基于事件的异步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