c# Socket(客户端)异步通讯

实现功能，能够随时发送数据，并且能够随时接收服务端发送过来的数据，能够判断服务端或端口网络的连接状态，随时查看与服务器通讯是否通畅。

可以使用VS创建一个用户控件或创建一个类，来控制Socket通讯，代码成熟，建议做成用户控件，这样可以随时拖拽控件，写事件什么的都方便。

在写Socket客户端之前，要知道Socket客户端接收数据，使用的线程循环的方式，有数据接收到的时候，触发消息事件，在断开事件处理时，能够触发断开连接事件，这时要定义几个委托，承载事件的触发。

public delegate void ReceiveBuffer(byte[] buffer);//收到消息时，传递消息Buffer的事件。

public delegate void HostDisconnectionEvent();//断开连接时，触发的事件。

我在使用的时候，习惯将委托单独放在一个.cs文件当，定义为委托事件类：DelegateEvent.cs

还要考虑到，在Socket接收消息时，需要使用线程，那么在触发收到消息的事件后，如果需要修改界面上的参数或值，需要做控件的异步调用处理，这样处理起来太麻烦，而且处理不好，到时会有一堆的Bug，这是我在使用过程当中遇到的。那么有一没有办法不使用线程，让客户端循环接收消息呢？这时我想到了使用异步，最后又增加了一个异步收消息的委托：

public delegate void AsyncReceivedClient(object sender);//异步收到消息时的委托，如果整个类当中只有一个客户端连接，可以不带参数。

这时，委托类基本建完了，那么，这时需要定义代码了：

创建一个TCPClient类，当然，这个类和System.Net.Sockets下的类不同，为了区分，我定义的命名空间为：System.Net.Securate.TCP，下面是定义的事件和参数：

/// <summary>
/// 收到消息事件
/// </summary>
public ReceiveBuffer ReceiveComtemplate;
/// <summary>
/// 主机断开连接事件
/// </summary>
public HostDisconnectionEvent HostDisconnectedComtelplate;
private string _Address;
/// <summary>
/// 获取或设置连接地址
/// </summary>
public string Address
{
get { return _Address; }
set { _Address = value; }
}
private int _Port;
/// <summary>
/// 获取或设置端口号
/// </summary>
public int Port
{
get { return _Port; }
set { _Port = value; }
}
private Socket tcpClient;
/// <summary>
/// 获取连接状态
/// </summary>
public bool IsConnected
{
get {
if (tcpClient == null)
return false;
return tcpClient.Connected;
}
}

创建连接的启动事件，我写两种启动方式，一种是不带参的，一种是带参的，如下：

/// <summary>
/// 打开连接
/// </summary>
/// <returns></returns>
public bool Start()
{
return Start(_Address, _Port);
}
/// <summary>
/// 打开连接
/// </summary>
/// <param name="ip">连接地址</param>
/// <param name="port">连接端口号</param>
/// <returns></returns>
public bool Start(string ip, int port)
{
try
{
_Address = ip;
_Port = port;
tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipaddress = IPAddress.Parse(_Address);
tcpClient.Connect(ipaddress, port);
if (tcpClient.Connected)
{
AsyncReceivedClient rc = new AsyncReceivedClient(Receive);
rc.BeginInvoke(tcpClient, null, null);
}
return tcpClient.Connected;
}
catch (Exception ex)
{
return false;
}
}

需要注意的是：

AsyncReceivedClient rc = new AsyncReceivedClient(Receive);
rc.BeginInvoke(tcpClient, null, null);

这两行，实现的是异步委托带参的调用，实现随时接收服务端发送过来的消息。

在客户端收消息时，需要判断服务端连接是否断开，在网上的介绍上，说使用socket.Poll(1, SelectMode.SelectRead)和socket.Available= 0来判断网络是否断开，但在实际上的使用当中，我使用第三方的服务端，使用这种方式，根本不能判断断开，后来我想，能不能开一个SocketCient，来判断服务端口是否正常，相当于telnet命令，在实际使用当中，还没遇到问题：

/// <summary>
/// 接收消息
/// </summary>
/// <returns></returns>
public void Receive(object o)
{
Socket s = o as Socket;
bool IsConnected = true;
while (s.Connected)
{
try
{
int res = s.Available;
if (res > 0)
{
byte[] xxxx = new byte[res];
int nRead = s.Receive(xxxx);
byte[] buffer = new byte[nRead];
Array.Copy(xxxx, 0, buffer, 0, nRead);
if (ReceiveComtemplate != null)
ReceiveComtemplate(buffer);
}
else
{
try
{
Socket testSocket =
new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
testSocket.Connect(s.RemoteEndPoint);
if (!testSocket.Connected)
{
Stop();
IsConnected = false;
goto EndReceive;
}
else
{
testSocket.Shutdown(SocketShutdown.Both);
testSocket.Close();
}
}
catch (Exception ex)
{
Stop();
IsConnected = false;
goto EndReceive;
}
}
}
catch (Exception ex)
{
Stop();
IsConnected = false;
goto EndReceive;
}
Thread.Sleep(100);
}
EndReceive:
if (!IsConnected)
{
if (HostDisconnectedComtelplate != null)
HostDisconnectedComtelplate();
}
}

最后就是一个发送，一个停止，这个部分，基本和msdn上介绍的一样，没有什么特殊的处理：

/// <summary>
/// 发送消息
/// </summary>
/// <param name="buffer">发送的数据</param>
public void Send(byte[] buffer)
{
try
{
if (tcpClient.Connected)
{
tcpClient.Send(buffer);
}
}
catch { }
}
/// <summary>
/// 停止
/// </summary>
public void Stop()
{
try
{
//tcpClient.Client.Shutdown(SocketShutdown.Both);
//tcpClient.Close();
tcpClient.Shutdown(SocketShutdown.Both);
tcpClient.Close();
}
catch (Exception ex)
{ }
}

到这里基本上已经完成，完整代码如下，如果有不同看法或有更好的意见，欢迎在线留言：

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

namespace System.Net.Securate.TCP
{
public sealed class TCPClient
{
/// <summary>
/// 收到消息事件
/// </summary>
public ReceiveBuffer ReceiveComtemplate;
/// <summary>
/// 主机断开连接事件
/// </summary>
public HostDisconnectionEvent HostDisconnectedComtelplate;
private string _Address;
/// <summary>
/// 获取或设置连接地址
/// </summary>
public string Address
{
get { return _Address; }
set { _Address = value; }
}
private int _Port;
/// <summary>
/// 获取或设置端口号
/// </summary>
public int Port
{
get { return _Port; }
set { _Port = value; }
}
private Socket tcpClient;
/// <summary>
/// 获取连接状态
/// </summary>
public bool IsConnected
{
get {
if (tcpClient == null)
return false;
return tcpClient.Connected;
}
}
/// <summary>
/// 打开连接
/// </summary>
/// <returns></returns>
public bool Start()
{
return Start(_Address, _Port);
}
/// <summary>
/// 打开连接
/// </summary>
/// <param name="ip">连接地址</param>
/// <param name="port">连接端口号</param>
/// <returns></returns>
public bool Start(string ip, int port)
{
try
{
_Address = ip;
_Port = port;
tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipaddress = IPAddress.Parse(_Address);
tcpClient.Connect(ipaddress, port);
if (tcpClient.Connected)
{
AsyncReceivedClient rc = new AsyncReceivedClient(Receive);
rc.BeginInvoke(tcpClient, null, null);
}
return tcpClient.Connected;
}
catch (Exception ex)
{
return false;
}
}
/// <summary>
/// 接收消息
/// </summary>
/// <returns></returns>
public void Receive(object o)
{
Socket s = o as Socket;
bool IsConnected = true;
while (s.Connected)
{
try
{
int res = s.Available;
if (res > 0)
{
byte[] xxxx = new byte[res];
int nRead = s.Receive(xxxx);
byte[] buffer = new byte[nRead];
Array.Copy(xxxx, 0, buffer, 0, nRead);
if (ReceiveComtemplate != null)
ReceiveComtemplate(buffer);
}
else
{
try
{
Socket testSocket =
new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
testSocket.Connect(s.RemoteEndPoint);
if (!testSocket.Connected)
{
Stop();
IsConnected = false;
goto EndReceive;
}
else
{
testSocket.Shutdown(SocketShutdown.Both);
testSocket.Close();
}
}
catch (Exception ex)
{
Stop();
IsConnected = false;
goto EndReceive;
}
}
}
catch (Exception ex)
{
Stop();
IsConnected = false;
goto EndReceive;
}
Thread.Sleep(100);
}
EndReceive:
if (!IsConnected)
{
if (HostDisconnectedComtelplate != null)
HostDisconnectedComtelplate();
}
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="buffer">发送的数据</param>
public void Send(byte[] buffer)
{
try
{
if (tcpClient.Connected)
{
tcpClient.Send(buffer);
}
}
catch { }
}
/// <summary>
/// 停止
/// </summary>
public void Stop()
{
try
{
//tcpClient.Client.Shutdown(SocketShutdown.Both);
//tcpClient.Close();
tcpClient.Shutdown(SocketShutdown.Both);
tcpClient.Close();
}
catch (Exception ex)
{ }
}
}
}

c# Socket(客户端)异步通讯

猜你喜欢