🐺 ⏭️ 🙍🏻 WCF का उपयोग कर संदेश आधारित वेब सेवा SOAP का निर्माण 👩🏾‍🏭 🛁 👴🏼

मैं वास्तव में WCF को एक फ्रेमवर्क के रूप में पसंद करता हूं जो संचार परत के निर्माण को सरल बनाता है। लेकिन WCF की डिज़ाइन शैली मेरे अनुरूप नहीं है। मुझे लगता है कि प्रत्येक डीटीओ के लिए एक नया तरीका बनाना एक अच्छा समाधान नहीं है, इसलिए मैंने इस समस्या को हल करने की कोशिश की।

WCF की कुछ सीमाएँ हैं:

ओवरलोडिंग में विधि का समर्थन नहीं करता है।
यह एक सार्वभौमिक एपीआई नहीं है।
सेवा अनुबंध व्यावसायिक आवश्यकताओं पर निर्भर करता है।
संस्करण को डेटाकंट्रेक्ट और विधियों के स्तर पर किया जाना चाहिए, ऑपरेशन का नाम सार्वभौमिक होना चाहिए।
अन्य गैर- .NET क्लाइंट्स के पास उतने क्लाइंट होने चाहिए जितने की आपकी सेवाएं हैं।

मुझे लगता है कि RPC (दूरस्थ प्रक्रिया कॉल) शैली दृष्टिकोण सबसे उपयुक्त नहीं है। सेवा पुन: प्रयोज्य होनी चाहिए, और उस पर व्यावसायिक आवश्यकताओं का प्रभाव न्यूनतम होना चाहिए। मुझे लगता है कि दूरस्थ एपीआई को निम्नलिखित आवश्यकताओं को पूरा करना चाहिए:

एक स्थिर और बहुमुखी इंटरफ़ेस है।
डीटीओ पैटर्न के अनुसार डेटा ट्रांसफर करें।

एक संदेश-आधारित वेब सेवा एक संदेश अमूर्त जोड़कर WCF की अधिकांश सीमाओं को पार कर जाती है।

इस लेख को पढ़ने के बाद, आप सीखेंगे कि पुन: प्रयोज्य SOAP संदेश-आधारित वेब सेवाओं का निर्माण कैसे करें (और हर समय नए बनाना बंद करें)।

वेब सेवा डिजाइन

आइए आरपीसी-शैली के दृष्टिकोण, साथ ही संदेश आधारित दृष्टिकोण पर एक नज़र डालें।

आरपीसी डिजाइन

आरपीसी शैली का मुख्य विचार ग्राहकों को स्थानीय वस्तुओं के रूप में दूरस्थ सेवाओं के साथ काम करने का अवसर देना है। WCF में, एक ServiceContract क्लाइंट साइड पर उपलब्ध संचालन को परिभाषित करता है। उदाहरण के लिए:

[ServiceContract] public interface IRpcService { [OperationContract] void RegisterClient(Client client); [OperationContract] Client GetClientByName(string clientName); [OperationContract] List<Client> GetAllClients(); }

सेवा अनुबंध बहुत सरल है और इसमें तीन ऑपरेशन शामिल हैं। हमें सेवा अनुबंध में किसी भी परिवर्तन के बाद क्लाइंट को बदलना होगा (उदाहरण के लिए, किसी ऑपरेशन को जोड़ना या निकालना, ऑपरेशन के हस्ताक्षर को बदलना)। एक वास्तविक एप्लिकेशन में 10 से अधिक ऑपरेशन हो सकते हैं, इसलिए एक सेवा को बनाए रखना और ग्राहकों को बहुत समय लगता है।

संदेश आधारित डिजाइन

संदेश-आधारित दृष्टिकोण डेटा ट्रांसफर ऑब्जेक्ट और गेटवे पैटर्न पर आधारित है। डीटीओ में संचार के लिए आवश्यक सभी डेटा हैं, और गेटवे संचार प्रक्रिया से आवेदन को अलग करता है। इसलिए एक संदेश-आधारित सेवा एक अनुरोध संदेश प्राप्त करती है और एक प्रतिक्रिया संदेश देती है। आइए अमेज़ॅन एपीआई से एक उदाहरण देखें।

अनुरोध उदाहरण:

 https://ec2.amazonaws.com/?Action=AllocateAddress Domain=vpc &AUTHPARAMS

उत्तर उदाहरण:

 <AllocateAddressResponse xmlns="http://ec2.amazonaws.com/doc/2013-02-01/"> <requestId>59dbff89-35bd-4eac-99ed-be587EXAMPLE</requestId> <publicIp>198.51.100.1</publicIp> <domain>vpc</domain> <allocationId>eipalloc-5723d13e</allocationId> </AllocateAddressResponse>

इस प्रकार, सेवा अनुबंध कुछ इस तरह दिखना चाहिए:

 public interface IMessageBasedService { Response Execute(Request request); }

जहां Request

और Response

कोई भी डीटीओ हो सकता है, यानी एक विधि से हम किसी भी आरपीसी सेवा अनुबंध को बदल सकते हैं, लेकिन डब्ल्यूसीएफ आरपीसी शैली का उपयोग करता है।

संदेश आधारित शैली

जैसा कि आप पहले से ही जानते हैं, एक संदेश-आधारित वेब सेवा के लिए, हम किसी भी डीटीओ को प्रसारित करने के लिए Request

और Response

वस्तुओं का उपयोग कर सकते हैं। लेकिन WCF इस डिजाइन का समर्थन नहीं करता है। WCF में सभी संचार इंटर्न संदेश वर्ग के उपयोग पर आधारित हैं। अर्थात्, WCF किसी भी DTO को एक Message

उदाहरण में परिवर्तित करता है और क्लाइंट से सर्वर पर एक Message

भेजता है। इसलिए, हमें Request

और Response

वस्तुओं के लिए Message

वर्ग का उपयोग करना चाहिए।

निम्नलिखित सेवा अनुबंध Response

ऑब्जेक्ट के साथ और उसके बिना संचार का वर्णन करता है।

 [ServiceContract] public interface ISoapService { [OperationContract(Action = ServiceMetadata.Action.ProcessOneWay)] void ProcessOneWay(Message message); [OperationContract(Action = ServiceMetadata.Action.Process, ReplyAction = ServiceMetadata.Action.ProcessResponse)] Message Process(Message message); }

ISoapService

हमें किसी भी डेटा को स्थानांतरित करने की अनुमति देता है, लेकिन यह पर्याप्त नहीं है। हम वस्तुओं को बनाना, हटाना और उस पर तरीकों को लागू करना चाहते हैं। मेरे लिए, सबसे अच्छा विकल्प ऑब्जेक्ट पर CRUD ऑपरेशन है, इसलिए हम किसी भी ऑपरेशन को लागू कर सकते हैं। सबसे पहले, एक SoapServiceClient

बनाएं जो किसी भी डीटीओ को भेज और प्राप्त कर सकता है।

साबुन सेवा ग्राहक

SoapServiceClient

किसी भी डीटीओ से Message

बनाने का तरीका दिखाएगा। SoapServiceClient

एक आवरण है जो किसी भी डीटीओ को Message

में परिवर्तित करता है और इसे सेवा में भेजता है। आपके द्वारा भेजे गए संदेश में निम्न डेटा है:

डीटीओ
डीटीओ प्रकार सर्वर-साइड डिसेरलाइज़ेशन के लिए आवश्यक है
सर्वर साइड पर कॉल की जाने वाली विधि।

हमारा लक्ष्य SOAP वेब सेवा के लिए एक पुन: प्रयोज्य ग्राहक बनाना है, जो किसी भी अनुरोध / प्रतिक्रिया को भेजने / प्राप्त करने और ऑब्जेक्ट पर कोई भी संचालन करने में सक्षम होगा। जैसा कि पहले उल्लेख किया गया है, CRUD इसके लिए सबसे उपयुक्त है, इसलिए ग्राहक कुछ इस तरह दिख सकता है:

 var client = new SoapServiceClient("NeliburSoapService"); ClientResponse response = client.Post<ClientResponse>(createRequest); response = client.Put<ClientResponse>(updateRequest);

नीचे SoapServiceClient

वर्ग की Post

विधि के लिए सभी कोड है।

 public TResponse Post<TResponse>(object request) { return Send<TResponse>(request, OperationTypeHeader.Post); } private TResponse Send<TResponse>(object request, MessageHeader operationType) { using (var factory = new ChannelFactory<ISoapService>(_endpointConfigurationName)) { MessageVersion messageVersion = factory.Endpoint.Binding.MessageVersion; Message message = CreateMessage(request, operationType, messageVersion); ISoapService channel = factory.CreateChannel(); Message result = channel.Process(message); return result.GetBody<TResponse>(); } } private static Message CreateMessage( object request, MessageHeader actionHeader, MessageVersion messageVersion) { Message message = Message.CreateMessage( messageVersion, ServiceMetadata.Operations.Process, request); var contentTypeHeader = new ContentTypeHeader(request.GetType()); message.Headers.Add(contentTypeHeader); message.Headers.Add(actionHeader); return message; }

कृपया CreateMessage

मेथड पर ध्यान CreateMessage

और कैसे DTO टाइप और कॉल की गई सामग्री contentTypeHeader

और actionHeader

माध्यम से contentTypeHeader

actionHeader

।

SoapContentTypeHeader

और SoapOperationTypeHeader

लगभग समान हैं। SoapContentTypeHeader

उपयोग DTO प्रकार को स्थानांतरित करने के लिए किया जाता है, और SoapOperationTypeHeader

का उपयोग लक्ष्य ऑपरेशन को प्रसारित करने के लिए किया जाता है। कम शब्द, अधिक कोड:

 internal sealed class SoapContentTypeHeader : MessageHeader { private const string NameValue = "nelibur-content-type"; private const string NamespaceValue = "http://nelibur.org/" + NameValue; private readonly string _contentType; public SoapContentTypeHeader(Type contentType) { _contentType = contentType.Name; } public override string Name { get { return NameValue; } } public override string Namespace { get { return NamespaceValue; } } public static string ReadHeader(Message request) { int headerPosition = request.Headers.FindHeader(NameValue, NamespaceValue); if (headerPosition == -1) { return null; } var content = request.Headers.GetHeader<string>(headerPosition); return content; } protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) { writer.WriteString(_contentType); } }

निम्नलिखित SoapServiceClient

तरीके हैं:

 public static TResponse Get<TResponse>(object request) public static Task<TResponse> GetAsync<TResponse>(object request) public static void Post(object request) public static Task PostAsync(object request) public static TResponse Post<TResponse>(object request) public static Task<TResponse> PostAsync<TResponse>(object request) public static void Put(object request) public static Task PutAsync(object request) public static TResponse Put<TResponse>(object request) public static Task<TResponse> PutAsync<TResponse>(object request) public static void Delete(object request) public static Task DeleteAsync(object request)

जैसा कि आपने पहले ही देखा है, सभी CRUD ऑपरेशन में अतुल्यकालिक संस्करण हैं।

SOAP सेवा

SOAP सेवा में सक्षम होना चाहिए:

संदेश से एक विशिष्ट अनुरोध बनाएँ
अनुरोध पर लक्ष्य विधि को कॉल करें
यदि आवश्यक हो, तो प्रतिक्रिया से एक संदेश बनाएं और वापस करें

हमारा लक्ष्य कुछ ऐसा बनाना है जो किसी विशेष Request

लिए उपयुक्त CRUD विधि को बुलाएगा। नीचे दिए गए उदाहरण से पता चलता है कि आप Client

ऑब्जेक्ट कैसे जोड़ और प्राप्त कर सकते हैं।

 public sealed class ClientProcessor : IPut<CreateClientRequest>, IGet<GetClientRequest> { private readonly List<Client> _clients = new List<Client>(); public object Get(GetClientRequest request) { Client client = _clients.Single(x => x.Id == request.Id); return new ClientResponse {Id = client.Id, Name = client.Name}; } public object Put(CreateClientRequest request) { var client = new Client { Id = Guid.NewGuid(), Name = request.Name }; _clients.Add(client); return new ClientResponse {Id = client.Id}; } }

सबसे अधिक रुचि IGet

और IGet

IPost

। वे CRUD ऑपरेशन का प्रतिनिधित्व करते हैं। वर्ग आरेख पर एक नज़र डालें:

अब आपको Request

को संबंधित CRUD ऑपरेशन के साथ जोड़ना होगा। अनुरोध प्रोसेसर के साथ Request

को संबद्ध करने का सबसे आसान तरीका है। NeliburService

इस कार्यक्षमता के लिए प्रतिष्ठित है। आइए इसे देखें।

 public abstract class NeliburService { internal static readonly RequestMetadataMap _requests = new RequestMetadataMap(); protected static readonly Configuration _configuration = new Configuration(); private static readonly RequestProcessorMap _requestProcessors = new RequestProcessorMap(); protected static void ProcessOneWay(RequestMetadata requestMetaData) { IRequestProcessor processor = _requestProcessors.Get(requestMetaData.Type); processor.ProcessOneWay(requestMetaData); } protected static Message Process(RequestMetadata requestMetaData) { IRequestProcessor processor = _requestProcessors.Get(requestMetaData.Type); return processor.Process(requestMetaData); } protected sealed class Configuration : IConfiguration { public void Bind<TRequest, TProcessor>(Func<TProcessor> creator) where TRequest : class where TProcessor : IRequestOperation { if (creator == null) { throw Error.ArgumentNull("creator"); } _requestProcessors.Add<TRequest, TProcessor>(creator); _requests.Add<TRequest>(); } public void Bind<TRequest, TProcessor>() where TRequest : class where TProcessor : IRequestOperation, new() { Bind<TRequest, TProcessor>(() => new TProcessor()); } } }

RequestMetadataMap

उपयोग Request

ऑब्जेक्ट के प्रकार को संग्रहीत करने के लिए किया जाता है जो Message

से एक विशिष्ट Request

बनाने के लिए आवश्यक है।

 internal sealed class RequestMetadataMap { private readonly Dictionary<string, Type> _requestTypes = new Dictionary<string, Type>(); internal void Add<TRequest>() where TRequest : class { Type requestType = typeof(TRequest); _requestTypes[requestType.Name] = requestType; } internal RequestMetadata FromRestMessage(Message message) { UriTemplateMatch templateMatch = WebOperationContext.Current.IncomingRequest.UriTemplateMatch; NameValueCollection queryParams = templateMatch.QueryParameters; string typeName = UrlSerializer.FromQueryParams(queryParams).GetTypeValue(); Type targetType = GetRequestType(typeName); return RequestMetadata.FromRestMessage(message, targetType); } internal RequestMetadata FromSoapMessage(Message message) { string typeName = SoapContentTypeHeader.ReadHeader(message); Type targetType = GetRequestType(typeName); return RequestMetadata.FromSoapMessage(message, targetType); } private Type GetRequestType(string typeName) { Type result; if (_requestTypes.TryGetValue(typeName, out result)) { return result; } string errorMessage = string.Format( "Binding on {0} is absent. Use the Bind method on an appropriate NeliburService", typeName); throw Error.InvalidOperation(errorMessage); } }

RequestProcessorMap

हैंडलर के लिए Request

ऑब्जेक्ट के प्रकार को बांधता है।

 internal sealed class RequestProcessorMap { private readonly Dictionary<Type, IRequestProcessor> _repository = new Dictionary<Type, IRequestProcessor>(); public void Add<TRequest, TProcessor>(Func<TProcessor> creator) where TRequest : class where TProcessor : IRequestOperation { Type requestType = typeof(TRequest); IRequestProcessor context = new RequestProcessor<TRequest, TProcessor>(creator); _repository[requestType] = context; } public IRequestProcessor Get(Type requestType) { return _repository[requestType]; } }

अब हम अंतिम चरण के लिए तैयार हैं: लक्ष्य पद्धति को कॉल करना। यहाँ हमारी SOAP सेवा है:

 [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)] public sealed class SoapService : ISoapService { public Message Process(Message message) { return NeliburSoapService.Process(message); } public void ProcessOneWay(Message message) { NeliburSoapService.ProcessOneWay(message); } }

सबसे पहले, आइए सेवा की ओर से निष्पादन की प्रक्रिया का वर्णन करने वाले अनुक्रम आरेख को देखें।

अनुक्रम चार्ट

कोड चरण में गोता लगाते हैं। NeliburSoapService

सिर्फ एक और कोड निष्पादित करता है, इस पर एक नज़र डालें।

 public sealed class NeliburSoapService : NeliburService { private NeliburSoapService() { } public static IConfiguration Configure(Action<IConfiguration> action) { action(_configuration); return _configuration; } public static Message Process(Message message) { RequestMetadata metadata = _requests.FromSoapMessage(message); return Process(metadata); } public static void ProcessOneWay(Message message) { RequestMetadata metadata = _requests.FromSoapMessage(message); ProcessOneWay(metadata); } }

NeliburSoapService

केवल NeliburSoapService

को सजाता है, अर्थात, यह SOAP Message

लिए RequestMetadata

बनाने के लिए उपयुक्त विधि कहता है।

सबसे दिलचस्प बात यहाँ हो रही है:

 RequestMetadata requestMetaData = _requests.FromSoapMessage(message)

 context.Process(requestMetaData).

SoapRequestMetadata मुख्य वस्तु है जो CRUD ऑपरेशन के प्रकार, डेटा का अनुरोध, इसके प्रकार को जोड़ती है, और एक अनुरोध का जवाब भी दे सकती है।

 internal sealed class SoapRequestMetadata : RequestMetadata { private readonly MessageVersion _messageVersion; private readonly object _request; internal SoapRequestMetadata(Message message, Type targetType) : base(targetType) { _messageVersion = message.Version; _request = CreateRequest(message, targetType); OperationType = SoapOperationTypeHeader.ReadHeader(message); } public override string OperationType { get; protected set; } public override Message CreateResponse(object response) { return Message.CreateMessage(_messageVersion, SoapServiceMetadata.Action.ProcessResponse, response); } public override TRequest GetRequest<TRequest>() { return (TRequest)_request; } private static object CreateRequest(Message message, Type targetType) { using (XmlDictionaryReader reader = message.GetReaderAtBodyContents()) { var serializer = new DataContractSerializer(targetType); return serializer.ReadObject(reader); } } }

और अंत में, हम सिर्फ RequestProcessor

माध्यम से संबंधित CRUD ऑपरेशन को कॉल करते हैं। RequestProcessor

ऑपरेशन को निर्धारित करने के लिए RequestProcessor

का उपयोग करता है और जब यह SoapServiceClient

वर्ग के लिए परिणाम देता है तो इसे कॉल करता है।

 internal sealed class RequestProcessor<TRequest, TProcessor> : IRequestProcessor where TRequest : class where TProcessor : IRequestOperation { private readonly Func<TProcessor> _creator; public RequestProcessor(Func<TProcessor> creator) { _creator = creator; } public Message Process(RequestMetadata metadata) { switch (metadata.OperationType) { case OperationType.Get: return Get(metadata); case OperationType.Post: return Post(metadata); case OperationType.Put: return Put(metadata); case OperationType.Delete: return Delete(metadata); default: string message = string.Format("Invalid operation type: {0}", metadata.OperationType); throw Error.InvalidOperation(message); } } public void ProcessOneWay(RequestMetadata metadata) { switch (metadata.OperationType) { case OperationType.Get: GetOneWay(metadata); break; case OperationType.Post: PostOneWay(metadata); break; case OperationType.Put: PutOneWay(metadata); break; case OperationType.Delete: DeleteOneWay(metadata); break; default: string message = string.Format("Invalid operation type: {0}", metadata.OperationType); throw Error.InvalidOperation(message); } } private Message Delete(RequestMetadata metadata) { var service = (IDelete<TRequest>)_creator(); var request = metadata.GetRequest<TRequest>(); object result = service.Delete(request); return metadata.CreateResponse(result); } private void DeleteOneWay(RequestMetadata metadata) { var service = (IDeleteOneWay<TRequest>)_creator(); var request = metadata.GetRequest<TRequest>(); service.DeleteOneWay(request); } private Message Get(RequestMetadata metadata) { var service = (IGet<TRequest>)_creator(); var request = metadata.GetRequest<TRequest>(); object result = service.Get(request); return metadata.CreateResponse(result); } private void GetOneWay(RequestMetadata metadata) { var service = (IGetOneWay<TRequest>)_creator(); var request = metadata.GetRequest<TRequest>(); service.GetOneWay(request); } private Message Post(RequestMetadata metadata) { var service = (IPost<TRequest>)_creator(); var request = metadata.GetRequest<TRequest>(); object result = service.Post(request); return metadata.CreateResponse(result); } private void PostOneWay(RequestMetadata metadata) { var service = (IPostOneWay<TRequest>)_creator(); var request = metadata.GetRequest<TRequest>(); service.PostOneWay(request); } private Message Put(RequestMetadata metadata) { var service = (IPut<TRequest>)_creator(); var request = metadata.GetRequest<TRequest>(); object result = service.Put(request); return metadata.CreateResponse(result); } private void PutOneWay(RequestMetadata metadata) { var service = (IPutOneWay<TRequest>)_creator(); var request = metadata.GetRequest<TRequest>(); service.PutOneWay(request); } }

डेमो

सबसे पहले, डेटा अनुबंधों की घोषणा करें:

CreateClientRequest

- एक नया क्लाइंट बनाने के लिए अनुरोध करें
UpdateClientRequest

- ईमेल क्लाइंट को अपडेट करने का अनुरोध
GetClientRequest

- आईडी द्वारा क्लाइंट के लिए अनुरोध
ग्राहक सूचना - ग्राहक सूचना
RemoveClientRequest

- क्लाइंट हटाने का अनुरोध

सर्वर का पक्ष

कॉन्फ़िगरेशन फ़ाइल सबसे आम है:

 <configuration> <!--WCF--> <system.serviceModel> <services> <service name="Nelibur.ServiceModel.Services.Default.SoapServicePerCall"> <endpoint address="http://localhost:5060/service" binding="basicHttpBinding" bindingConfiguration="ServiceBinding" contract="Nelibur.ServiceModel.Contracts.ISoapService" /> </service> </services> <bindings> <basicHttpBinding> <binding name="ServiceBinding"> <security mode="None"> <transport clientCredentialType="None" /> </security> </binding> </basicHttpBinding> </bindings> </system.serviceModel> <startup> <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /> </startup> </configuration>

WCF सेवा अत्यंत सरल है:

 [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)] public sealed class SoapServicePerCall : ISoapService { /// <summary> /// Process message with response. /// </summary> /// <param name="message">Request message.</param> /// <returns>Response message.</returns> public Message Process(Message message) { return NeliburSoapService.Process(message); } /// <summary> /// Process message without response. /// </summary> /// <param name="message">Request message.</param> public void ProcessOneWay(Message message) { NeliburSoapService.ProcessOneWay(message); } }

हैंडलर से सभी अनुरोधों को बांधना। सादगी के लिए, मैंने केवल एक अनुरोध हैंडलर बनाया। आप जितने चाहें उतने अनुरोध कर सकते हैं। मैं आपको CQRS पर मार्टिन फाउलर के लेख को पढ़ने की सलाह देता हूं। इससे आपको सही चुनाव करने में मदद मिलेगी। अनुरोधों और संचालकों को जोड़ने के लिए कोड:

 private static void BindRequestToProcessors() { NeliburSoapService.Configure(x => { x.Bind<CreateClientRequest, ClientProcessor>(); x.Bind<UpdateClientRequest, ClientProcessor>(); x.Bind<DeleteClientRequest, ClientProcessor>(); x.Bind<GetClientRequest, ClientProcessor>(); }); }

और अंत में, ClientProcessor

:

 public sealed class ClientProcessor : IPost<CreateClientRequest>, IGet<GetClientRequest>, IDeleteOneWay<DeleteClientRequest>, IPut<UpdateClientRequest> { private static List<Client> _clients = new List<Client>(); public void DeleteOneWay(DeleteClientRequest request) { Console.WriteLine("Delete Request: {0}\n", request); _clients = _clients.Where(x => x.Id != request.Id).ToList(); } public object Get(GetClientRequest request) { Console.WriteLine("Get Request: {0}", request); Client client = _clients.Single(x => x.Id == request.Id); return new ClientResponse { Id = client.Id, Email = client.Email }; } public object Post(CreateClientRequest request) { Console.WriteLine("Post Request: {0}", request); var client = new Client { Id = Guid.NewGuid(), Email = request.Email }; _clients.Add(client); return new ClientResponse { Id = client.Id, Email = client.Email }; } public object Put(UpdateClientRequest request) { Console.WriteLine("Put Request: {0}", request); Client client = _clients.Single(x => x.Id == request.Id); client.Email = request.Email; return new ClientResponse { Id = client.Id, Email = client.Email }; } }

ग्राहक का पक्ष

ग्राहक कोड सरल है:

 private static void Main() { var client = new SoapServiceClient("NeliburSoapService"); var createRequest = new CreateClientRequest { Email = "email@email.com" }; Console.WriteLine("POST Request: {0}", createRequest); ClientResponse response = client.Post<ClientResponse>(createRequest); Console.WriteLine("POST Response: {0}\n", response); var updateRequest = new UpdateClientRequest { Email = "new@email.com", Id = response.Id }; Console.WriteLine("PUT Request: {0}", updateRequest); response = client.Put<ClientResponse>(updateRequest); Console.WriteLine("PUT Response: {0}\n", response); var getClientRequest = new GetClientRequest { Id = response.Id }; Console.WriteLine("GET Request: {0}", getClientRequest); response = client.Get<ClientResponse>(getClientRequest); Console.WriteLine("GET Response: {0}\n", response); var deleteRequest = new DeleteClientRequest { Id = response.Id }; Console.WriteLine("DELETE Request: {0}", deleteRequest); client.Delete(deleteRequest); Console.ReadKey(); }

निष्पादन परिणाम:

ग्राहक:

सेवा:

वह सब

मुझे आशा है कि आपको अच्छा लगा होगा। यहां आप सीख सकते हैं कि WCF और Nelibur पर Restful वेब सेवाओं का निर्माण कैसे करें । लेख (अनुवाद) पढ़ने के लिए धन्यवाद। स्रोतों को मूल पृष्ठ या GitHub से डाउनलोड किया जा सकता है ।

WCF का उपयोग कर संदेश आधारित वेब सेवा SOAP का निर्माण