C# 异步Socket （BeginXXXX）服务器代码

最新推荐文章于 2024-01-09 18:22:34 发布

蓝色水

最新推荐文章于 2024-01-09 18:22:34 发布

阅读量501

点赞数

分类专栏： c#

c# 专栏收录该内容

222 篇文章 1 订阅

订阅专栏

前言：

1、最近维护公司的一个旧项目，是Socket通讯的，主要用于接收IPC（客户端）发送上来的抓拍图像，期间要保持通讯，监测数据包并进行处理。但是看之前那人写的代码个人觉得并不是很适合自己，于是就重写了，不过项目暂时弃置了，为了以后能够方便使用，也方便更多像我一样还是渣渣程序员的人，记录一些心得。我还是坚信那句话，分享才能够进步得更快

2、其实在做之前我对这个东西了解也很少，毕竟以我的认识，在国内C#更多地是用来开发网站，于是也在网上看了很多前辈贴的代码，我尝试过直接复制粘贴，发现很多都用不了最后自己写了才发现原来是这么一回事。所以在这里也奉劝各位不要做伸手党，通过自己的理解才能够将别人的知识转变成为自己的资本

开始：

1、Socket 通信分为同步和异步两种模式，客户端一般用同步，异步多用于服务端。至于两者的区别，很多前辈已经有博客阐述过了，我这里就贴其中一个链接帮助大家理解：http://www.cnblogs.com/BLoodMaster/archive/2010/07/02/1769774.html。万一这个链接失效，相信大家也会搜索到其他资源的

2、做这种Socket通信，我觉得关键点在于【数据处理】而不是建立链接，但往往很多不了解人会遇到各种困难，比如Socket链接关闭，丢包，粘包之类的。通用做法就是

2.1：使用缓冲区，将接收到的字节数组全部储存起来，再去分析数据，获取有效部分。

2.2：服务器跟客户端需要约定好报文的格式，一般来说至少要有【数据头标识】、【数据实体长度】、【数据尾标识】，这样才能更好地对数据进行处理，否则你很难界定到底哪一段数据才是你想要的。

2.3：数据分析一定要少用字符串或者字符拆解，因为这样很有可能获取到的长度是错误的（里面有很多空字节，或者编码解码问题导致字符串长度不一致），所以一定要用字节数组来处理，通过约定好的编码解码格式，查找标识所在位置进行数据拆解。

【比如：客户端跟服务器连接需要核对身份信息，因此对一字符串进行的特殊加密再编码发送，服务器接收到数据之后如果先编译成了字符串再获取密码转成byte[]，长度跟之前记录的很可能就会不一样】。不过对于获取报文头信息这一类通过字符串来拆解更为方便

3、在建立连接时通常发生的问题就是没有循环接收客户端消息导致socket被释放，或者只接受到客户端了几条消息之后就停了，我也遇到过这个问题，所以建立连接的关键在于BeginAccept和BeginReceive两个方法的递归循环调用

4、接下来就是贴代码了，这里只有服务器的，客户端的我还没有做以后补全了会发上来，入口函数是公开的，主要方法全部在这里，至于辅助函数（比如获取IP地址，检查端口是否被占用、获取发送消息大家可以自己去找一下吧，毕竟这些已经有很多前辈开源了）

4.1：由于本人只是一渣渣野生程序猿，如果大家有什么不同的看法请提出来，交流也是一种很好的进步方式

4.2：如果大家觉得有用，还是希望能够推荐一下，让更多新人看到，让大家能够彼此学习

4.3：我更希望有大神来告诉我不足的地方，因为我知道这些代码写得并不好~

public void Create_Server_Socket()

{

Thread th_server = null;

string result = string.Empty;

try

{

socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

IPAddress ip = Pubilc.Helper.Computer.GetIPv4();

IPEndPoint point = new IPEndPoint(ip, this._port);

socketServer.Bind(point);

socketServer.Listen(this._listen);

th_server = new Thread(() =>

{

if (this._isRunning)

socketServer.BeginAccept(AcceptCallBack, socketServer);

else

Close_Server_Socket();

});

th_server.IsBackground = true;

th_server.Start();

}

catch (Exception ex)

{

if (th_server.IsAlive)

th_server.Abort();

ShowLog(ex.Message);

};

}

public void Close_Server_Socket()

{

if (socketServer != null)

{

socketServer.Close();

}

}

void AcceptCallBack(IAsyncResult ar)

{

Socket socketServer = (Socket)ar.AsyncState;

try

{

Socket socketAccept = socketServer.EndAccept(ar);

DynamicBuffer state = new DynamicBuffer();

state.workSocket = socketAccept;

socketAccept.BeginReceive(state.Buffers, 0, state.Buffers.Length, SocketFlags.None, ReceiveCallBack, state);

}

catch(Exception ex)

{

LogHelper.WriteLog(typeof(SocketHelper_Server), ex);

ShowLog("AcceptCallBack" + ex.Message);

}

finally

{

if (this._isRunning)

socketServer.BeginAccept(AcceptCallBack, socketServer);

}

}

void ReceiveCallBack(IAsyncResult ar)

{

string sendMsg = string.Empty;

DynamicBuffer state = (DynamicBuffer)ar.AsyncState;

Socket socketAccept = state.workSocket;

try

{

int len = socketAccept.EndReceive(ar);

if (len > 0)

{

state.WritBuffer();

}

else

{

sendMsg=doMsg.CheckConnection(socketAccept.RemoteEndPoint.ToString());

if (!string.IsNullOrEmpty(sendMsg))

{

byte[] buffer = Encoding.Default.GetBytes(sendMsg);

state.sb.AddRange(buffer);

}

else

{

socketAccept.Shutdown(SocketShutdown.Both);

socketAccept.Close();

}

}

}

catch (Exception ex)

{

LogHelper.WriteLog(typeof(SocketHelper_Server), ex);

ShowLog("ReceiveCallBack" + ex.Message);

}

finally

{

if (this._isRunning)

{

try

{

Thread th_send = null;

th_send = new Thread(() =>

{

Send(ref state);

th_send.Abort();

});

th_send.IsBackground = true;

th_send.Start();

socketAccept.BeginReceive(state.Buffers, 0, state.Buffers.Length, SocketFlags.None, ReceiveCallBack, state);

}

catch (Exception ex)

{

showLog(ex.Message);

LogHelper.WriteLog(typeof(IpcServerDo), ex);

}

}

}

}

void Send(ref DynamicBuffer state)

{

byte[] buffer = null;

string sendMsg = string.Empty;

Socket socketAccept = state.workSocket;

Dictionary<string, byte[]> data;

state.GetAllData(out data);

if (data.Count > 0)

{

sendMsg = doMsg.AcceptFromIpc(socketAccept.RemoteEndPoint.ToString(), ref data);

if (!string.IsNullOrEmpty(sendMsg))

{

buffer = Encoding.Default.GetBytes(sendMsg.ToCharArray());

socketAccept.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, SendCallBack, socketAccept);

}

Send(ref state);

}

}

void SendCallBack(IAsyncResult ar)

{

Socket socketAccept = (Socket)ar.AsyncState;

try

{

int sendBytes = socketAccept.EndSend(ar);

}

catch(Exception ex)

{

LogHelper.WriteLog(typeof(SocketHelper_Server), ex);

}

}

4、下面是State对象类，其实这个就是相当于缓冲区，将东西放到这里来保存，包括socket对象，其实有用的就是上面的声明部分和构造函数，至于下面的写入方法和数据拆解，缓冲区清理的方法我都觉得有待提高，因为用这种方法我在接收一张500KB左右的图片竟然要10秒才有返回结果（整个逻辑流程完成并发送数据的时间），这是不可以接受的，所以下面的数据处理方法，大家见仁见智吧，根据自己的需求去找到自己适合的方法，这里只是提供思路

/// <summary>

/// 循环队列

/// </summary>

/// <typeparam name="T"></typeparam>

public class DynamicBuffer

{

/// <summary>

/// 缓冲区大小

/// </summary>

public int bufferSize { get; set; }

/// <summary>

/// 通讯对象

/// </summary>

public Socket workSocket { get; set; }

/// <summary>

/// 缓冲区

/// </summary>

public byte[] Buffers { get; set; }

/// <summary>

/// 储存区

/// </summary>

public List<byte> sb;

public DynamicBuffer()

{

this.bufferSize = 1024 *64;

this.sb = new List<byte>();

this.Buffers = new byte[bufferSize];

}

/// <summary>

/// 将缓冲区数据放入储存区

/// </summary>

public void WritBuffer()

{

int endPosition = 0;

byte[] buffer;

int len = 0;

for (endPosition = this.Buffers.Length - 1; endPosition >= 0; endPosition--)

{

//由于发现数据中有很多\0的空字节，此处从最后开始执行反向删除

if (this.Buffers[endPosition] != (byte)'\0')

break;

}

len = endPosition + 1;//因为是取长度，而不是位置，因此此处+1

buffer = new byte[len];

Array.Copy(this.Buffers, 0, buffer, 0, len);

this.sb.AddRange(buffer);

this.Buffers = new byte[bufferSize];

}

//返回指定的长度的byet[]数据,并会清理对应的储存区

public void GetAllData(out Dictionary<string, byte[]> data)

{

int DataLength = 0;

DataLength = GetAllAcceptMsg(out data);

if (DataLength > 0)

{

ClearList(DataLength);

}

}

//清理储存区已经发送的内容以及空包数据,以便下一次接收使用

private void ClearList(int DataLength)

{

this.sb.RemoveRange(0, DataLength);

}

/// <summary>

/// 判断储存区是否有接受完整的包

/// 并将完整的包存放，拆解

/// </summary>

/// <returns>单次有效数据的长度</returns>

private int GetAllAcceptMsg(out Dictionary<string, byte[]> data)

{

int DataLength=0;

int contentLength = 0;

int newlinePosition = 0;

string title = string.Empty;

string arr_msg = string.Empty;

byte[] buffer = this.sb.ToArray();

data = new Dictionary<string, byte[]>();

try

{

newlinePosition = StaticHelp.Search(buffer, Encoding.Default.GetBytes("\r\n\r\n\r\n"), false);//查找换行的位置

if (newlinePosition > 0)

{

arr_msg = Encoding.UTF8.GetString(buffer);

contentLength = Convert.ToInt32(CommonHelper.GetStrByRegex(arr_msg, "Content-Length: ", "\r\n"));

int dataLen = buffer.Length - newlinePosition;

if (dataLen >= contentLength)

{

title = arr_msg.Split(new string[] { "\r\n\r\n\r\n" }, StringSplitOptions.None)[0] + "\r\n";

byte[] postData = new byte[contentLength];

if (contentLength > 0)

Buffer.BlockCopy(buffer, newlinePosition, postData, 0, contentLength);

data.Add(title, postData);

DataLength = newlinePosition + contentLength;

}

}

else

{

DataLength = 0;

}

}

catch (Exception ex)

{

LogHelper.WriteLog(typeof(IpcServerDo), ex);

}

return DataLength;

}

}