介紹

我最近需要為一個.net專案準備一個內部執行緒通訊機制. 專案有多個使用ASP.NET，Windows 表單和控制檯應用程式的伺服器和客戶端構成. 考慮到實現的可能性，我下定決心要使用原生的socket，而不是許多.NET中已經提前為我們構建好的元件, 像是所謂的管道, NetTcpClient 還有 Azure 服務匯流排.

這篇文章中的伺服器基於System.Net.Sockets類非同步方法. 這些允許你支援大量的socket客戶端, 而一個客戶端的連線是唯一的阻塞機制. 阻塞的時間是可以忽略不記得，所以伺服器基本上是在當做一個多執行緒socket伺服器在運作的.

背景

原生的socket在為你提供通訊層面的完全控制權上具有優勢, 而在處理不同的資料型別是具有很大的靈活性. 你甚至可以通過socket傳送序列化了的CLR物件，儘管我在這裡不會那樣做. 這個專案將會想你展示如何在socket之間傳送文字.
程式碼的運用

使用下面的程式碼，你初始化了一個Server類，並運行了Start()方法: 

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

如果你計劃在一個Windows表單中管理伺服器的話，我建議使用一個BackgroundWorker, 因為socket方法(一般會是ManualResentEvent) 將會阻塞GUI執行緒的執行.

Server 類:  

using System.Net.Sockets;
 
public class Server
{
  private static Socket listener;
  public static ManualResetEvent allDone = new ManualResetEvent(false);
  public const int _bufferSize = 1024;
  public const int _port = 50000;
  public static bool _isRunning = true
 
;
 
  class StateObject
  {
    public Socket workSocket = null;
    public byte[] buffer = new byte[bufferSize];
    public StringBuilder sb = new StringBuilder();
  }
 
  // Returns the string between str1 and str2
  static string Between(string str, string str1, string str2)
  {
    int i1 = 0, i2 = 0;
    string rtn = "";
 
    i1 = str.IndexOf(str1, StringComparison.InvariantCultureIgnoreCase);
    if (i1 > -1)
    {
      i2 = str.IndexOf(str2, i1 + 1, StringComparison.InvariantCultureIgnoreCase);
      if (i2 > -1)
      {
        rtn = str.Substring(i1 + str1.Length, i2 - i1 - str1.Length);
      }
    }
    return rtn;
  }
 
  // Checks if the socket is connected
  static bool IsSocketConnected(Socket s)
  {
    return !((s.Poll(1000, SelectMode.SelectRead) && (s.Available == 0)) || !s.Connected);
  }
 
  // Insert all the other methods here.
}

ManualResetEvent 是一個實現了你的socket伺服器中事件的.NET類. 我們需要這個專案在我們想要釋出阻塞操作的時候向程式碼傳送訊號. 你可以試驗一下用bufferSize來適配你的需求. 如果能預期到訊息的大小, 使用byte單位來設定訊息的大小引數bufferSize. port是偵聽TCP的埠引數. 要意識到為其它應用程式伺服所使用的介面. 如果你想要能夠方便地停止伺服器，你需要實現一些機制來將_isRunning設定成false. 這一般可以藉助於使用一個 BackgroundWorker做到, 其中你可以使用myWorker.CancellationPending替換_isRunning. 我提到_isRunning的原因是給你在處理取消操作的問題上提供一個方向, 並向你展示偵聽器可以方便的停止的.

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

現在轉過來看看方法. 首先是Start()方法:

public void Start()
{
  IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
  IPEndPoint localEP = new IPEndPoint(IPAddress.Any, _port);
  listener = new Socket(localEP.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
  listener.Bind(localEP);
 
  while (_IsRunning)
  {
    allDone.Reset();
    listener.Listen(10);
    listener.BeginAccept(new AsyncCallback(acceptCallback), listener);
    bool isRequest = allDone.WaitOne(new TimeSpan(12, 0, 0)); // Blocks for 12 hours
 
    if (!isRequest)
    {
      allDone.Set();
      // Do some work here every 12 hours
    }
  }
  listener.Close();
}

這個方法初始化了偵聽器socket, 並開始等待使用者連線的到來. 專案中主要的模式是使用非同步委派. 非同步委派是在呼叫者中的狀態改變時被非同步呼叫的方法. isRequest 告訴你WaitOne 是否已經因為有客戶端連線或者超時而退出.

如果你有大量的客戶端連線同時發生, 考慮提高Listen()方法的佇列引數.

現在來看看下一個方法, acceptCallback . 這個方法由listener.BeginAccept非同步呼叫. 當方法完成執行時，偵聽器會立即偵聽新的客戶端.

static void acceptCallback(IAsyncResult ar)
{
  // Get the listener that handles the client request.
  Socket listener = (Socket)ar.AsyncState;
 
  if (listener != null)
  {
    Socket handler = listener.EndAccept(ar);
 
    // Signal main thread to continue
    allDone.Set();
 
    // Create state
    StateObject state = new StateObject();
    state.workSocket = handler;
    handler.BeginReceive(state.buffer, 0, _bufferSize, 0, new AsyncCallback(readCallback), state);
  }
}

acceptCallback 會派生出另外一個非同步指派: readCallback. 這個方法會讀取來自socket的實際資料. 我已經為收發資料作了我自己的控制, 對於_bufferSize來說是不變的. 所有傳送到伺服器的字串都必須用<!--SOCKET--> 和 <!--ENDSOCKET-->包起來. 同樣，客戶端在收到伺服器的響應式，必須解除響應資訊的包裹, 後者被<!--RESPONSE--> 和 <!--ENDRESPONSE-->包了起來。

static void readCallback(IAsyncResult ar)
{
  StateObject state = (StateObject)ar.AsyncState;
  Socket handler = state.workSocket;
 
  if (!IsSocketConnected(handler)) 
  {
    handler.Close();
    return;
  }
 
  int read = handler.EndReceive(ar);
 
  // Data was read from the client socket.
  if (read > 0)
  {
    state.sb.Append(Encoding.UTF8.GetString(state.buffer, 0, read));
 
    if (state.sb.ToString().Contains("<!--ENDSOCKET-->"))
    {
      string toSend = "";
      string cmd = ts.Strings.Between(state.sb.ToString(), "<!--SOCKET-->", "<!--ENDSOCKET-->");
           
      switch (cmd)
      {
        case "Hi!":
          toSend = "How are you?";
          break;
        case "Milky Way?":
          toSend = "No I am not.";
          break;
      }
 
      toSend = "<!--RESPONSE-->" + toSend + "<!--ENDRESPONSE-->";
 
      byte[] bytesToSend = Encoding.UTF8.GetBytes(toSend);
      handler.BeginSend(bytesToSend, 0, bytesToSend.Length, SocketFlags.None
        , new AsyncCallback(sendCallback), state);
    }
    else 
    {
      handler.BeginReceive(state.buffer, 0, _bufferSize, 0
          , new AsyncCallback(readCallback), state);
    }
  }
  else
  {
      handler.Close();
  }
}

readCallback 會派生另外一個方法, sendCallback, 它將會向客戶端傳送請求. 如果客戶端沒有關閉連線, sendCallback 將會向socket傳送訊號以獲得更多的資料.

static void sendCallback(IAsyncResult ar)
{
  StateObject state = (StateObject)ar.AsyncState;
  Socket handler = state.workSocket;
  handler.EndSend(ar);
 
  StateObject newstate = new StateObject();
  newstate.workSocket = handler;
  handler.BeginReceive(newstate.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(readCallback), newstate);
}

我會將寫一個socket客戶端作為聯絡留給讀者. socket客戶端應該使用同異步呼叫同樣的程式設計模式. 我希望你能從這篇文章中收穫樂趣，並且會像一個socket程式設計師那樣付諸實踐!

要點

我在生產環境下使用了此程式碼，其中的socket伺服器是一個自由文字搜尋引擎。 SQL Server缺乏對自由文字搜尋支援（你可以使用自由文字索引，但它們是緩慢和昂貴的）。socket伺服器負載了大量導向IEnumerables的文字資料，並使用Linq來搜尋文字。來自socket伺服器的響應從數百萬行的Unicode文字資料中搜索時間在幾毫秒內。我們還使用了三個分散式的Sphinx伺服器（www.sphinxsearch.com）。socket伺服器充當了Sphinx伺服器的快取記憶體。如果你需要一個快速的自由文字搜尋引擎，我強烈建議使用Sphinx。

**************轉載：https://m.jb51.net/article/69359.htm