C# asynchronous TcpListener

港控/mmm° 2022-08-27 03:22 185阅读 0赞

MyConnection.cs

**\[csharp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  using System;  
2.  using System.Collections.Generic;  
3.  using System.Linq;  
4.  using System.Text;  
5.  using System.Net.Sockets;  
6.  using System.IO;  
7.    
8.  namespace AsyncListener  
9.  \{  
10.     class MyConnection  
11.     \{  
12.         public delegate void HandleMessageEvent(TcpClient client, string message);  
13.   
14.         private TcpClient \_client;  
15.         private NetworkStream \_stream;  
16.         private byte\[\] \_buffer;  
17.         private static int \_bufsize = 1024;  
18.         private StringBuilder \_msg = new StringBuilder();  
19.   
20.         public event HandleMessageEvent MessageArrive = null;  
21.   
22.         public MyConnection(TcpClient client)  
23.         \{  
24.             \_client = client;  
25.             \_stream = \_client.GetStream();  
26.             \_buffer = new byte\[\_bufsize\];  
27.         \}  
28.   
29.         public void Process()  
30.         \{  
31.             \_stream.BeginRead(\_buffer, 0, \_buffer.Length, OnRead, null);  
32.         \}  
33.   
34.         private void OnRead(IAsyncResult ar)  
35.         \{  
36.             int count = \_stream.EndRead(ar);  
37.             if (count > 0)  
38.             \{  
39.                 string value = Encoding.ASCII.GetString(\_buffer, 0, count);  
40.                 foreach (char ch in value)  
41.                 \{  
42.                     if (ch == '\\n')  
43.                     \{  
44.                         if (\_msg.Length > 0)  
45.                         \{  
46.                             if (\_msg\[\_msg.Length - 1\] == '\\r') \_msg.Remove(\_msg.Length - 1, 1);  
47.                             if (MessageArrive != null) MessageArrive(\_client, \_msg.ToString());  
48.                             \_msg.Clear();  
49.                         \}  
50.                     \}  
51.                     else  
52.                         \_msg.Append(ch);  
53.                 \}  
54.             \}  
55.             \_stream.BeginRead(\_buffer, 0, \_buffer.Length, OnRead, null);  
56.         \}  
57.     \}  
58. \}

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Net.Sockets;
    using System.IO;
    
    namespace AsyncListener
    {
        class MyConnection
        {
            public delegate void HandleMessageEvent(TcpClient client, string message);
    
            private TcpClient _client;
            private NetworkStream _stream;
            private byte[] _buffer;
            private static int _bufsize = 1024;
            private StringBuilder _msg = new StringBuilder();
    
            public event HandleMessageEvent MessageArrive = null;
    
            public MyConnection(TcpClient client)
            {
                _client = client;
                _stream = _client.GetStream();
                _buffer = new byte[_bufsize];
            }
    
            public void Process()
            {
                _stream.BeginRead(_buffer, 0, _buffer.Length, OnRead, null);
            }
    
            private void OnRead(IAsyncResult ar)
            {
                int count = _stream.EndRead(ar);
                if (count > 0)
                {
                    string value = Encoding.ASCII.GetString(_buffer, 0, count);
                    foreach (char ch in value)
                    {
                        if (ch == '\n')
                        {
                            if (_msg.Length > 0)
                            {
                                if (_msg[_msg.Length - 1] == '\r') _msg.Remove(_msg.Length - 1, 1);
                                if (MessageArrive != null) MessageArrive(_client, _msg.ToString());
                                _msg.Clear();
                            }
                        }
                        else
                            _msg.Append(ch);
                    }
                }
                _stream.BeginRead(_buffer, 0, _buffer.Length, OnRead, null);
            }
        }
    }

MyListener.cs

**\[csharp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  using System;  
2.  using System.Collections.Generic;  
3.  using System.Linq;  
4.  using System.Text;  
5.  using System.Net.Sockets;  
6.    
7.  namespace AsyncListener  
8.  \{  
9.      class MyListener  
10.     \{  
11.         private TcpListener \_server;  
12.         private int \_port;  
13.         private Dictionary<string, MyConnection> \_clientMap = new Dictionary<string, MyConnection>();  
14.   
15.         public event MyConnection.HandleMessageEvent ClientMessageArrive = null;  
16.   
17.         public MyListener(int port)  
18.         \{  
19.             \_port = port;  
20.             \_server = new TcpListener(\_port);  
21.         \}  
22.   
23.         public void Start()  
24.         \{  
25.             \_server.Start();  
26.             \_server.BeginAcceptTcpClient(OnAccept, \_server);  
27.         \}  
28.   
29.         private void OnAccept(IAsyncResult ar)  
30.         \{  
31.             TcpClient client = \_server.EndAcceptTcpClient(ar);  
32.             Console.WriteLine("Accept client from " + client.Client.RemoteEndPoint.ToString());  
33.             MyConnection conn = new MyConnection(client);  
34.             conn.MessageArrive += ClientMessageArrive;  
35.   
36.             \_clientMap.Add(client.Client.RemoteEndPoint.ToString(), conn);  
37.   
38.             conn.Process();  
39.   
40.             \_server.BeginAcceptTcpClient(OnAccept, \_server);  
41.         \}  
42.   
43.     \}  
44. \}

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Net.Sockets;
    
    namespace AsyncListener
    {
        class MyListener
        {
            private TcpListener _server;
            private int _port;
            private Dictionary<string, MyConnection> _clientMap = new Dictionary<string, MyConnection>();
    
            public event MyConnection.HandleMessageEvent ClientMessageArrive = null;
    
            public MyListener(int port)
            {
                _port = port;
                _server = new TcpListener(_port);
            }
    
            public void Start()
            {
                _server.Start();
                _server.BeginAcceptTcpClient(OnAccept, _server);
            }
    
            private void OnAccept(IAsyncResult ar)
            {
                TcpClient client = _server.EndAcceptTcpClient(ar);
                Console.WriteLine("Accept client from " + client.Client.RemoteEndPoint.ToString());
                MyConnection conn = new MyConnection(client);
                conn.MessageArrive += ClientMessageArrive;
    
                _clientMap.Add(client.Client.RemoteEndPoint.ToString(), conn);
    
                conn.Process();
    
                _server.BeginAcceptTcpClient(OnAccept, _server);
            }
    
        }
    }

Program.cs

**\[csharp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  using System;  
2.  using System.Collections.Generic;  
3.  using System.Linq;  
4.  using System.Text;  
5.  using System.Net.Sockets;  
6.    
7.  namespace AsyncListener  
8.  \{  
9.      class Program  
10.     \{  
11.         static void MsgArrive(TcpClient client, string msg)  
12.         \{  
13.             Console.WriteLine("msg \{0\} from \{1\}", msg, client.Client.RemoteEndPoint.ToString());  
14.         \}  
15.   
16.         static void Main(string\[\] args)  
17.         \{  
18.             MyListener listener = new MyListener(12345);  
19.             listener.ClientMessageArrive += MsgArrive;  
20.             listener.Start();  
21.             Console.WriteLine("Listen on port 12345");  
22.   
23.             Console.ReadLine();  
24.         \}  
25.     \}  
26. \}

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Net.Sockets;
    
    namespace AsyncListener
    {
        class Program
        {
            static void MsgArrive(TcpClient client, string msg)
            {
                Console.WriteLine("msg {0} from {1}", msg, client.Client.RemoteEndPoint.ToString());
            }
    
            static void Main(string[] args)
            {
                MyListener listener = new MyListener(12345);
                listener.ClientMessageArrive += MsgArrive;
                listener.Start();
                Console.WriteLine("Listen on port 12345");
    
                Console.ReadLine();
            }
        }
    }

[view plain]: http://blog.csdn.net/ericyeung/article/details/6840571#