C#实现的异步Socket服务器

　　介绍
　　我最近需要为一个。net项目准备一个内部线程通信机制。 项目有多个使用ASP.NET,Windows 表单和控制台应用程序的服务器和客户端构成。 考虑到实现的可能性，我下定决心要使用原生的socket,而不是许多。NET中已经提前为我们构建好的组件， 像是所谓的管道， NetTcpClient 还有 Azure 服务总线。
　　这篇文章中的服务器基于System.Net.Sockets类异步方法。 这些允许你支持大量的socket客户端， 而一个客户端的连接是唯一的阻塞机制。 阻塞的时间是可以忽略不记得，所以服务器基本上是在当做一个多线程socket服务器在运作的。
　　背景
　　原生的socket在为你提供通信层面的完全控制权上具有优势， 而在处理不同的数据类型是具有很大的灵活性。 你甚至可以通过socket发送序列化了的CLR对象，尽管我在这里不会那样做。 这个项目将会想你展示如何在socket之间发送文本。
　　代码的运用
　　使用下面的代码，你初始化了一个Server类，并运行了Start（）方法：
　　1Server myServer = new Server（）；
　　2myServer.Start（）；
　　如果你计划在一个Windows表单中管理服务器的话，我建议使用一个BackgroundWorker, 因为socket方法（一般会是ManualResentEvent） 将会阻塞GUI线程的运行。
　　Server 类：
　　01using System.Net.Sockets;
　　02
　　03public class Server
　　04{
　　05 private static Socket listener;
　　06 public static ManualResetEvent allDone = new ManualResetEvent（false）；
　　07 public const int _bufferSize = 1024;
　　08 public const int _port = 50000;
　　09 public static bool _isRunning = true;
　　10
　　11 class StateObject
　　12 {
　　13 public Socket workSocket = null;
　　14 public byte[] buffer = new byte[bufferSize];
　　15 public StringBuilder sb = new StringBuilder（）；
　　16 }
　　17
　　18 // Returns the string between str1 and str2
　　19 static string Between（string str, string str1, string str2）
　　20 {
　　21 int i1 = 0, i2 = 0;
　　22 string rtn = "";
　　23
　　24 i1 = str.IndexOf（str1, StringComparison.InvariantCultureIgnoreCase）；
　　25 if （i1 > -1）
　　26 {
　　27 i2 = str.IndexOf（str2, i1 + 1, StringComparison.InvariantCultureIgnoreCase）；
　　28 if （i2 > -1）
　　29 {
　　30 rtn = str.Substring（i1 + str1.Length, i2 - i1 - str1.Length）；
　　31 }
　　32 }
　　33 return rtn;
　　34 }
　　35
　　36 // Checks if the socket is connected
　　37 static bool IsSocketConnected（Socket s）
　　38 {
　　39 return !（（s.Poll（1000, SelectMode.SelectRead） && （s.Available == 0）） || !s.Connected）；
　　40 }
　　41
　　42 // Insert all the other methods here.
　　43}
　　ManualResetEvent 是一个实现了你的socket服务器中事件的。NET类。 我们需要这个项目在我们想要发布阻塞操作的时候向代码发送信号。 你可以试验一下用bufferSize来适配你的需求。 如果能预期到消息的大小， 使用byte单位来设置消息的大小参数bufferSize. port是侦听TCP的端口参数。 要意识到为其它应用程序伺服所使用的接口。 如果你想要能够方便地停止服务器，你需要实现一些机制来将_isRunning设置成false. 这一般可以借助于使用一个 BackgroundWorker做到， 其中你可以使用myWorker.CancellationPending替换_isRunning. 我提到_isRunning的原因是给你在处理取消操作的问题上提供一个方向， 并向你展示侦听器可以方便的停止的 www.jamo123.com
　　Between（） 和IsSocketConnected（） 是辅助方法。
　　现在转过来看看方法。 首先是Start（）方法：
　　01public void Start（）
　　02{
　　03 IPHostEntry ipHostInfo = Dns.GetHostEntry（Dns.GetHostName（））；
　　04 IPEndPoint localEP = new IPEndPoint（IPAddress.Any, _port）；
　　05 listener = new Socket（localEP.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp）；
　　06 listener.Bind（localEP）；
　　07
　　08 while （_IsRunning）
　　09 {
　　10 allDone.Reset（）；
　　11 listener.Listen（10）；
　　12 listener.BeginAccept（new AsyncCallback（acceptCallback）， listener）；
　　13 bool isRequest = allDone.WaitOne（new TimeSpan（12, 0, 0））； // Blocks for 12 hours
　　14
　　15 if （！isRequest）
　　16 {
　　17 allDone.Set（）；
　　18 // Do some work here every 12 hours
　　19 }
　　20 }
　　21 listener.Close（）；
　　22}
　　这个方法初始化了侦听器socket, 并开始等待用户连接的到来。 项目中主要的模式是使用异步委派。 异步委派是在调用者中的状态改变时被异步调用的方法。 isRequest 告诉你WaitOne 是否已经因为有客户端连接或者超时而退出。
　　如果你有大量的客户端连接同时发生， 考虑提高Listen（）方法的队列参数。
　　现在来看看下一个方法， acceptCallback . 这个方法由listener.BeginAccept异步调用。 当方法完成执行时，侦听器会立即侦听新的客户端。
　　01static void acceptCallback（IAsyncResult ar）
　　02{
　　03 // Get the listener that handles the client request.
　　04 Socket listener = （Socket）ar.AsyncState;
　　05
　　06 if （listener != null）
　　07 {
　　08 Socket handler = listener.EndAccept（ar）；
　　09
　　10 // Signal main thread to continue
　　11 allDone.Set（）；
　　12
　　13 // Create state
　　14 StateObject state = new StateObject（）；
　　15 state.workSocket = handler;
　　16 handler.BeginReceive（state.buffer, 0, _bufferSize, 0, new AsyncCallback（readCallback）， state）；
　　17 }
　　18}
　　acceptCallback 会派生出另外一个异步指派： readCallback. 这个方法会读取来自socket的实际数据。 我已经为收发数据作了我自己的控制， 对于_bufferSize来说是不变的。 所有发送到服务器的字符串都必须用<!--SOCKET--> 和 <!--ENDSOCKET-->包起来。 同样，客户端在收到服务器的响应式，必须解除响应信息的包裹， 后者被<!--RESPONSE--> 和 <!--ENDRESPONSE-->包了起来 www.tygj123.com
　　01static void readCallback（IAsyncResult ar）
　　02{
　　03 StateObject state = （StateObject）ar.AsyncState;
　　04 Socket handler = state.workSocket;
　　05
　　06 if （！IsSocketConnected（handler））
　　07 {
　　08 handler.Close（）；
　　09 return;
　　10 }
　　11
　　12 int read = handler.EndReceive（ar）；
　　13
　　14 // Data was read from the client socket.
　　15 if （read > 0）
　　16 {
　　17 state.sb.Append（Encoding.UTF8.GetString（state.buffer, 0, read））；
　　18
　　19 if （state.sb.ToString（）。Contains（"<!--ENDSOCKET-->"））
　　20 {
　　21 string toSend = "";
　　22 string cmd = ts.Strings.Between（state.sb.ToString（）， "<!--SOCKET-->", "<!--ENDSOCKET-->"）；
　　23
　　24 switch （cmd）
　　25 {
　　26 case "Hi!":
　　27 toSend = "How are you?";
　　28 break;
　　29 case "Milky Way?":
　　30 toSend = "No I am not.";
　　31 break;
　　32 }
　　33
　　34 toSend = "<!--RESPONSE-->" + toSend + "<!--ENDRESPONSE-->";
　　35
　　36 byte[] bytesToSend = Encoding.UTF8.GetBytes（toSend）；
　　37 handler.BeginSend（bytesToSend, 0, bytesToSend.Length, SocketFlags.None
　　38 , new AsyncCallback（sendCallback）， state）；
　　39 }
　　40 else
　　41 {
　　42 handler.BeginReceive（state.buffer, 0, _bufferSize, 0
　　43 , new AsyncCallback（readCallback）， state）；
　　44 }
　　45 }
　　46 else
　　47 {
　　48 handler.Close（）；
　　49 }
　　50}
　　readCallback 会派生另外一个方法， sendCallback, 它将会向客户端发送请求。 如果客户端没有关闭连接， sendCallback 将会向socket发送信号以获得更多的数据。
　　01static void sendCallback（IAsyncResult ar）
　　02{
　　03 StateObject state = （StateObject）ar.AsyncState;
　　04 Socket handler = state.workSocket;
　　05 handler.EndSend（ar）；
　　06
　　07 StateObject newstate = new StateObject（）；
　　08 newstate.workSocket = handler;
　　09 handler.BeginReceive（newstate.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback（readCallback）， newstate）；
　　10}
　　我会将写一个socket客户端作为联系留给读者。 socket客户端应该使用同异步调用同样的编程模式。 我希望你能从这篇文章中收获乐趣，并且会像一个socket程序员那样付诸实践！
　　要点
　　我在生产环境下使用了此代码，其中的socket服务器是一个自由文本搜索引擎。 SQL Server缺乏对自由文本搜索支持（你可以使用自由文本索引，但它们是缓慢和昂贵的）。socket服务器负载了大量导向IEnumerables的文本数据，并使用Linq来搜索文本。来自socket服务器的响应从数百万行的Unicode文本数据中搜索时间在几毫秒内。我们还使用了三个分布式的Sphinx服务器。socket服务器充当了Sphinx服务器的高速缓存 www.yztrans.com