मल्टी क्लाइंट नेटवर्क प्रोटोकॉल C # में

प्रस्तावना

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



परियोजना को तीन भागों में विभाजित किया जा सकता है:

• सर्वर साइड
• ग्राहक भाग
• सर्वर और क्लाइंट के लिए सामान्य हिस्सा

सामान्य भाग

पैकेज

सभी पैकेजों के लिए सामान्य इंटरफ़ेस:

namespace Common { interface IPacket { void Write(BinaryWriter writer); //   } } 

एक सार वर्ग जो हमारे इंटरफ़ेस को विरासत में देता है:

 namespace Common { abstract class PacketBase : IPacket { protected PacketBase(int id) { this.Id = id; } public int Id { get; private set; } protected void WriteHeader(BinaryWriter writer) { writer.Write(this.Id); } //    protected virtual void WriteBody(BinaryWriter writer) { } //    public void Write(BinaryWriter writer) { this.WriteHeader(writer); this.WriteBody(writer); } //    } } 

पैकेज हैंडलर

सभी हैंडलर के लिए सामान्य इंटरफ़ेस:

 namespace Common { interface IPacketHandler : ICloneable { void Read(); //  void Handle(); //  } } 

एक सार वर्ग जो पैकेज हैंडलर इंटरफ़ेस को विरासत में मिला है।

 namespace Common { abstract class PacketHandlerBase : IPacketHandler { public PacketHandlerBase() { } public BinaryReader Reader { get; set; } public object Context { get; set; } public virtual void Read() { } //  public virtual void Handle() { } //  public abstract Object Clone(); //,    } } 

संदर्भ वह वस्तु है जो कनेक्शन पैकेट संचालकों के लिए उपयोगी जानकारी के साथ जुड़ा हुआ है। प्रत्येक हैंडलर को इस संदर्भ ऑब्जेक्ट का लिंक प्राप्त होगा और यदि वह चाहे तो इसका उपयोग कर सकता है।

हैंडलर की दुकान

 namespace Common { class PacketHandlerStorage { public PacketHandlerStorage() { this._storage = new Dictionary(); } private Dictionary _storage; public PacketHandlerBase GetHandlerById(int id) { PacketHandlerBase x = this._storage[id]; return (PacketHandlerBase)x.Clone(); //      Clone } public void AddHandler(int id, PacketHandlerBase handler) { this._storage.Add(id, handler); } } } 

GetHandlerById विधि आईडी द्वारा संबंधित पैकेट हैंडलर लौटाती है। AddHandler रिपॉजिटरी में एक हैंडलर जोड़ता है।

पढ़ने और प्रसंस्करण पैकेज के लिए कक्षा

 namespace Common { class InputProcessor { public InputProcessor(NetworkStream stream, Connection connection, PacketHandlerStorage handlers) { this._connection = connection; this._stream = stream; this.Handlers = handlers; Reader = new BinaryReader(this._stream); this._started = false; } private NetworkStream _stream; private Connection _connection; //   private Thread _newThread; private BinaryReader Reader; private bool _started; public PacketHandlerStorage Handlers { get; set; } private void _handlePacket() { int id = Reader.ReadInt32(); // id  PacketHandlerBase handler = this.Handlers.GetHandlerById(id); //  handler.Reader = this.Reader; handler.Read(); //  this._connection.Receive(handler); //  } private void _worker() { while (!this._started) { _handlePacket(); } } public void Run() { this._newThread = new Thread(this._worker); this._newThread.Start(); } } } 

कंस्ट्रक्टर नेटवर्क स्ट्रीम, कनेक्शन वर्ग की वस्तु और हैंडलर के भंडारण की वस्तु को स्वीकार करता है। _handlePacket पैकेज की आईडी पढ़ता है, अपने हैंडलर को प्राप्त करता है, रीड और प्रोसेस विधि को कॉल करता है। एक लूप में _worker _handlePacket कहता है। रन विधि एक थ्रेड बनाता है और इसमें _worker प्रारंभ करता है।

पैकेज रिकॉर्ड क्लास

 namespace Common { class OutputProccessor { public OutputProccessor(NetworkStream stream) { this._stream = stream; _writer = new BinaryWriter(this._stream); this.Packets = new Queue(); this._lock = new ManualResetEvent(true); } private Thread _newThread; private NetworkStream _stream; private BinaryWriter _writer; private Queue Packets; private ManualResetEvent _lock; private void _worker() { while (true) { this._lock.WaitOne(); if (this.Packets.Count > 0) //      this.Packets.Dequeue().Write(this._writer); //  else this._lock.Reset(); } } public void Send(PacketBase packet) //   { this.Packets.Enqueue(packet); this._lock.Set(); } public void Run() { this._newThread = new Thread(this._worker); this._newThread.Start(); } } } 

_Work विधि में, पैकेट भेजने की विधि को लूप में कहा जाता है, बशर्ते कि 0. से अधिक हो। एक अलग थ्रेड में रन विधि _worker शुरू होती है।

कनेक्शन वर्ग

कक्षा कनेक्शन। नाम से यह स्पष्ट है कि यह कनेक्शन के संचालन के लिए जिम्मेदार वर्ग है।

 namespace Common { class Connection { public Connection(TcpClient client, PacketHandlerStorage handlers) { this._client = client; this.Stream = this._client.GetStream(); this._inputProccessor = new InputProcessor(this.Stream, this, handlers); this._outputProccessor = new OutputProccessor(this.Stream); } private TcpClient _client; private InputProcessor _inputProccessor; //  /  private OutputProccessor _outputProccessor; //    public NetworkStream Stream { get; private set; } public object Context { get; set; } public void Run() { this._inputProccessor.Run(); this._outputProccessor.Run(); } public void Send(PacketBase packet) { this._outputProccessor.Send(packet); } public void Receive(PacketHandlerBase handler) { handler.Context = this.Context; handler.Handle(); } } } 

TcpClient और हैंडलर स्टोरेज ऑब्जेक्ट कंस्ट्रक्टर में स्वीकार किए जाते हैं। रन विधि पैकेट धाराओं को पढ़ना और भेजना शुरू कर देती है। भेजें विधि एक पैकेट भेजता है। प्राप्तकर्ता विधि में, मूल उदाहरण हैंडलर संदर्भ के लिए लिखा जाता है और प्रसंस्करण विधि कहा जाता है।

सर्वर साइड

ग्राहक का संदर्भ

कनेक्शन वर्ग कनेक्शन के संचालन के लिए जिम्मेदार है, क्लाइंट से सर्वर तक और इसके विपरीत। हैंडलर के पास एक संदर्भ क्षेत्र है जिसमें कनेक्शन उदाहरण संग्रहीत है। सर्वर के लिए ClientContext वर्ग।

 namespace Server { class ClientContext { public ClientContext(Connection connection) { this.Connection = connection; } public Connection Connection { get; set; } } } 

ClientContextFactory

ClientContextFactory वर्ग का उपयोग कनेक्शन ऑब्जेक्ट द्वारा एक नया ClientContext ऑब्जेक्ट प्राप्त करने के लिए किया जाता है।

 namespace Server { class ClientContextFactory : ContextFactory { public override object MakeContext(Connection connection) { return new ClientContext(connection); } } } 

प्रोटोकॉल संस्करण वर्ग

ServerHandlersV1 हैंडलर स्टोर वारिस। कंस्ट्रक्टर में हैंडलर जोड़े जाते हैं। इस प्रकार, आप विभिन्न पैकेट संचालकों के साथ प्रोटोकॉल के विभिन्न संस्करण बना सकते हैं और PacketHandlerStorage के बजाय आवश्यक प्रोटोकॉल संस्करण के वर्ग को प्रतिस्थापित कर सकते हैं।

 namespace Server { class ServerHandlersV1 : PacketHandlerStorage { public ServerHandlersV1() { //AddHandler(0, new SomePacketHandler1()); //AddHandler(1, new SomePacketHandler2()); } } } 

सर्वर

 namespace Server { class Server { public Server(int port, ContextFactory contextFactory) { this.Port = port; this.Started = false; this._contextFactory = contextFactory; this._connectios = new List(); } private Thread _newThread; private TcpListener _listner; private List _connectios; //  public int Port { get; set; } public bool Started { get; private set; } public PacketHandlerStorage Handlers { get; set; } //  private ContextFactory _contextFactory { get; set; } private void _worker() { this._listner = new TcpListener(IPAddress.Any, this.Port); this._listner.Start(); this.Started = true; while (this.Started) { TcpClient client = this._listner.AcceptTcpClient(); Connection connection = new Connection(client, this.Handlers); connection.Context = this._contextFactory.MakeContext(connection); connection.Run(); this._connectios.Add(connection); } } public void Run() { this._newThread = new Thread(this._worker); this._newThread.Start(); } } } 

कंस्ट्रक्टर पोर्ट और प्रोटोकॉल संस्करण को स्वीकार करता है। _वर्कर विधि में, हम tcpListner शुरू करते हैं। फिर क्लाइंट को लूप में स्वीकार किया जाता है, कनेक्शन ऑब्जेक्ट और उसके संदर्भ बनाए जाते हैं, कनेक्शन लॉन्च किया जाता है और कनेक्शन की सूची में जोड़ा जाता है। रन विधि एक थ्रेड बनाता है और इसमें _worker प्रारंभ करता है।

ग्राहक भाग

प्रोटोकॉल संस्करण वर्ग

हैंडलर स्टोर का उत्तराधिकारी ClientHandlersV1 है।

 namespace Client { class ClientHandlersV1 : PacketHandlerStorage { public ClientHandlersV1() { //AddHandler(0, new SomePacketHandler1()); //AddHandler(1, new SomePacketHandler2()); } } } 

ग्राहक

 namespace Client { class Client { public Client(string ip, int port, PacketHandlerStorage handlers) { this._tcpClient = new TcpClient(ip, port); this._connection = new Connection(this._tcpClient, handlers); this._connection.Context = this; this._connection.Run(); } private TcpClient _tcpClient; private Connection _connection; } } 

कंस्ट्रक्टर आईपी, पोर्ट और आवश्यक प्रोटोकॉल संस्करण के क्लास ऑब्जेक्ट को स्वीकार करता है, और एक कनेक्शन स्थापित होता है।

उदाहरण

सिंपल कंसोल चैट।

सर्वर

 namespace Chat_server { class Program { public static Server.Server Server { get; set; } //  public static List<string> Contacts { get; set; } //    static void Main(string[] args) { Contacts = new List<string>(); Server = new Server.Server(1698, new Server.ClientContextFactory(), new Server.ServerHandlersV1()); Server.Run(); DateTime now = new DateTime(); now = DateTime.Now; System.Console.WriteLine("Server started at " + now.Hour + ":" + now.Minute + ":" + now.Second); } } } 

स्वागत पैकेज:

 using Common; namespace Server.Packets { class HelloPacket : PacketBase { public HelloPacket() : base(0) {} //id - 0 } } 

संदेश पैकेज:

 using Common; namespace Server.Packets { class MessagePacket : PacketBase { public MessagePacket(string nick, string message) : base(1) { this._nick = nick; this._message = message; } private string _nick; private string _message; protected override void WriteBody(System.IO.BinaryWriter writer) { writer.Write(this._nick); writer.Write(this._message); } } } 

WriteBody विधि पैकेज बॉडी को भेजती है यानी प्रेषक का उपनाम और उसका संदेश।

आपका स्वागत है पैकेट हैंडलर:

 using Common; using Chat_server; using System; namespace Server.PacketHandlers { class HelloPacketHandler : PacketHandlerBase { public HelloPacketHandler() { } private string _nick; public override void Read() { this._nick = this.Reader.ReadString(); //  } public override void Handle() { Program.Contacts.Add(this._nick); //   DateTime now = new DateTime(); now = DateTime.Now; System.Console.WriteLine(now.Hour + ":" + now.Minute + ":" + now.Second + " " + this._nick + " connected"); } public override object Clone() { return new HelloPacketHandler(); } } } 

स्वागत पैकेट में, ग्राहक हमें एक उपनाम भेजता है जिसे रीड विधि में पढ़ा जाता है, और हैंडल विधि में इसे सूची में जोड़ा जाता है।

संदेश हैंडलर संदेश के साथ:

 using Common; using Server; using Server.Packets; using Chat_server; namespace Server.PacketHandlers { class MessagePacketHandler : PacketHandlerBase { public MessagePacketHandler() { } private string _nick; private string _message; public override void Read() { this._nick = this.Reader.ReadString(); //  this._message = this.Reader.ReadString(); //  } public override void Handle() { Program.Server.SendMessage(this._nick, this._message, ((ClientContext)Context).Connection); //     } public override object Clone() { return new MessagePacketHandler(); } } } 

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

 public void SendMessage(string nick, string message, Connection sender) { foreach (Connection connection in this._connectios) if(connection != sender) connection.Send(new MessagePacket(nick, message)); } 

ServerHandlersV1 वर्ग (पैकेटेटैंडलरस्टोरेज के वंशज) में हैंडलर।

 using Common; using Server.PacketHandlers; namespace Server { class ServerHandlersV1 : PacketHandlerStorage { public ServerHandlersV1() { AddHandler(0, new HelloPacketHandler()); AddHandler(1, new MessagePacketHandler()); } } } 

ग्राहक

 namespace Chat_client { class Program { public static Client.Client Client { get; set; } //  public static string Nick { get; set; } // public static string IpAddress { get; set; } //Ip  static void Main(string[] args) { string message; Console.Write(" : "); Nick = Console.ReadLine(); Console.Write("IP  : "); IpAddress = Console.ReadLine(); Console.Clear(); Client = new Client.Client(IpAddress, 1698, new Client.ClientHandlersV1()); while (true) { message = Console.ReadLine(); Client.SendMessagePacket(message); } } } } 

लूप डायल किए गए संदेश भेजता है। क्योंकि पैकेज भेजने का कोई तरीका नहीं है; मैंने ग्राहक वर्ग में एक विधि लिखी है।

 public void SendMessagePacket(string message) { this._connection.Send(new MessagePacket(Program.Nick, message)); } 

स्वागत पैकेज:

 using Common; using Chat_client; namespace Client.Packets { class HelloPacket : PacketBase { public HelloPacket() : base(0) {} //id - 0 protected override void WriteBody(System.IO.BinaryWriter writer) { writer.Write(Program.Nick); } } } 

उपनाम WriteBody पद्धति में भेजा गया है।

संदेश पैकेज:

 using Common; namespace Client.Packets { class MessagePacket : PacketBase { public MessagePacket(string nick, string message) : base(1) { this._nick = nick; this._message = message; } private string _nick; private string _message; protected override void WriteBody(System.IO.BinaryWriter writer) { writer.Write(this._nick); writer.Write(this._message); } } } 

आपका उपनाम और संदेश भेजा जाता है।

आपका स्वागत है पैकेट हैंडलर:

 using Common; namespace Client.PacketHandlers { class HelloPacketHandler : PacketHandlerBase { public HelloPacketHandler() { } public override object Clone() { return new HelloPacketHandler(); } } } 

वह कोई क्रिया नहीं करता है।

संदेश बैच हैंडलर:

 using Common; namespace Client.PacketHandlers { class MessagePacketHandler : PacketHandlerBase { public MessagePacketHandler() { } private string _nick; private string _message; public override void Read() { this._nick = this.Reader.ReadString(); //  this._message = this.Reader.ReadString(); //  } public override void Handle() { System.Console.ForegroundColor = System.ConsoleColor.Green; System.Console.Write(this._nick + ": "); System.Console.ForegroundColor = System.ConsoleColor.Gray; System.Console.WriteLine(this._message); } public override object Clone() { return new MessagePacketHandler(); } } } 

रीड विधि में, उपनाम और संदेश प्राप्त होता है। हैंडल विधि में, संदेश कंसोल पर प्रदर्शित होता है।

ClientHandlersV1 में हैंडलर।

 using Common; using Client.PacketHandlers; namespace Client { class ClientHandlersV1 : PacketHandlerStorage { public ClientHandlersV1() { AddHandler(0, new HelloPacketHandler()); AddHandler(1, new MessagePacketHandler()); } } } 

सरल मल्टी-क्लाइंट कंसोल चैट तैयार है!




प्रोटोकॉल डाउनलोड करें

चैट डाउनलोड करें (सर्वर)

चैट डाउनलोड करें (ग्राहक)