C# asynchronous TcpListener



MyConnection.cs

[csharp] view plain copy print ?

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 copy print ?

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 copy print ?

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();
        }
    }
}