हम अपना सिंक्रोनस / एसिंक्रोनस क्लाइंट सर्वर लिखते हैं

सभी को नमस्कार।

इस लेख में, हम एक बहु-थ्रेडेड टीसीपी एप्लिकेशन सर्वर के सिद्धांत पर विचार करेंगे जिसमें हम सिंक्रोनस और एसिंक्रोनस कॉल को लागू करते हैं, साथ ही प्रक्रियाओं और डेटा को संपीड़ित करने के लिए अलग-अलग उपयोग करते हैं।

यह सब कैसे शुरू हुआ।
यह सब एक मुश्किल विकल्प के साथ शुरू हुआ जहां इंटरनेट के माध्यम से काम करने वाले कई अलग-अलग अनुप्रयोगों के बीच बातचीत को लागू करना शुरू करना है। ऐसा लगता है कि डब्ल्यूसीएफ इस तरह की समस्या को हल करने में सक्षम है, लेकिन, दुर्भाग्य से, यह कमियों और कुछ समस्याओं के बिना नहीं है, और इसके संचालन का सिद्धांत डेटा ट्रांसफर गति को बहुत प्रभावित करता है। एक सरल समाधान की आवश्यकता थी और एक ही समय में काफी कार्यात्मक।

हम अपनी परियोजना एक कक्षा पुस्तकालय के साथ शुरू करते हैं जिसमें हम विभिन्न प्रकार के अनुप्रयोगों के लिए प्रक्रियाओं और कार्यों के इंटरफेस बनाते हैं।

public interface ICommon { string[] GetAvailableUsers(); void ChangePrivileges(string Login, string password); } public interface IDog { bool TryFindObject(out object obj); int Bark(int nTimes); } public interface ICat { void CutTheText(ref string Text); } 

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

यहां हम एक वर्ग बनाते हैं जिसके साथ हम सर्वर और क्लाइंट के बीच डेटा का आदान-प्रदान करेंगे।

 [Serializable] public class Message { public Message(string Command, object[] Parameters) { this.Command = Command; if (Parameters != null) this.prms = Parameters; } public bool IsSync; public bool IsEmpty = true; public readonly string Command; public object ReturnValue; public object[] prms; public Exception Exception; } 

ग्राहक

क्लाइंट इंटरफ़ेस विधियों और सर्वर के बीच एक प्रॉक्सी कनेक्शन लागू करेगा। ऐसा करने के लिए, एक ऐसा वर्ग बनाएं जो परदे के पीछे लागू हो:

 private class Proxy<T> : RealProxy where T : class { UniservClient client; public Proxy(UniservClient client): base(typeof(T)) { this.client = client; } public override IMessage Invoke(IMessage msg) { IMethodCallMessage call = (IMethodCallMessage)msg; object[] parameters = call.Args; int OutArgsCount = call.MethodBase.GetParameters().Where(x => x.IsOut).Count(); Message result = client.Execute(call.MethodName, parameters); parameters = parameters.Select((x, index) => result.prms[index] ?? x).ToArray(); return new ReturnMessage(result.ReturnValue, parameters, OutArgsCount, call.LogicalCallContext, call); } } 

और इंटरफ़ेस विधियों तक पहुँचने के लिए गुण बनाएँ:

 public ICommon Common { get; private set; } public IDog Dog { get; private set; } public ICat Cat { get; private set; } 

प्रारंभिक परदे के पीछे और गुण:

 CommonProxy = new Proxy<ICommon>(this); DogProxy = new Proxy<IDog>(this); CatProxy = new Proxy<ICat>(this); Common = (ICommon)CommonProxy.GetTransparentProxy(); Dog = (IDog)DogProxy.GetTransparentProxy(); Cat = (ICat)CatProxy.GetTransparentProxy(); 

सर्वर आदेश संसाधित करना:

 private void Listener() { while (true) { try { if (ListenerToken.IsCancellationRequested) return; if (!IsConnected) _Connect(); while (true) { if (ListenerToken.IsCancellationRequested) return; Message msg = ReceiveData<Message>(); if (msg.Command == "OnPing") { //   SendData(msg); if (Events.OnPing != null) Events.OnPing.BeginInvoke(null, null); continue; } if (msg.IsSync) { //     SyncResult(msg); } else { //    try { //   Action var pi = typeof(IEvents).GetProperty(msg.Command, BindingFlags.Instance | BindingFlags.Public); if (pi == null) throw new Exception(string.Concat(" \"", msg.Command, "\"  ")); var delegateRef = pi.GetValue(this, null) as Delegate; //   if (delegateRef != null) ThreadPool.QueueUserWorkItem(state => delegateRef.DynamicInvoke(msg.prms)); } catch (Exception ex) { throw new Exception(string.Concat("    \"", msg.Command, "\""), ex); } } } } catch (TaskCanceledException) { return; } catch (Exception ex) { if (Events.OnError != null) Events.OnError.BeginInvoke(ex, null, null); } finally { _Dicsonnect(); } Thread.Sleep(2000); } } 

दूरस्थ प्रक्रिया निष्पादित करने के लिए निम्नलिखित विधियाँ जिम्मेदार हैं:

 private Message Execute(string MethodName, object[] parameters) { lock (syncLock) { _syncResult = new Message(MethodName, parameters); _syncResult.IsSync = true; _OnResponce.Reset(); SendData(_syncResult); _OnResponce.Wait(); //    if (_syncResult.IsEmpty) {//  ,    throw new Exception(string.Concat("      \"", MethodName, "\"")); } if (_syncResult.Exception != null) throw _syncResult.Exception; //    return _syncResult; } } private void SyncResult(Message msg) { //     _syncResult = msg; _syncResult.IsEmpty = false; _OnResponce.Set(); //   } 

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

सर्वर

आइए उन वर्गों का एक पदानुक्रम बनाएँ जो कुछ कार्यों की उपलब्धता का निर्धारण करेंगे:

 public class Cat_Ring0 : Ring2, ICat { public Cat_Ring0(User u) : base(u) { up.UserType = UserType.Cat; } public void CutTheText(ref string Text) { Text = Text.Remove(Text.Length - 1); } } public class Dog_Ring0 : Dog_Ring1, IDog { public Dog_Ring0(User u) : base(u) { up.UserType = UserType.Dog; } public int Bark(int nTimes) { var ConnectedDogs = ConnectedUsers.ToArray().Where(x => x.UserType == UserType.Dog).Select(x => x.nStream); ConnectedDogs.AsParallel().ForAll(nStream => { SendMessage(nStream, new Message("OnBark", new object[] { nTimes})); }); return ConnectedDogs.Count(); } } public class Dog_Ring1 : Ring2 { public Dog_Ring1(User u): base(u) { up.UserType = UserType.Dog; } public bool TryFindObject(out object obj) { obj = "TheBall"; return true; } } public class Ring2 : Ring, ICommon { public Ring2(User u) : base(u) { } public string[] GetAvailableUsers() { return new string[] { "Dog0", "Dog1", "Tom" }; } public void ChangePrivileges(string Animal, string password) { switch (Animal) { case "Dog0": if (password != "groovy!") throw new Exception("  "); up.ClassInstance = new Dog_Ring0(up); break; case "Dog1": if (password != "_password") throw new Exception("  "); up.ClassInstance = new Dog_Ring1(up); break; case "Tom": if (password != "TheCat") throw new Exception("  "); up.ClassInstance = new Cat_Ring0(up); break; default: throw new Exception("   "); } } } public abstract class Ring { public readonly User up; public Ring(User up) { this.up = up; } } 

अब यह प्रक्रिया को एक निश्चित "रिंग" में रखने के लिए पर्याप्त है ताकि संबंधित क्लाइंट के पास इसकी पहुंच हो। Ring0 पहुंच का शीर्ष स्तर है; इस प्रकार के उपयोगकर्ता के पास न केवल इसमें मौजूद प्रक्रियाओं तक पहुँच है, बल्कि सभी अंतर्निहित वर्गों में प्रक्रियाओं के लिए भी है। प्रारंभ में, उपयोगकर्ता रिंग 2 में समाप्त होता है, जो सभी के लिए उपलब्ध सामान्य तरीकों को लागू करता है। फिर, ChangePrivileges () का उपयोग करके , उपयोगकर्ता, प्राधिकरण के बाद, एक निश्चित स्तर की पहुंच के साथ एक निश्चित प्रकार के "रिंग" में मिल सकता है।

मुख्य सर्वर ऑपरेशन निम्न विधि में घटाया गया है:

 private void ProcessMessage(Message msg, User u) { string MethodName = msg.Command; if (MethodName == "OnPing") return; //        MethodInfo method = u.RingType.GetMethod(MethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy); try { if (method == null) { throw new Exception(string.Concat(" \"", MethodName, "\" ")); } try { //    msg.ReturnValue = method.Invoke(u.ClassInstance, msg.prms); } catch (Exception ex) { throw ex.InnerException; } //  ref  out  msg.prms = method.GetParameters().Select(x => x.ParameterType.IsByRef ? msg.prms[x.Position] : null).ToArray(); } catch (Exception ex) { msg.Exception = ex; } finally { //     SendMessage(u.nStream, msg); } } 

ClassInstance प्रॉपर्टी में "रिंग" का एक उदाहरण होता है जिसमें प्रक्रिया को उसके नाम से खोजा जाएगा।

उदाहरण रन लॉग:


परिणाम WCF के समान एक सरल और सुरुचिपूर्ण समाधान है।
स्रोत को यहां ले जाया जा सकता है