C# NetHelper网络通信编程类[异步]

ro4ters

之前飞哥发了一个同步的版本,我来个异步的吧.{:soso_e113:}(只写了tcp,udp懒得写了.)
http://www.sufeinet.com/thread-3678-1-1.html
注释都写了.过程也理清楚了.完全当学习的东西看吧..

1. 
   
2. <P>/*
   
3. 说明:Socket辅助类
   
4. 作者:Ro4ters
   
5. 编写时间: 26-06-2013
   
6. 主要功能:
   
7.    接收发送数据.(异步)</P>
   
8. <P>*/
   
9.        class SocketHelper
   
10.     {
    
11.         public delegate void Uplistbox(string txt);
    
12.         public Uplistbox uplb;  //更新listbox委托变量
    
13.         protected static readonly ILog logger = LogManager.GetLogger(typeof(TCPSocketServer2));
    
14.         private ManualResetEvent allDone = new ManualResetEvent(false); //线程控制
    
15.         protected Hashtable m_workerSocketHt = Hashtable.Synchronized(new Hashtable());//保存客户端socket哈希表
    
16.         public AsyncCallback asyncCallBack;  //声明异步完成时调用的方法.
    
17.         private Socket m_mainSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//主通信Socket
    
18.         public bool isExit = false;//全局控制SOCKET启动和关闭
    
19.         private long m_clientCount = 0L;//记录客户端数量
    
20.         /// <summary>
    
21.         /// 发送消息
    
22.         /// </summary>
    
23.         /// <param name="buffer">需要发送的字节</param>
    
24.         public void Send(byte[] buffer)
    
25.         {
    
26.             try
    
27.             {
    
28.                 //目标地址
    
29.                 IPEndPoint ip = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1234);
    
30.                 //发送通信socket
    
31.                 Socket sk = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    
32.                 sk.Connect(ip);//连接
    
33.                 sk.Send(buffer);//发送
    
34.                 SocketUser su = new SocketUser();
    
35.                 su.CurrentSocket = sk;
    
36.                 su.DataBuffer = buffer;
    
37.                 //异步接收
    
38.                 asyncCallBack = new AsyncCallback(OnDataReceived);
    
39.                 sk.BeginReceive(su.DataBuffer, 0, su.DataBuffer.Length, SocketFlags.None, asyncCallBack, su);</P>
    
40. <P>            }
    
41.             catch (Exception ex)
    
42.             {
    
43.                 string msg = ex.ToString() + " " + DateTime.Now.ToString();
    
44.                 uplb(msg);
    
45.                 logger.Debug(msg);
    
46.             }
    
47.         }
    
48.         /// <summary>
    
49.         /// 发送消息[重载]
    
50.         /// </summary>
    
51.         /// <param name="SocketUser">需要发送的SocketUser对象</param>
    
52.         /// <param name="buffer">需要发送的字节</param>
    
53.         public void Send(SocketUser su, byte[] buffer)
    
54.         {
    
55.             try
    
56.             {
    
57.                 //目标地址
    
58.                 IPEndPoint ip = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1234);
    
59.                 //发送通信socket
    
60.                 su.CurrentSocket.Connect(ip);//连接
    
61.                 su.CurrentSocket.Send(buffer);//发送
    
62.                 su.DataBuffer = buffer;
    
63.                 //异步接收
    
64.                 asyncCallBack = new AsyncCallback(OnDataReceived);
    
65.                 su.CurrentSocket.BeginReceive(su.DataBuffer, 0, su.DataBuffer.Length, SocketFlags.None, asyncCallBack, su);</P>
    
66. <P>            }
    
67.             catch (Exception ex)
    
68.             {
    
69.                 string msg = ex.ToString() + " " + DateTime.Now.ToString();
    
70.                 uplb(msg);
    
71.                 logger.Debug(msg);
    
72.             }
    
73.         }
    
74.         /// <summary>
    
75.         /// 建立监听连接
    
76.         /// </summary>
    
77.         /// <param name="port">监听的端口号</param>
    
78.         private void AcceptConnection(object port)
    
79.         {
    
80.             try
    
81.             {</P>
    
82. <P>                IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, (int)port);
    
83.                 //绑定地址
    
84.                 m_mainSocket.Bind(ipLocal);
    
85.                 //开始监听
    
86.                 m_mainSocket.Listen(10000);
    
87.                 while (isExit == false)
    
88.                 {
    
89.                     try
    
90.                     {
    
91.                         allDone.Reset(); //线程阻塞
    
92.                         logger.Debug("TcpListener启动成功: " + ipLocal.Address.ToString() + "," + ipLocal.Port.ToString());
    
93.                         //接收异步连接并创建新的socket对象.
    
94.                         m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), m_mainSocket);
    
95.                         allDone.WaitOne();
    
96.                     }
    
97.                     catch (SocketException sf)
    
98.                     {
    
99.                         logger.Error("客户连接请求异常" + sf.ToString());
    
100.                     }
     
101.                     catch (Exception f)
     
102.                     {
     
103.                         logger.Error("客户连接请求异常" + "错误信息:" + f.Message);
     
104.                         break;
     
105.                     }</P>
     
106. <P>                }
     
107.             }
     
108.             catch (SocketException se)
     
109.             {
     
110.                 logger.Error("TcpListener启动失败" + se.ToString() + "错误号:" + se.ErrorCode.ToString());</P>
     
111. <P>            }
     
112.             catch (Exception e)
     
113.             {
     
114.                 logger.Error("TcpListener错误" + "错误信息:" + e.Message);
     
115.             }</P>
     
116. <P>        }
     
117.         /// <summary>
     
118.         /// 开始监听
     
119.         /// </summary>
     
120.         /// <param name="Port">监听的端口</param>
     
121.         /// <param name="buffer">发送的字节</param>
     
122.         public bool StartListening(int Port, params byte[] buffer)
     
123.         {
     
124.             if (Port == 0)
     
125.             {
     
126.                 logger.Debug("TcpListener未启动,请指定监听的端口号.");
     
127.                 return false;
     
128.             }</P>
     
129. <P>            // 创建监听socket
     
130.             Thread AcceptTh = new Thread(new ThreadStart(delegate
     
131.             {
     
132.                 AcceptConnection(Port);
     
133.             }));
     
134.             AcceptTh.Start();
     
135.             Thread sendth = new Thread(new ThreadStart(delegate
     
136.             {
     
137.                 Send(buffer);
     
138.             }));
     
139.             sendth.Start();
     
140.             logger.Debug("启动TCP监听,端口: " + Port);
     
141.             return true;
     
142.         }</P>
     
143. <P>//下面方法在二楼
     
144.       }
     
145. }</P>
     
146. <P> </P>

复制代码

Have Fun; {:soso_e121:}
26-06-2013

ro4ters

1.   /// <summary>
   
2.         /// 释放Socket
   
3.         /// </summary>
   
4.         /// <param name="user"></param>
   
5.         public void ClientDisConnect(SocketUser user)
   
6.         {
   
7.             try
   
8.             {
   
9.                 logger.Error("数据中心：" + user.ClientName + "," + user.LoginIP + " 断开连接");
   
10.                 if (user != null)
    
11.                 {
    
12.                     if (user.CurrentSocket != null)
    
13.                     {
    
14.                         //释放连接
    
15.                         user.CurrentSocket.Shutdown(SocketShutdown.Both);
    
16.                         user.CurrentSocket.Close();
    
17.                         user.CurrentSocket = null;
    
18.                     }
    
19.                     user = null;
    
20. 
    
21.                 }
    
22.             }
    
23.             catch (Exception e)
    
24.             {
    
25.                 logger.Error("关闭TCP连接错误：" + e.ToString());
    
26.             }
    
27.         }
    
28.         /// <summary>
    
29.         /// 异步接收传入连接
    
30.         /// </summary>
    
31.         /// <param name="asyn"></param>
    
32.         public void OnClientConnect(IAsyncResult asyn)
    
33.         {
    
34.             try
    
35.             {
    
36.                 allDone.Set();
    
37.                 if (m_mainSocket == null)
    
38.                 {
    
39.                     logger.Debug("TCP监听服务已关闭");
    
40.                     return;
    
41.                 }
    
42.                 Socket workerSocket = (Socket)asyn.AsyncState;
    
43.                 Socket Temuser = m_mainSocket.EndAccept(asyn);//异步接收
    
44.                 Interlocked.Increment(ref m_clientCount);  //连接数量
    
45.                 SocketUser user = new SocketUser(Temuser, m_clientCount);
    
46.                 WaitForData(user); //等待线程数据
    
47. 
    
48.             }
    
49.             catch (Exception ex)
    
50.             {
    
51.                 System.Windows.Forms.MessageBox.Show(ex.ToString());
    
52.                 return;
    
53.             }
    
54. 
    
55.         }
    
56. 
    
57. 
    
58. 
    
59.         /// <summary>
    
60.         /// 线程等待数据
    
61.         /// </summary>
    
62.         /// <param name="soc"></param>
    
63.         /// <param name="clientNumber"></param>
    
64.         public void WaitForData(SocketUser theUser)
    
65.         {
    
66.             try
    
67.             {
    
68.                 asyncCallBack = new AsyncCallback(OnDataReceived); //实例化委托.
    
69.                 if (theUser != null)
    
70.                 {
    
71.                     //异步接收
    
72.                     theUser.CurrentSocket.BeginReceive(theUser.DataBuffer, 0, theUser.DataBuffer.Length, SocketFlags.None, asyncCallBack, theUser);
    
73.                 }
    
74. 
    
75.             }
    
76.             catch (SocketException se)
    
77.             {
    
78.                 logger.Error("数据处理异常1" + se.ToString());
    
79.             }
    
80.         }
    
81.         byte[] buffer = new byte[1024 * 1024];
    
82.         /// <summary>
    
83.         /// 接收数据(异步回调)
    
84.         /// </summary>
    
85.         /// <param name="asyn">异步返回的连接状态</param>
    
86.         public void OnDataReceived(IAsyncResult asyn)
    
87.         {
    
88.             SocketUser theUser = (SocketUser)asyn.AsyncState;
    
89.             try
    
90.             {
    
91.                 if (theUser.CurrentSocket == null)
    
92.                 {
    
93.                     logger.Error("socket is null ");
    
94.                     return;
    
95.                 }
    
96.                 int iRx = theUser.CurrentSocket.EndReceive(asyn); //接收到的消息长度
    
97.                 if (iRx == 0)
    
98.                 {
    
99.                     logger.Error("没有接收的数据，断开tcp连接");
    
100.                     throw new SocketException(10054);
     
101.                 }
     
102.                 //提取有效字节数据
     
103.                 byte[] data = new byte[iRx];
     
104.                 byte[] buff = theUser.DataBuffer;
     
105.                 for (int i = 0; i < iRx; i++)
     
106.                 {
     
107.                     data[i] = buff[i];
     
108.                 }
     
109. 
     
110.                 //数据处理
     
111.                 ProcessReceiveData(theUser, data);
     
112. 
     
113.                 //继续等待数据
     
114.                 if (isExit == false)
     
115.                 {
     
116.                     WaitForData(theUser);
     
117.                 }
     
118.             }
     
119.             catch (ObjectDisposedException ode)
     
120.             {
     
121.                 logger.Error("数据处理异常2" + ode.ToString());
     
122.             }
     
123.             catch (SocketException se)
     
124.             {
     
125.                 if (se.ErrorCode == 10054)
     
126.                 {
     
127.                     logger.Error("Tcp连接被关闭 " + se.Message);
     
128.                     ClientDisConnect(theUser);
     
129.                 }
     
130.                 else
     
131.                 {
     
132.                     logger.Error("数据处理异常3" + se.ToString());
     
133.                 }
     
134.             }
     
135.         }
     
136.         /// <summary>
     
137.         /// 处理数据.
     
138.         /// </summary>
     
139.         /// <param name="socketuser">接收消息的SocketUser</param>
     
140.         /// <param name="buffer">接收的消息</param>
     
141.         private void ProcessReceiveData(SocketUser socketuser, byte[] buffer)
     
142.         {
     
143.             string msg = System.Text.Encoding.ASCII.GetString(buffer);
     
144.             uplb(msg);
     
145.         }
     
146.    
     

复制代码

ro4ters

还是发个全的吧.....

站长苏飞

异步的我的库里也有，只是还不稳定，没开放，异步不同于同步的那么稳定，我目前还没有研究透彻，我建议你能个例子，大量数据测试一下，异步的功能和同步的就是多了个线程和委托控件，最关键的是稳定性。
其他 的我感觉都是次要的。
楼主这个看着行，不知道实际怎么样。有时间给能个例子上来测试下吧

ro4ters

站长苏飞 发表于 2013-6-26 17:12
异步的我的库里也有，只是还不稳定，没开放，异步不同于同步的那么稳定，我目前还没有研究透彻，我建议你能 ...

实际大批量数据效果还有待测试,我服务器上代码用的是异步,每天2000+客户端同时连接(5-15秒发送一条数据)...暂时没发现太大的问题,可能数据有点小的原因吧.

站长苏飞

ro4ters 发表于 2013-6-26 19:04
实际大批量数据效果还有待测试,我服务器上代码用的是异步,每天2000+客户端同时连接(5-15秒发送一条数据). ...

那也不错了，还有一个就是并发，你这个量，并发的可能不大，不错了，挺好

x228223

想学习这个  但现在 还在到基础 。。

非对称

强烈支持楼主ing……

coody

受教了，学习中……

忆如从前

刚开始学习这个东西 能不能给个实例呀 ,, 万分感谢 ,, ,,,zll88108@126.com