zoukankan      html  css  js  c++  java

  • C# 实现的异步 Socket 服务器

    介绍

    我最近需要为一个.net项目准备一个内部线程通信机制. 项目有多个使用ASP.NET，Windows 表单和控制台应用程序的服务器和客户端构成. 考虑到实现的可能性，我下定决心要使用原生的socket，而不是许多.NET中已经提前为我们构建好的组件, 像是所谓的管道, NetTcpClient 还有 Azure 服务总线.

    这篇文章中的服务器基于System.Net.Sockets类异步方法. 这些允许你支持大量的socket客户端, 而一个客户端的连接是唯一的阻塞机制. 阻塞的时间是可以忽略不记得，所以服务器基本上是在当做一个多线程socket服务器在运作的.

    背景

    原生的socket在为你提供通信层面的完全控制权上具有优势, 而在处理不同的数据类型是具有很大的灵活性. 你甚至可以通过socket发送序列化了的CLR对象，尽管我在这里不会那样做. 这个项目将会想你展示如何在socket之间发送文本.

    代码的运用

    使用下面的代码，你初始化了一个Server类，并运行了Start()方法:

    1 Server myServer = new Server();
    2 myServer.Start();

    如果你计划在一个Windows表单中管理服务器的话，我建议使用一个BackgroundWorker, 因为socket方法(一般会是ManualResentEvent) 将会阻塞GUI线程的运行.

    Server 类:

    01 using System.Net.Sockets;
    02  
    03 public 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的原因是给你在处理取消操作的问题上提供一个方向, 并向你展示侦听器可以方便的停止的.

    Between() 和IsSocketConnected() 是辅助方法.

    现在转过来看看方法. 首先是Start()方法:

    01 public 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异步调用. 当方法完成执行时，侦听器会立即侦听新的客户端.

    01 static 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-->包了起来。

    01 static 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发送信号以获得更多的数据.

    01 static 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服务器（www.sphinxsearch.com）。socket服务器充当了Sphinx服务器的高速缓存。如果你需要一个快速的自由文本搜索引擎，我强烈建议使用Sphinx。

    原文地址：http://www.codeproject.com/Articles/745134/csharp-async-socket-server
  • 相关阅读:
    Solidity notes
    Solidity by Example详解
    基本命令中部
    基本命令上部
    服务器介绍
    Linux发展史及安装
    ERROR: Unrecognized command line argument: 'use'
    RequireJs 深入理解
    Redis 安装教程 （Windows 2.6.13 稳定版）
    System.AccessViolationException: 尝试读取或写入受保护的内存 解决办法
  • 原文地址：https://www.cnblogs.com/gc2013/p/3651847.html
Copyright © 2011-2022 走看看