Tcp Socket异步通讯实例

/// <summary>
/// Socket客户端实体类,作用发送和接收数据包
/// </summary>
public class SocketHelper
{
/// <summary>
/// 端IP地址和端口号
/// </summary>
/// <param name="ipAdress">IP</param>
/// <param name="port">端口号</param>
public SocketHelper(string ipAdress, int port)
{
try
{
//远程终端
_RemoteEP = new IPEndPoint(IPAddress.Parse(ipAdress), port);
//建立客户端
_Client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//确保可以重复使用套接字
_Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
}
catch (ArgumentException ae)
{
if (OnError != null)
OnError("远程连接IP和端口号错误:" + ae.Message, _Client, 0);
Console.WriteLine("远程连接IP和端口号错误:" + ae.Message);
}
catch (SocketException ex)
{
if (OnError != null)
OnError("使用套接字出错:" + ex.Message, _Client, 0);
Console.WriteLine("使用套接字出错:" + ex.Message);
}
}

#region methods
/// <summary>
/// socket通信机连接函数
/// </summary>
public bool Connect()
{
try
{
//连接标识
bool isConnect = false;
//调用系统连接函数
_Client.BeginConnect(_RemoteEP, new AsyncCallback(ConnectCallback), _Client);
//设置一个等待时间
isConnect = connectDone.WaitOne(100);
if (isConnect)
{
connectInfo = "连接成功!";
Console.WriteLine(connectInfo);
}
else
{
connectInfo = "连接失败!";
Console.WriteLine(connectInfo);
}
return isConnect;
}
catch (ObjectDisposedException ex)
{
if (OnError != null)
OnError(ex.Message, _Client, 0);
return false;
}
}
/// <summary>
/// socket连接返回函数
/// </summary>
/// <param name="ar">表示异步操作的状态</param>
private static void ConnectCallback(IAsyncResult ar)
{
try
{
// 获取socket连接实例
Socket client = (Socket)ar.AsyncState;
// 完成连接过程.
client.EndConnect(ar);
// 置位连接完成标志
connectDone.Set();
// 得到连接成功信息
connectInfo = "连接成功！";
}
catch (Exception e)
{
// 得到连接失败信息
connectInfo = e.ToString();
// 结束连接
connectDone.Reset();
}
}
/// <summary>
/// socket通信机关闭函数
/// </summary>
public void Close()
{
try
{
if (_Client != null)
{
//如果仍然产生通信信息，则禁用
if (_Client.Connected)
{
_Client.Shutdown(SocketShutdown.Both);
_Client.Disconnect(true);
}
//关闭socket通信
_Client.Close();

//获得关闭成功信息
closeInfo = "通信机已关闭!";
}
}
catch (Exception e)
{
//获得关闭通信失败信息
closeInfo = e.ToString();
_Client.Disconnect(true);
}
}
/// <summary>
/// 数据发送函数
/// </summary>
/// <param name="messageSend">需发送的信息</param>
/// <returns>
/// 返回发送是否成功值
/// </returns>
public bool Send(String messageSend)
{
//将数据转换成Byte型ASCII码。
byte[] byteData = Encoding.ASCII.GetBytes(messageSend);

try
{
// 向远程设备（Server）发送数据.
_Client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), _Client);
sendInfo = "发送成功!";
Console.WriteLine(sendInfo);
}
catch (SocketException se)
{
//设置发送产生错误信息
sendInfo = "发送失败:" + se.Message;
Console.WriteLine(sendInfo);
if (OnError != null)
OnError(se.Message, _Client, 0);
return false;
}
//发送标志事件等待
sendDone.WaitOne();
//返回真
return (true);
}
/// <summary>
/// 数据发送返回函数
/// </summary>
/// <param name="ar">表示异步操作的状态</param>
private static void SendCallback(IAsyncResult ar)
{
try
{
// 获取socket连接实例
Socket Client = (Socket)ar.AsyncState;
// 对远程设备发送数据完成
int bytesSent = Client.EndSend(ar);
//置位发送完成标志
sendDone.Set();
// 获得发送完成信息
sendInfo = "发送已完成！";
}
catch (Exception e)
{
//得到发送失败信息
sendInfo = e.ToString();
//结束发送标志
sendDone.Reset();
}
}
/// <summary>
/// 数据接收函数
/// </summary>
/// <param name="client">已连接的socket通信机实例（客户端）</param>
/// <returns>
/// 返回接收数据
/// </returns>
public string Receive()
{
try
{
//int i;
// 创建实例.
StateObject state = new StateObject();
state.workSocket = _Client;
// 开始从远程设备接收数据
_Client.BeginReceive(state.buffer, 0, StateObject.bufferSize, 0, new AsyncCallback(ReceiveCallback), state);

//设置等待时间间隔
//获取接收数据
receiveDone.WaitOne(500);
revData = state.sb.ToString();
//返回接收到的数据
return (revData);
}
catch (ObjectDisposedException oe)
{
if (OnError != null)
OnError(oe.Message, _Client, 0);
return "";
}
catch (SocketException se)
{
if (OnError != null)
OnError(se.Message, _Client, 0);
return "";
}
catch (Exception e)
{
//获得接收失败信息
revInfo = e.ToString();
//返回空字符串
return ("");
}
}
/// <summary>
/// 数据接收返回函数
/// </summary>
/// <param name="ar">表示异步操作的状态</param>
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
// 创建实例
StateObject State = (StateObject)ar.AsyncState;
Socket Client = State.workSocket;

// 从远程设备读取数据
int BytesRead = Client.EndReceive(ar);

if (BytesRead > 0)
{
// 可能有过多的数据，先存储缓冲区内的字符串
revTempString = Encoding.Default.GetString(State.buffer, 0, BytesRead);
//将缓冲区间的数据封装在一个StringBulid类型中
State.sb.Append(revTempString);
// 接收剩余数据
Client.BeginReceive(State.buffer, 0, StateObject.bufferSize, 0, new AsyncCallback(ReceiveCallback), State);
}
else
{
// 所有数据都已经接收
if (State.sb.Length > 1)
{
string response = State.sb.ToString();
}
// 置位数据已接收标志位
receiveDone.Set();
}
}
catch (ObjectDisposedException oe)
{
revInfo = oe.Message;
throw oe;
}
catch (SocketException se)
{
revInfo = se.Message;
throw se;
}
catch (Exception e)
{
// 获得接收失败信息
revInfo = e.Message;
throw e;
}
}
#endregion

#region 变量
private static ManualResetEvent sendDone = new ManualResetEvent(false);
private static ManualResetEvent connectDone = new ManualResetEvent(false);
private static ManualResetEvent receiveDone = new ManualResetEvent(false);

private static string connectInfo = "";
private static string closeInfo = "";
private static string sendInfo = "";
private static string revInfo = "";
private static string revData = "";
private static string revTempString = "";

private EndPoint _RemoteEP = null;
private Socket _Client = null;

public delegate void ErrorDelegate(string ErroMessage, Socket soc, int ErroCode);

public event ErrorDelegate OnError;
#endregion
}

public class StateObject
{
// Client   socket.
public Socket workSocket = null;
// Size of receive buffer.1024
public const int bufferSize = 1024;
// Receive buffer.
public byte[] buffer = new byte[bufferSize];
// Received data string.
public StringBuilder sb = new StringBuilder();
}