基于事件的异步Socket(TCP连接方式)

代码

// TcpService.cs

using  System;
using  System.IO;
using  System.Text;
using  System.Net;
using  System.Diagnostics;
using  System.Net.Sockets;
using  System.Collections.Generic;
using  System.Runtime.InteropServices;

namespace  SocketServer
{

     ///   <summary>
     ///  边城浪  QQ：19201576
     ///  最后更新：9:57 2007-8-7
     ///  TCP连接服务器端,接受多客户的TCP连接
     ///   </summary>
     public   class  TcpService < T >
          where  T :  class , IDataTransmit, new ()
    {
         #region  事件定义

         ///   <summary>
         ///  客户端连接事件
         ///   </summary>
         public   event  NetEventHandler Connected;
         ///   <summary>
         ///  客户端断开事件
         ///   </summary>
         public   event  NetEventHandler DisConnect;
         #endregion

         #region  字段
         private   readonly   int  maxsockets;             // 最大客户连接数
         private  TcpListener listener;                // 监听类
         private  Dictionary < EndPoint, T >  session;     // 保存连接的客户端
         #endregion

         #region  属性
         ///   <summary>
         ///  当前客户连接数
         ///   </summary>
         public   int  ConnectCount
        {
             get  {  return  session.Count; }
        }

         ///   <summary>
         ///  与客户连接的所有Socket
         ///   </summary>
         public  Dictionary < EndPoint, T >  Session
        {
             get  {  return  session; }
        }
         #endregion

         #region  构造函数
         ///   <summary>  
         ///  构造函数
         ///   </summary>  
         ///   <param name="port"> 监听的端口号 </param>  
         ///   <param name="maxsocket"> 最大客户连接量 </param>  
         public  TcpService( int  port,  int  maxsockets,  string  ip)
        {
             if  (maxsockets  <   1 )
            {
                 throw   new  ArgumentOutOfRangeException( " maxsockets " ,  " 最大连接数不能小于1 " );
            }
             this .maxsockets  =  maxsockets;
             this .listener  =   new  TcpListener( new  IPEndPoint(IPAddress.Parse(ip), port));
             this .session  =   new  Dictionary < EndPoint, T > ();
        }

         public  TcpService( int  port)
            :  this (port,  1000 ,  " 0.0.0.0 " )
        {
        }
         #endregion

         #region  公用方法
         public   void  Start( int  backlog)
        {
            listener.Start(backlog);
             // 监听客户端连接请求 
            listener.BeginAcceptSocket(clientConnect, listener);
        }

         ///   <summary>  
         ///  启动服务器程序,开始监听客户端请求
         ///   </summary>  
         public   void  Start()
        {
            Start( 4 );
        }

         private   void  clientConnect(IAsyncResult ar)
        {
            TcpListener listener  =  (TcpListener)ar.AsyncState;
             // 接受客户的连接,得连接Socket
            Socket client  =  listener.EndAcceptSocket(ar);
            client.IOControl(IOControlCode.KeepAliveValues, Keepalive( 0 , 60000 , 5000 ),  null );

            T work  =   new  T();
            work.TcpSocket  =  client;
            work.DisConnected  +=   new  NetEventHandler(work_DisConnect);

            EndPoint socketPoint  =  client.RemoteEndPoint;
             if  (session.ContainsKey(socketPoint))
            {
                session[socketPoint]  =  work;
            }
             else
            {
                session.Add(socketPoint, work);
            }

             if  (ConnectCount  <  maxsockets)
            {
                 // 继续监听客户端连接请求 
                IAsyncResult iar  =  listener.BeginAcceptSocket(clientConnect, listener);
            }
             else
            {    // 达到最大连接客户数,则关闭监听.
                listener.Stop();
            }

             // 客户端连接成功事件
            NetEventHandler handler  =  Connected;
             if  (handler  !=   null )
            {
                handler(work,  new  NetEventArgs( " 接受客户的连接请求 " ));
            }
            Debug.WriteLine(socketPoint.ToString()  +   "  is Connection...Num "   +  ConnectCount);
        }

         // 客户端断开连接
         private   void  work_DisConnect(IDataTransmit work, NetEventArgs e)
        {
            EndPoint socketPoint  =  work.RemoteEndPoint;
            session.Remove(socketPoint);

             // 如果已关闭侦听器,则打开,继续监听
             if  (ConnectCount  ==  maxsockets)
            {
                listener.Start( 2 );
                IAsyncResult iar  =   listener.BeginAcceptSocket(clientConnect, listener);
            }

             // 触发客户断开事件
            NetEventHandler handler  =  DisConnect;
             if  (handler  !=   null )
            {
                handler(work, e);
            }           
            Debug.WriteLine(socketPoint.ToString()  +   "  is OnDisConnected...Num "   +  ConnectCount);
        }
         #endregion
        
         ///   <summary>
         ///   得到tcp_keepalive结构值
         ///   </summary>
         ///   <param name="onoff"> 是否启用Keep-Alive </param>
         ///   <param name="keepalivetime"> 多长时间后开始第一次探测（单位：毫秒） </param>
         ///   <param name="keepaliveinterval"> 探测时间间隔（单位：毫秒） </param>
         ///   <returns></returns>
         public   static   byte [] Keepalive( int  onoff,  int  keepalivetime,  int  keepaliveinterval)
        {
             byte [] inOptionValues  =   new   byte [ 12 ];
            BitConverter.GetBytes(onoff).CopyTo(inOptionValues,  0 );
            BitConverter.GetBytes(keepalivetime).CopyTo(inOptionValues,  4 );
            BitConverter.GetBytes(keepaliveinterval).CopyTo(inOptionValues,  8 );
             return  inOptionValues;
        }
    }

     public   class  TcpService : TcpService < DataTransmit >
    {
         #region  构造函数
         ///   <summary>  
         ///  构造函数
         ///   </summary>  
         ///   <param name="port"> 监听的端口号 </param>  
         ///   <param name="maxsocket"> 最大客户连接量 </param>  
         public  TcpService( int  port,  int  maxsockets,  string  ip)
            :  base (port, maxsockets, ip)
        {
        }
         public  TcpService( int  port)
            :  base (port,  1000 ,  " 0.0.0.0 " )
        {
        }
         #endregion
    }
}

// NetEventArgs.cs

using  System;
using  System.Collections.Generic;
using  System.Text;

namespace  SocketServer
{
     ///   <summary>
     ///  网络通讯事件模型委托
     ///   </summary>
     ///   <param name="sender"></param>
     ///   <param name="e"> TcpClient </param>
     public   delegate   void  NetEventHandler(IDataTransmit sender, NetEventArgs e);

     ///   <summary>
     ///  网络事件参数
     ///   </summary>
     public   class  NetEventArgs : EventArgs
    {
         private   object  eventArg;

         public  NetEventArgs( object  EventArg)
        {
            eventArg  =  EventArg;
        }
         public   object  EventArg
        {
             get  {  return  eventArg; }
             set  { eventArg  =  value; }
        }

         public   override   string  ToString()
        {
             if  (eventArg  !=   null )
            {
                 return  eventArg.ToString();
            }
             else
            {
                 return   string .Empty;
            }
        }
    }
}


IDataTransmit.cs

using  System;
namespace  SocketServer
{
     public   interface  IDataTransmit
    {
         bool  Connected {  get ; }
         ///   <summary>
         ///  连接失败事件
         ///   </summary>
         event  NetEventHandler ConnectFail;
         ///   <summary>
         ///  连接成功事件
         ///   </summary>
         event  NetEventHandler ConnectSucceed;
         ///   <summary>
         ///  断开连接事件
         ///   </summary>
         event  NetEventHandler DisConnected;
         ///   <summary>
         ///  接收到数据事件
         ///   </summary>
         event  NetEventHandler ReceiveData;
         ///   <summary>
         ///  获取远程终结点
         ///   </summary>
        System.Net.EndPoint RemoteEndPoint {  get ; }
         ///   <summary>
         ///  发送二进制数据
         ///   </summary>
         ///   <param name="data"></param>
         ///   <returns></returns>
         bool  Send( byte [] bin);
         ///   <summary>
         ///  发送文本
         ///   </summary>
         ///   <param name="text"></param>
         ///   <returns></returns>
         bool  Send( string  text);
         ///   <summary>
         ///  开始接收数据
         ///   </summary>
         void  Start();
         ///   <summary>
         ///  停止
         ///   </summary>
         void  Stop();
         ///   <summary>
         ///  Socket对象.
         ///   </summary>
        System.Net.Sockets.Socket TcpSocket {  get ;  set ;}
    }
}


DataTransmit.cs

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.Net;
using  System.Net.Sockets;
using  System.Diagnostics;
using  System.Threading;

namespace  SocketServer
{
     ///   <summary>
     ///  辅助传输对象
     ///   </summary>
     public   class  DataTransmit : IDataTransmit
    {
         #region  事件定义
         ///   <summary>
         ///  连接成功事件
         ///   </summary>
         public   event  NetEventHandler ConnectSucceed;
         ///   <summary>
         ///  连接失败事件
         ///   </summary>
         public   event  NetEventHandler ConnectFail;
         ///   <summary>
         ///  断开连接事件
         ///   </summary>
         public   event  NetEventHandler DisConnected;
         ///   <summary>
         ///  接收到数据事件
         ///   </summary>
         public   event  NetEventHandler ReceiveData;       
         #endregion

         #region  字段
         private  Socket socket;                   // 连接的Socket
         private  EndPoint iep;                    // 网络终节点,用于标识不同的用户
         private   byte [] buffer;                   // 接收数据缓存
         private  SocketError errorCode;           // 错误代码
         public   const   int  BagSize  =   8192 ;         // 缓存大小
         #endregion

         #region  属性
         public  Socket TcpSocket
        {
             get
            {
                 return  socket;
            }
             set
            {
                 if  (value  ==   null )
                {
                     throw   new  ArgumentNullException( " client " );
                }
                 this .socket  =  value;
                 this .socket.ReceiveBufferSize  =  BagSize;
                 this .iep  =  value.RemoteEndPoint;
            }
        }
         ///   <summary>
         ///  获取远程终结点
         ///   </summary>
         public  EndPoint RemoteEndPoint
        {
             get  {  return  iep; }
        }
         ///   <summary>
         ///  Socket是否已连接
         ///   </summary>
         public   bool  Connected
        {
             get
            {
                 if  (socket  ==   null )
                {
                     return   false ;
                }
                 else
                {
                     return   this .socket.Connected;
                }
            }
        }
         ///   <summary>
         ///  Socket错误代码
         ///   </summary>
         public  SocketError ErrorCode
        {
             get  {  return  errorCode; }
             set  { errorCode  =  value; }
        }
         #endregion

         #region  构造函数
         public  DataTransmit()
        {
            errorCode  =  SocketError.Success;
            buffer  =   new   byte [BagSize];
        }

         public  DataTransmit( string  ip,  int  port)
            :  this ( new  IPEndPoint(IPAddress.Parse(ip), port))
        {
        }

         ///   <summary>
         ///  客户端调用此构造函数
         ///   </summary>
         ///   <param name="ipPoint"> 在连接的服务器端网络地址 </param>
         public  DataTransmit(EndPoint ipEndPoint)
            :  this ()
        {
            iep  =  ipEndPoint;
        }

         ///   <summary>
         ///  服务器端调用
         ///   </summary>
         ///   <param name="client"> 服务器监听连接得到的Socket对象 </param>
         public  DataTransmit(Socket client)
            :  this ()
        {
            TcpSocket  =  client;
        }
         #endregion

         public   void  Stop()
        {
             if  (socket  !=   null )
            {
                 try
                {
                     if  (socket.Connected)
                    {
                        socket.Shutdown(SocketShutdown.Both);                        
                    }
                    socket.Close();
                }
                 catch  { }
                socket  =   null ;
            }
        }

         ///   <summary>
         ///  开始接收数据
         ///   </summary>
         ///   <returns></returns>
         public   void  Start()
        {
             if  (socket  !=   null   &&  socket.Connected)
            {
                receiveData();
            }
             else
            {
                 this .socket  =   new  Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                 this .socket.ReceiveBufferSize  =  BagSize;
                 this .socket.BeginConnect(iep, connectCallback, socket);
            }
        }

         private   void  connectCallback(IAsyncResult ar)
        {
             try
            {
                 this .socket.EndConnect(ar);
            }
             catch  (Exception err)
            {
                OnConnectFail(err);
                 return ;
            }
             // 连接成功,开始接收数据
            OnConnectSucceed();
            receiveData();
        }

         private   void  receiveData()
        {
             //  调用异步方法 BeginReceive 来告知 socket 如何接收数据
            IAsyncResult iar  =  socket.BeginReceive(buffer,  0 , BagSize, SocketFlags.None,  out  errorCode, receiveCallback, buffer);
             if  ((errorCode  !=  SocketError.Success)  &&  (errorCode  !=  SocketError.IOPending))
            {
                OnDisConnected( new  SocketException(( int )errorCode));
            }
        }

         ///   <summary>
         ///  接收数据回调函数
         ///   </summary>
         ///   <param name="ar"></param>
         private   void  receiveCallback(IAsyncResult ar)
        {
             // 接收到的数据长度．
             int  receLen  =   0 ;
             try
            {
                receLen  =  socket.EndReceive(ar,  out  errorCode);
            }
             catch  (Exception err)
            {
                OnDisConnected(err);
                 return ;
            }
             if  (errorCode  ==  SocketError.Success)
            {
                 if  (receLen  >   0 )
                {
                     byte [] currentBin  =   new   byte [receLen];
                    Buffer.BlockCopy(buffer,  0 , currentBin,  0 , receLen);
                    OnReceiveData(currentBin);
                }
                receiveData();
            }
             else
            {
                OnDisConnected( new  SocketException(( int )errorCode));
            }
        }

         public   virtual   bool  Send( string  text)
        {
             byte [] bin  =  Encoding.Default.GetBytes(text);
             return  Send(bin);
        }

         public   virtual   bool  Send( byte [] data)
        {
             if  (Connected)
            {
                 this .socket.BeginSend(data,  0 , data.Length, SocketFlags.None,  out  errorCode, sendCallBack, socket);
                 if  (errorCode  ==  SocketError.Success)
                {
                     return   true ;
                }
            }
             return   false ;
        }

         private   void  sendCallBack(IAsyncResult ar)
        {
             this .socket.EndSend(ar,  out  errorCode);
             if  (errorCode  !=  SocketError.Success)
            {
                OnDisConnected( new  SocketException(( int )errorCode));
            }
        }

         #region  受保护的事件处理方法

         protected   virtual   void  OnConnectSucceed()
        {
            NetEventHandler hander  =  ConnectSucceed;
             if  (hander  !=   null )
            {
                ConnectSucceed( this ,  new  NetEventArgs( " 成功连接到服务器 " ));
            }
        }

         protected   virtual   void  OnConnectFail(Exception err)
        {
            NetEventHandler hander  =  ConnectFail;    // 连接服务器失败事件
             if  (hander  !=   null )
            {
                ConnectFail( this ,  new  NetEventArgs(err));
            }
        }

         protected   virtual   void  OnDisConnected(Exception err)
        {
             // Stop();
            NetEventHandler hander  =  DisConnected;   // 断开连接事件
             if  (hander  !=   null )
            {
                hander( this ,  new  NetEventArgs(err));
            }
        }

         protected   virtual   void  OnReceiveData( object  bin)
        {
            NetEventHandler hander  =  ReceiveData;    // 接收到消息事件
             if  (hander  !=   null )
            {
                hander( this ,  new  NetEventArgs(bin));
            }
        }
         #endregion
    }
}




本文来自CSDN博客，转载请标明出处：http: // blog.csdn.net/yeerh/archive/2006/09/25/1280111.aspx

 

转载于:https://www.cnblogs.com/bobofsj11/archive/2010/02/24/1672884.html