Wie schreibe ich einen skalierbaren Tcp / Ip-basierten Server

Ich bin in der Design-Phase des Schreibens einer neuen Windows-Dienstanwendung, die TCP / IP-Verbindungen für lang laufende Verbindungen akzeptiert (dh es ist nicht wie HTTP, wo es viele kurze Verbindungen gibt, sondern ein Client verbindet und bleibt für Stunden oder Tage verbunden oder sogar Wochen).

Ich suche nach Ideen für die beste Art, die Netzwerkarchitektur zu entcasting. Ich muss mindestens einen Thread für den Dienst starten. Ich überlege mir, die Asynch-API (BeginRecieve, etc ..) zu verwenden, da ich nicht weiß, wie viele Clients ich zu einem bestimmten Zeitpunkt verbunden habe (möglicherweise Hunderte). Ich möchte definitiv keinen Thread für jede Verbindung starten.

Die Daten werden hauptsächlich von meinem Server an die Clients übertragen, aber es werden gelegentlich Befehle von den Clients gesendet. Dies ist in erster Linie eine Überwachungsanwendung, bei der mein Server regelmäßig Statusdaten an die Clients sendet.

Irgendwelche Vorschläge für den besten Weg, dies so skalierbar wie möglich zu machen? Grundlegender Workflow? Vielen Dank.

EDIT: Um klar zu sein, suche ich nach. NET-basierten Lösungen (C # wenn möglich, aber jede. NET-Sprache wird funktionieren)

BOUNTY NOTE: Um das Kopfgeld zu erhalten, erwarte ich mehr als eine einfache Antwort. Ich würde ein funktionierendes Beispiel für eine Lösung benötigen, entweder als einen pointers auf etwas, das ich herunterladen könnte, oder als ein kurzes Beispiel in einer Zeile. Und es muss .net und Windows sein (jede .net Sprache ist akzeptabel)

EDIT: Ich möchte allen danken, die gute Antworten gegeben haben. Leider konnte ich nur einen akzeptieren, und ich entschied mich dafür, die bekanntere Begin / End-Methode zu akzeptieren. Esacs Lösung mag zwar besser sein, aber es ist immer noch neu genug, dass ich nicht sicher weiß, wie es funktionieren wird.

Ich habe alle Antworten aufgewertet, die ich für gut befunden habe. Ich wünschte, ich könnte mehr für euch tun. Danke noch einmal.

Solutions Collecting From Web of "Wie schreibe ich einen skalierbaren Tcp / Ip-basierten Server"

Ähnliches habe ich in der Vergangenheit geschrieben. Aus meinen Recherchen vor Jahren hat sich gezeigt, dass das Schreiben Ihrer eigenen Socket-Implementierung die beste Wette ist, die asynchronen Sockets verwendet. Dies bedeutete, dass Kunden, die wirklich nichts tun, tatsächlich relativ wenig Ressourcen benötigten. Alles, was passiert, wird vom .NET-Thread-Pool behandelt.

Ich schrieb es als eine class, die alle Verbindungen für die Server verwaltet.

Ich habe einfach eine Liste verwendet, um alle Client-Verbindungen zu halten, aber wenn Sie schnellere Suchvorgänge für größere Listen benötigen, können Sie sie schreiben, wie Sie wollen.

private List _sockets; 

Außerdem muss der Socket tatsächlich auf eingehende Verbindungen warten.

 private System.Net.Sockets.Socket _serverSocket; 

Die Startmethode startet den Server-Socket und beginnt auf eingehende Verbindungen zu warten.

 public bool Start() { System.Net.IPHostEntry localhost = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName()); System.Net.IPEndPoint serverEndPoint; try { serverEndPoint = new System.Net.IPEndPoint(localhost.AddressList[0], _port); } catch (System.ArgumentOutOfRangeException e) { throw new ArgumentOutOfRangeException("Port number entered would seem to be invalid, should be between 1024 and 65000", e); } try { _serverSocket = new System.Net.Sockets.Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp); } catch (System.Net.Sockets.SocketException e) { throw new ApplicationException("Could not create socket, check to make sure not duplicating port", e); } try { _serverSocket.Bind(serverEndPoint); _serverSocket.Listen(_backlog); } catch (Exception e) { throw new ApplicationException("Error occured while binding socket, check inner exception", e); } try { //warning, only call this once, this is a bug in .net 2.0 that breaks if // you're running multiple asynch accepts, this bug may be fixed, but // it was a major pain in the ass previously, so make sure there is only one //BeginAccept running _serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket); } catch (Exception e) { throw new ApplicationException("Error occured starting listeners, check inner exception", e); } return true; } 

Ich möchte nur bemerken, dass der Ausnahmebehandlungscode schlecht aussieht, aber der Grund dafür ist, dass ich Ausnahmenausblendungscode darin hatte, so dass irgendwelche Ausnahmen unterdrückt werden würden, und false zurückgab, wenn eine Konfigurationsoption gesetzt war, aber ich wollte sie entfernen der Kürze halber.

Der obige _serverSocket.BeginAccept (neuer AsyncCallback (acceptCallback)), _serverSocket) setzt unseren Server-Socket im Wesentlichen so ein, dass er die acceptCallback-Methode aufruft, wenn ein Benutzer eine Verbindung herstellt. Diese Methode wird vom .NET-Threadpool ausgeführt, der automatisch das Erstellen zusätzlicher Arbeitsthreads verarbeitet, wenn Sie viele Blockierungsvorgänge ausführen. Dies sollte jede Last auf dem Server optimal handhaben.

  private void acceptCallback(IAsyncResult result) { xConnection conn = new xConnection(); try { //Finish accepting the connection System.Net.Sockets.Socket s = (System.Net.Sockets.Socket)result.AsyncState; conn = new xConnection(); conn.socket = s.EndAccept(result); conn.buffer = new byte[_bufferSize]; lock (_sockets) { _sockets.Add(conn); } //Queue recieving of data from the connection conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn); //Queue the accept of the next incomming connection _serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket); } catch (SocketException e) { if (conn.socket != null) { conn.socket.Close(); lock (_sockets) { _sockets.Remove(conn); } } //Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners _serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket); } catch (Exception e) { if (conn.socket != null) { conn.socket.Close(); lock (_sockets) { _sockets.Remove(conn); } } //Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners _serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket); } } 

Der obige Code hat im Wesentlichen nur die BeginReceive Verbindung akzeptiert, Warteschlangen BeginReceive , ein callback, der ausgeführt wird, wenn der Client Daten sendet, und dann den nächsten acceptCallback der die nächste acceptCallback akzeptiert.

Der BeginReceive Methodenaufruf teilt dem Socket mit, was er tun soll, wenn er Daten vom Client empfängt. Für BeginReceive müssen Sie ihm ein BeginReceive geben, mit dem die Daten kopiert werden, wenn der Client Daten sendet. Die ReceiveCallback Methode wird aufgerufen, und so behandeln wir Daten.

 private void ReceiveCallback(IAsyncResult result) { //get our connection from the callback xConnection conn = (xConnection)result.AsyncState; //catch any errors, we'd better not have any try { //Grab our buffer and count the number of bytes receives int bytesRead = conn.socket.EndReceive(result); //make sure we've read something, if we haven't it supposadly means that the client disconnected if (bytesRead > 0) { //put whatever you want to do when you receive data here //Queue the next receive conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn); } else { //Callback run but no data, close the connection //supposadly means a disconnect //and we still have to close the socket, even though we throw the event later conn.socket.Close(); lock (_sockets) { _sockets.Remove(conn); } } } catch (SocketException e) { //Something went terribly wrong //which shouldn't have happened if (conn.socket != null) { conn.socket.Close(); lock (_sockets) { _sockets.Remove(conn); } } } } 

EDIT: In diesem Muster habe ich vergessen, das in diesem Bereich des Codes zu erwähnen:

 //put whatever you want to do when you receive data here //Queue the next receive conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn); 

Was ich im Allgemeinen tun würde, ist in dem, was auch immer Sie möchten, Code, ist Neuzusammensetzen von Paketen in Nachrichten, und dann erstellen Sie sie als Jobs im Thread-Pool. Auf diese Weise wird der BeginReceive des nächsten Blocks vom Client nicht verzögert, während der Code zur Verarbeitung der Nachricht ausgeführt wird.

Der accept callback beendet das Lesen des Datensockets durch den Aufruf von end receive. Dies füllt den Puffer, der in der begin receive-function bereitgestellt wird. Sobald Sie tun, was Sie wollen, wo ich den Kommentar hinterlassen habe, rufen wir die nächste BeginReceive Methode auf, die den Callback erneut BeginReceive , wenn der Client weitere Daten sendet. Jetzt ist hier der wirklich schwierige Teil, wenn der Client Daten sendet, kann Ihr Empfangsrückruf nur mit einem Teil der Nachricht angerufen werden. Der Zusammenbau kann sehr kompliziert werden. Ich habe meine eigene Methode verwendet und dafür eine Art proprietäres Protokoll erstellt. Ich habe es weggelassen, aber wenn du es anforderst, kann ich es hinzufügen. Dieser Handler war eigentlich der komplizierteste Code, den ich je geschrieben habe.

 public bool Send(byte[] message, xConnection conn) { if (conn != null && conn.socket.Connected) { lock (conn.socket) { //we use a blocking mode send, no async on the outgoing //since this is primarily a multithreaded application, shouldn't cause problems to send in blocking mode conn.socket.Send(bytes, bytes.Length, SocketFlags.None); } } else return false; return true; } 

Die obige Sendemethode verwendet tatsächlich einen synchronen Sendeaufruf, was für mich aufgrund der Nachrichtengrößen und der Multithread-Art meiner Anwendung in Ordnung war. Wenn Sie an jeden Client senden möchten, müssen Sie lediglich die _Sockets-Liste durchlaufen.

Die oben erwähnte xConnection-class ist im Grunde ein einfacher Wrapper für einen Socket, der den Byte-Puffer enthält, und in meiner Implementierung einige Extras.

 public class xConnection : xBase { public byte[] buffer; public System.Net.Sockets.Socket socket; } 

Auch als Referenz hier sind die using s ich einschließe, da ich immer genervt bin, wenn sie nicht enthalten sind.

 using System.Net.Sockets; 

Ich hoffe, das ist hilfreich, es ist vielleicht nicht der sauberste Code, aber es funktioniert. Es gibt auch einige Nuancen im Code, die Sie beim Ändern nicht beachten sollten. Zum einen, nur einen einzigen BeginAccept zu jeder Zeit aufgerufen. Früher gab es einen sehr nervigen .net Bug, der vor Jahren war, also erinnere ich mich nicht an die Details.

Außerdem ReceiveCallback wir im ReceiveCallback Code alles, was vom Socket empfangen wird, bevor wir den nächsten Empfang in die Warteschlange stellen. Dies bedeutet, dass wir für einen einzelnen Socket zu einem beliebigen Zeitpunkt nur einmal in ReceiveCallback sind und keine Thread-Synchronisation verwenden müssen. Wenn Sie dies jedoch neu anordnen, um den nächsten Empfang sofort nach dem Ziehen der Daten aufzurufen, was möglicherweise etwas schneller ist, müssen Sie sicherstellen, dass Sie die Threads ordnungsgemäß synchronisieren.

Außerdem habe ich viel von meinem Code gehackt, aber ich habe die Essenz dessen, was gerade passiert, verlassen. Dies sollte ein guter Anfang für Ihr Design sein. Hinterlasse einen Kommentar, wenn du weitere Fragen hast.

Es gibt viele Möglichkeiten, Netzwerkoperationen in C # durchzuführen. Sie alle verwenden unterschiedliche Mechanismen unter der Haube und leiden daher unter großen performancesproblemen mit einer hohen Parallelität. Begin * -Operationen sind eine dieser Methoden, die von vielen oft als schnellere / schnellste Art der Netzwerkarbeit bezeichnet wird.

Um diese Probleme zu lösen, führten sie den * Async-Methodensatz ein: Von MSDN http://msdn.microsoft.com/en-us/library/system.net.sockets.socketasyncenzentargs.aspx

Die SocketAsyncEventArgs-class ist Teil einer Reihe von Erweiterungen der System.Net.Sockets .. ::. Socket-class, die ein alternatives asynchrones Muster bereitstellen, das von spezialisierten Hochleistungs-Socket-Anwendungen verwendet werden kann. Diese class wurde speziell für Netzwerkserveranwendungen entwickelt, die eine hohe performance erfordern. Eine Anwendung kann das erweiterte asynchrone Muster ausschließlich oder nur in ausgewählten heißen Bereichen verwenden (z. B. beim Empfang großer Datenmengen).

Das Hauptmerkmal dieser Verbesserungen ist die Vermeidung der wiederholten Zuweisung und Synchronisierung von Objekten während asynchronen Socket-I / O mit hohem Volumen. Das Begin / End-Entwurfsmuster, das derzeit von der System.Net.Sockets .. ::. Socket-class implementiert wird, erfordert, dass für jede asynchrone Socket-Operation ein System .. ::. IAsyncResult-Objekt zugewiesen wird.

Unter dem Deckblatt verwendet die * Async-API IO-Completion-Ports, die die schnellste Möglichkeit zur Durchführung von Netzwerkoperationen darstellen, siehe http://msdn.microsoft.com/en-us/magazine/cc302334.aspx

Und nur um Ihnen zu helfen, schließe ich den Quellcode für einen Telnet-Server ein, den ich mit der * Async-API geschrieben habe. Ich schließe nur die relevanten Teile ein. Beachten Sie auch, dass ich die Daten nicht inline verarbeiten muss, sondern sie stattdessen in eine blockierungsfreie (Wartelose) Warteschlange verschiebe, die in einem separaten Thread verarbeitet wird. Beachten Sie, dass ich die entsprechende Pool-class nicht einschließe, die nur ein einfacher Pool ist, der ein neues Objekt erstellt, wenn es leer ist, und die Buffer-class, die nur ein selbstexpandierender Puffer ist, der nicht wirklich benötigt wird, es sei denn, Sie erhalten ein Indeterminist Datenmenge. Wenn Sie mehr Informationen wünschen, zögern Sie nicht, mir eine PM zu senden.

  public class Telnet { private readonly Pool m_EventArgsPool; private Socket m_ListenSocket; ///  /// This event fires when a connection has been established. ///  public event EventHandler Connected; ///  /// This event fires when a connection has been shutdown. ///  public event EventHandler Disconnected; ///  /// This event fires when data is received on the socket. ///  public event EventHandler DataReceived; ///  /// This event fires when data is finished sending on the socket. ///  public event EventHandler DataSent; ///  /// This event fires when a line has been received. ///  public event EventHandler LineReceived; ///  /// Specifies the port to listen on. ///  [DefaultValue(23)] public int ListenPort { get; set; } ///  /// Constructor for Telnet class. ///  public Telnet() { m_EventArgsPool = new Pool(); ListenPort = 23; } ///  /// Starts the telnet server listening and accepting data. ///  public void Start() { IPEndPoint endpoint = new IPEndPoint(0, ListenPort); m_ListenSocket = new Socket(endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); m_ListenSocket.Bind(endpoint); m_ListenSocket.Listen(100); // // Post Accept // StartAccept(null); } ///  /// Not Yet Implemented. Should shutdown all connections gracefully. ///  public void Stop() { //throw (new NotImplementedException()); } // // ACCEPT // ///  /// Posts a requests for Accepting a connection. If it is being called from the completion of /// an AcceptAsync call, then the AcceptSocket is cleared since it will create a new one for /// the new user. ///  /// null if posted from startup, otherwise a SocketAsyncEventArgs for reuse. private void StartAccept(SocketAsyncEventArgs e) { if (e == null) { e = m_EventArgsPool.Pop(); e.Completed += Accept_Completed; } else { e.AcceptSocket = null; } if (m_ListenSocket.AcceptAsync(e) == false) { Accept_Completed(this, e); } } ///  /// Completion callback routine for the AcceptAsync post. This will verify that the Accept occured /// and then setup a Receive chain to begin receiving data. ///  /// object which posted the AcceptAsync /// Information about the Accept call. private void Accept_Completed(object sender, SocketAsyncEventArgs e) { // // Socket Options // e.AcceptSocket.NoDelay = true; // // Create and setup a new connection object for this user // Connection connection = new Connection(this, e.AcceptSocket); // // Tell the client that we will be echo'ing data sent // DisableEcho(connection); // // Post the first receive // SocketAsyncEventArgs args = m_EventArgsPool.Pop(); args.UserToken = connection; // // Connect Event // if (Connected != null) { Connected(this, args); } args.Completed += Receive_Completed; PostReceive(args); // // Post another accept // StartAccept(e); } // // RECEIVE // ///  /// Post an asynchronous receive on the socket. ///  /// Used to store information about the Receive call. private void PostReceive(SocketAsyncEventArgs e) { Connection connection = e.UserToken as Connection; if (connection != null) { connection.ReceiveBuffer.EnsureCapacity(64); e.SetBuffer(connection.ReceiveBuffer.DataBuffer, connection.ReceiveBuffer.Count, connection.ReceiveBuffer.Remaining); if (connection.Socket.ReceiveAsync(e) == false) { Receive_Completed(this, e); } } } ///  /// Receive completion callback. Should verify the connection, and then notify any event listeners /// that data has been received. For now it is always expected that the data will be handled by the /// listeners and thus the buffer is cleared after every call. ///  /// object which posted the ReceiveAsync /// Information about the Receive call. private void Receive_Completed(object sender, SocketAsyncEventArgs e) { Connection connection = e.UserToken as Connection; if (e.BytesTransferred == 0 || e.SocketError != SocketError.Success || connection == null) { Disconnect(e); return; } connection.ReceiveBuffer.UpdateCount(e.BytesTransferred); OnDataReceived(e); HandleCommand(e); Echo(e); OnLineReceived(connection); PostReceive(e); } ///  /// Handles Event of Data being Received. ///  /// Information about the received data. protected void OnDataReceived(SocketAsyncEventArgs e) { if (DataReceived != null) { DataReceived(this, e); } } ///  /// Handles Event of a Line being Received. ///  /// User connection. protected void OnLineReceived(Connection connection) { if (LineReceived != null) { int index = 0; int start = 0; while ((index = connection.ReceiveBuffer.IndexOf('\n', index)) != -1) { string s = connection.ReceiveBuffer.GetString(start, index - start - 1); s = s.Backspace(); LineReceivedEventArgs args = new LineReceivedEventArgs(connection, s); Delegate[] delegates = LineReceived.GetInvocationList(); foreach (Delegate d in delegates) { d.DynamicInvoke(new object[] { this, args }); if (args.Handled == true) { break; } } if (args.Handled == false) { connection.CommandBuffer.Enqueue(s); } start = index; index++; } if (start > 0) { connection.ReceiveBuffer.Reset(0, start + 1); } } } // // SEND // ///  /// Overloaded. Sends a string over the telnet socket. ///  /// Connection to send data on. /// Data to send. /// true if the data was sent successfully. public bool Send(Connection connection, string s) { if (String.IsNullOrEmpty(s) == false) { return Send(connection, Encoding.Default.GetBytes(s)); } return false; } ///  /// Overloaded. Sends an array of data to the client. ///  /// Connection to send data on. /// Data to send. /// true if the data was sent successfully. public bool Send(Connection connection, byte[] data) { return Send(connection, data, 0, data.Length); } public bool Send(Connection connection, char c) { return Send(connection, new byte[] { (byte)c }, 0, 1); } ///  /// Sends an array of data to the client. ///  /// Connection to send data on. /// Data to send. /// Starting offset of date in the buffer. /// Amount of data in bytes to send. ///  public bool Send(Connection connection, byte[] data, int offset, int length) { bool status = true; if (connection.Socket == null || connection.Socket.Connected == false) { return false; } SocketAsyncEventArgs args = m_EventArgsPool.Pop(); args.UserToken = connection; args.Completed += Send_Completed; args.SetBuffer(data, offset, length); try { if (connection.Socket.SendAsync(args) == false) { Send_Completed(this, args); } } catch (ObjectDisposedException) { // // return the SocketAsyncEventArgs back to the pool and return as the // socket has been shutdown and disposed of // m_EventArgsPool.Push(args); status = false; } return status; } ///  /// Sends a command telling the client that the server WILL echo data. ///  /// Connection to disable echo on. public void DisableEcho(Connection connection) { byte[] b = new byte[] { 255, 251, 1 }; Send(connection, b); } ///  /// Completion callback for SendAsync. ///  /// object which initiated the SendAsync /// Information about the SendAsync call. private void Send_Completed(object sender, SocketAsyncEventArgs e) { e.Completed -= Send_Completed; m_EventArgsPool.Push(e); } ///  /// Handles a Telnet command. ///  /// Information about the data received. private void HandleCommand(SocketAsyncEventArgs e) { Connection c = e.UserToken as Connection; if (c == null || e.BytesTransferred < 3) { return; } for (int i = 0; i < e.BytesTransferred; i += 3) { if (e.BytesTransferred - i < 3) { break; } if (e.Buffer[i] == (int)TelnetCommand.IAC) { TelnetCommand command = (TelnetCommand)e.Buffer[i + 1]; TelnetOption option = (TelnetOption)e.Buffer[i + 2]; switch (command) { case TelnetCommand.DO: if (option == TelnetOption.Echo) { // ECHO } break; case TelnetCommand.WILL: if (option == TelnetOption.Echo) { // ECHO } break; } c.ReceiveBuffer.Remove(i, 3); } } } ///  /// Echoes data back to the client. ///  /// Information about the received data to be echoed. private void Echo(SocketAsyncEventArgs e) { Connection connection = e.UserToken as Connection; if (connection == null) { return; } // // backspacing would cause the cursor to proceed beyond the beginning of the input line // so prevent this // string bs = connection.ReceiveBuffer.ToString(); if (bs.CountAfterBackspace() < 0) { return; } // // find the starting offset (first non-backspace character) // int i = 0; for (i = 0; i < connection.ReceiveBuffer.Count; i++) { if (connection.ReceiveBuffer[i] != '\b') { break; } } string s = Encoding.Default.GetString(e.Buffer, Math.Max(e.Offset, i), e.BytesTransferred); if (connection.Secure) { s = s.ReplaceNot("\r\n\b".ToCharArray(), '*'); } s = s.Replace("\b", "\b \b"); Send(connection, s); } // // DISCONNECT // ///  /// Disconnects a socket. ///  ///  /// It is expected that this disconnect is always posted by a failed receive call. Calling the public /// version of this method will cause the next posted receive to fail and this will cleanup properly. /// It is not advised to call this method directly. ///  /// Information about the socket to be disconnected. private void Disconnect(SocketAsyncEventArgs e) { Connection connection = e.UserToken as Connection; if (connection == null) { throw (new ArgumentNullException("e.UserToken")); } try { connection.Socket.Shutdown(SocketShutdown.Both); } catch { } connection.Socket.Close(); if (Disconnected != null) { Disconnected(this, e); } e.Completed -= Receive_Completed; m_EventArgsPool.Push(e); } ///  /// Marks a specific connection for graceful shutdown. The next receive or send to be posted /// will fail and close the connection. ///  ///  public void Disconnect(Connection connection) { try { connection.Socket.Shutdown(SocketShutdown.Both); } catch (Exception) { } } ///  /// Telnet command codes. ///  internal enum TelnetCommand { SE = 240, NOP = 241, DM = 242, BRK = 243, IP = 244, AO = 245, AYT = 246, EC = 247, EL = 248, GA = 249, SB = 250, WILL = 251, WONT = 252, DO = 253, DONT = 254, IAC = 255 } ///  /// Telnet command options. ///  internal enum TelnetOption { Echo = 1, SuppressGoAhead = 3, Status = 5, TimingMark = 6, TerminalType = 24, WindowSize = 31, TerminalSpeed = 32, RemoteFlowControl = 33, LineMode = 34, EnvironmentVariables = 36 } } 

Es gab eine wirklich gute Diskussion von skalierbarem TCP / IP unter Verwendung von .NET, geschrieben von Chris Mullins of Coversant, leider scheint sein Blog von seinem früheren Standort verschwunden zu sein, also werde ich versuchen, seine Ratschläge aus dem Gedächtnis zusammenzusetzen (einige nützliche Kommentare) von ihm erscheinen in diesem Thread: C ++ vs. C #: Entwicklung eines hochskalierbaren IOCP-Servers )

Zu Async beachten Sie, dass sowohl die Begin/End als auch die Async Methoden für die Socket class IO-Completion-Ports (IOCP) verwenden, um Skalierbarkeit bereitzustellen. Dies macht einen größeren Unterschied (bei korrekter Verwendung; siehe unten) zur Skalierbarkeit als die der beiden Methoden, die Sie zur Implementierung Ihrer Lösung verwenden.

Die Beiträge von Chris Mullins basierten auf der Verwendung von Begin/End , mit der ich persönlich Erfahrung habe. Beachten Sie, dass Chris eine Lösung auf dieser Basis zusammengestellt hat, die auf einer 32-Bit-Maschine mit 2 GB Arbeitsspeicher bis zu 10000 gleichzeitige Client-Verbindungen und auf einer 64-Bit-Plattform mit ausreichend Speicher 100.000.000s umfasst. Aus meiner eigenen Erfahrung mit dieser Technik (auch wenn diese Last nicht annähernd ausreicht) habe ich keinen Grund, an diesen indikativen Zahlen zu zweifeln.

IOCP im Gegensatz zu Thread-pro-Verbindung oder Auswahl-Primitive

Der Grund, warum Sie einen Mechanismus verwenden möchten, der IOCP unter der Haube verwendet, ist, dass er einen sehr niedrigen Windows-Threadpool verwendet, der keine Threads aufweckt, bis tatsächliche Daten auf dem E / A-Kanal vorhanden sind, von dem Sie versuchen zu lesen ( Beachten Sie, dass IOCP auch für Datei-IO verwendet werden kann). Der Vorteil davon ist, dass Windows nicht zu einem Thread wechseln muss, nur um festzustellen, dass es sowieso noch keine Daten gibt, so dass die Anzahl der Kontextwechsel reduziert wird, die Ihr Server auf das erforderliche Minimum durchführen muss.

Context-Switches sind das, was definitiv den “thread-per-connection” -Mechanismus auslöschen wird, obwohl dies eine praktikable Lösung ist, wenn Sie nur mit ein paar Dutzend Verbindungen arbeiten. Dieser Mechanismus ist jedoch bei weitem nicht skalierbar.

Wichtige Überlegungen bei der Verwendung von IOCP

Erinnerung

In erster Linie ist es wichtig zu verstehen, dass IOCP leicht zu Speicherproblemen unter .NET führen kann, wenn Ihre Implementierung zu naiv ist. Jeder Aufruf von IOCP BeginReceive führt zum “Pinnen” des Puffers, in den Sie BeginReceive . Für eine gute Erklärung, warum dies ein Problem ist, siehe: Yun Jins Weblog: OutOfMemoryException und Pinning .

Zum Glück kann dieses Problem vermieden werden, aber es erfordert ein bisschen einen Kompromiss. Die vorgeschlagene Lösung besteht darin, beim Start der Anwendung (oder in der Nähe davon) einen Big byte[] Puffer von mindestens 90 KB oder so zuzuweisen (ab .NET 2 kann die erforderliche Größe in späteren Versionen größer sein). Der Grund dafür ist, dass große Speicherzuweisungen automatisch in einem nicht komprimierenden Speichersegment (The Large Object Heap) landen, das effektiv automatisch angeheftet wird. Indem Sie beim Start einen großen Puffer reservieren, stellen Sie sicher, dass dieser Block des unbeweglichen Speichers an einer relativ “niedrigen Adresse” liegt, wo er nicht in die Quere kommt und eine Fragmentierung verursacht.

Sie können dann Offsets verwenden, um diesen einen großen Puffer in separate Bereiche für jede Verbindung zu segmentieren, die einige Daten lesen müssen. Hier kommt ein Trade-off ins Spiel. Da dieser Puffer vorab zugeordnet werden muss, müssen Sie entscheiden, wie viel Pufferspeicherplatz Sie pro Verbindung benötigen und welche Obergrenze Sie für die Anzahl der Verbindungen festlegen möchten, auf die Sie skalieren möchten (oder Sie können eine Abstraktion implementieren) das kann zusätzliche gepinnte Puffer zuweisen, sobald Sie sie benötigen).

Die einfachste Lösung wäre, jeder Verbindung ein einzelnes Byte mit einem eindeutigen Offset innerhalb dieses Puffers zuzuordnen. Dann können Sie einen BeginReceive Aufruf für ein einzelnes Byte durchführen, das gelesen werden soll, und den Rest des Lesevorgangs als Ergebnis des Callbacks ausführen, das Sie erhalten.

wird bearbeitet

Wenn Sie den Callback von dem von Ihnen durchgeführten Aufruf von Begin , ist es sehr wichtig zu erkennen, dass der Code im Callback auf dem Low-Level-IOCP-Thread ausgeführt wird. Es ist absolut notwendig, dass Sie lange Operationen in diesem callback vermeiden. Wenn Sie diese Threads für die komplexe Verarbeitung verwenden, wird Ihre Skalierbarkeit genauso stark beeinträchtigt wie bei der Verwendung von “Thread-pro-Verbindung”.

Die vorgeschlagene Lösung besteht darin, den callback nur zu verwenden, um ein Arbeitselement in eine Warteschlange zu stellen, um die eingehenden Daten zu verarbeiten, die in einem anderen Thread ausgeführt werden. Vermeiden Sie potenziell blockierende Vorgänge innerhalb des callbacks, damit der IOCP-Thread so schnell wie möglich in seinen Pool zurückkehren kann. In .NET 4.0 würde ich vorschlagen, dass die einfachste Lösung darin besteht, eine Task zu spawnen und ihr einen Verweis auf den Client-Socket und eine Kopie des ersten Bytes zu geben, das bereits vom BeginReceive Aufruf gelesen wurde. Diese Task ist dann dafür verantwortlich, alle Daten aus dem Socket zu lesen, die die Anfrage darstellen, die Sie verarbeiten, ausführen und dann einen neuen BeginReceive Aufruf ausführen, um den Socket für IOCP erneut in die Warteschlange zu stellen. Vor .NET 4.0 können Sie den ThreadPool verwenden oder eine eigene Implementierung mit Thread-Warteschlangen erstellen.

Zusammenfassung

Grundsätzlich würde ich vorschlagen, Kevins Beispielcode für diese Lösung mit den folgenden zusätzlichen Warnungen zu verwenden:

  • BeginReceive Sie sicher, dass der Puffer, den Sie an BeginReceive bereits fixiert ist.
  • BeginReceive Sie sicher, dass der callback, den Sie an BeginReceive nicht mehr als eine Aufgabe in Warteschlange stellt, um die tatsächliche Verarbeitung der eingehenden Daten zu verarbeiten

Wenn Sie das tun, habe ich keine Zweifel, dass Sie die Ergebnisse von Chris replizieren können, indem Sie auf potentielle Hunderttausende von simultanen Clients skalieren (vorausgesetzt, dass Sie die richtige Hardware und eine effiziente Implementierung Ihres eigenen Verarbeitungscodes haben).

You already got the most part of the answer via the code samples above. Using asynchronous IO operation is absolutely the way to go here. Async IO is the way the Win32 is designed internally to scale. The best possible performance you can get is achieved using Completion Ports, binding your sockets to completion ports and have a thread pool waiting for completion port completion. The common wisdom is to have 2-4 threads per CPU(core) waiting for completion. I highly recommend to go over these three articles by Rick Vicik from the Windows Performance team:

  1. Designing Applications for Performance – Part 1
  2. Designing Applications for Performance – Part 2
  3. Designing Applications for Performance – Part 3

The said articles cover mostly the native Windows API, but they are a must read for anyone trying to get a grasp at scalability and performance. They do have some briefs on the managed side of things too.

Second thing you’ll need to do is make sure you go over the Improving .NET Application Performance and Scalability book, that is available online. You will find pertinent and valid advice around the use of threads, asynchronous calls and locks in Chapter 5. But the real gems are in Chapter 17 where you’ll find such goodies as practical guidance on tuning your thread pool. My apps had some serious problems until I adjusted the maxIothreads/maxWorkerThreads as per the recommendations in this chapter.

You say that you want to do a pure TCP server, so my next point is spurious. However , if you find yourself cornered and use the WebRequest class and its derivatives, be warned that there is a dragon guarding that door: the ServicePointManager . This is a configuration class that has one purpose in life: to ruin your performance. Make sure you free your server from the artificial imposed ServicePoint.ConnectionLimit or your application will never scale (I let you discover urself what is the default value…). You may also reconsider the default policy of sending an Expect100Continue header in the http requests.

Now about the core socket managed API things are fairly easy on the Send side, but they are significantly more complex on the Receive side. In order to achieve high throughput and scale you must ensure that the socket is not flow controlled because you do not have a buffer posted for receive. Ideally for high performance you should post ahead 3-4 buffers and post new buffers as soon as you get one back ( before you process the one got back) so you ensure that the socket always has somewhere to deposit the data coming from the network. You’ll see why you probably won’t be able to achieve this shortly.

After you’re done playing with the BeginRead/BeginWrite API and start the serious work you’ll realize that you need security on your traffic, ie. NTLM/Kerberos authentication and traffic encryption, or at least traffic tampering protection. The way you do this is you use the built in System.Net.Security.NegotiateStream (or SslStream if you need to go cross disparate domains). This means that instead of relying on straight socket asynchronous operations you will rely on the AuthenticatedStream asynchronous operations. As soon as you obtain a socket (either from connect on client or from accept on server) you create a stream on the socket and submit it for authentication, by calling either BeginAuthenticateAsClient or BeginAuthenticateAsServer. After the authentication completes (at least your safe from the native InitiateSecurityContext/AcceptSecurityContext madness…) you will do your authorization by checking the RemoteIdentity property of your Authenticated stream and doing whatever ACL verification your product must support. After that you will send messages using the BeginWrite and you’ll be receiving them with BeginRead. This is the problem I was talking before that you won’t be able to post multiple receive buffers, because the AuthenticateStream classes don’t support this. The BeginRead operation manages internally all the IO until you have received an entire frame, otherwise it could not handle the the message authentication (decrypt frame and validate signature on frame). Though in my experience the job done by the AuthenticatedStream classes is fairly good and shouldn’t have any problem with it. Ie. you should be able to saturate GB network with only 4-5% CPU. The AuthenticatedStream classes will also impose on you the protocol specific frame size limitations (16k for SSL, 12k for Kerberos).

This should get you started on the right track. I’m not going to post code here, there is a perfectly good example on MSDN . I’ve done many projects like this and I was able to scale to about 1000 users connected without problems. Above that you’ll need to modify registry keys to allow the kernel for more socket handles. and make sure you deploy on a server OS, that is W2K3 not XP or Vista (ie. client OS), it makes a big difference.

BTW make sure if you have databases operations on the server or file IO you also use the async flavor for them, or you’ll drain the thread pool in no time. For SQL Server connections make sure you add the ‘Asyncronous Processing=true’ to the connection string.

I’ve got such a server running in some of my solutions. Here is a very detail explanation of the different ways to do it in .net: Get Closer to the Wire with High-Performance Sockets in .NET

Lately I’ve been looking for ways to improve our code and will be looking into this: ” Socket Performance Enhancements in Version 3.5 ” that was included specifically “for use by applications that use asynchronous network I/O to achieve the highest performance”.

“The main feature of these enhancements is the avoidance of the repeated allocation and synchronization of objects during high-volume asynchronous socket I/O. The Begin/End design pattern currently implemented by the Socket class for asynchronous socket I/O requires a System.IAsyncResult object be allocated for each asynchronous socket operation.”

You can keep reading if you follow the link. I personally will be testing their sample code tomorrow to benchmark it against what i’ve got.

Edit: Here you can find working code for both client and server using the new 3.5 SocketAsyncEventArgs so you can test it within a couple minutes and go thru the code. It is a simple approach but is the basis for starting a much larger implementation. Also this article from almost two years ago in MSDN Magazine was a interesting read.

Have you considered just using a WCF net TCP binding and a publish/subscribe pattern ? WCF would allow you to focus [mostly] on your domain instead of plumbing..

There are lots of WCF samples & even a publish/subscribe framework available on IDesign’s download section which may be useful : http://www.idesign.net

I am wondering about one thing:

I definitely do not want to start a thread for each connection.

Warum das? Windows could handle hundreds of threads in an application since at least Windows 2000. I’ve done it, it’s really easy to work with if the threads don’t need to be synchronized. Especially given that you’re doing a lot of I/O (so you’re not CPU-bound, and a lot of threads would be blocked on either disk or network communication), I don’t understand this restriction.

Have you tested the multi-threaded way and found it lacking in something? Do you intend to also have a database connection for each thread (that would kill the database server, so it’s a bad idea, but it’s easily solved with a 3-tier design). Are you worried that you’ll have thousands of clients instead of hundreds, and then you’ll really have problems? (Though I’d try a thousand threads or even ten thousand if I had 32+ GB of RAM – again, given that you’re not CPU bound, thread switch time should be absolutely irrelevant.)

Here is the code – to see how this looks running, go to http://mdpopescu.blogspot.com/2009/05/multi-threaded-server.html and click on the picture.

Server class:

  public class Server { private static readonly TcpListener listener = new TcpListener(IPAddress.Any, 9999); public Server() { listener.Start(); Console.WriteLine("Started."); while (true) { Console.WriteLine("Waiting for connection..."); var client = listener.AcceptTcpClient(); Console.WriteLine("Connected!"); // each connection has its own thread new Thread(ServeData).Start(client); } } private static void ServeData(object clientSocket) { Console.WriteLine("Started thread " + Thread.CurrentThread.ManagedThreadId); var rnd = new Random(); try { var client = (TcpClient) clientSocket; var stream = client.GetStream(); while (true) { if (rnd.NextDouble() < 0.1) { var msg = Encoding.ASCII.GetBytes("Status update from thread " + Thread.CurrentThread.ManagedThreadId); stream.Write(msg, 0, msg.Length); Console.WriteLine("Status update from thread " + Thread.CurrentThread.ManagedThreadId); } // wait until the next update - I made the wait time so small 'cause I was bored :) Thread.Sleep(new TimeSpan(0, 0, rnd.Next(1, 5))); } } catch (SocketException e) { Console.WriteLine("Socket exception in thread {0}: {1}", Thread.CurrentThread.ManagedThreadId, e); } } } 

Server main program:

 namespace ManyThreadsServer { internal class Program { private static void Main(string[] args) { new Server(); } } } 

Client class:

  public class Client { public Client() { var client = new TcpClient(); client.Connect(IPAddress.Loopback, 9999); var msg = new byte[1024]; var stream = client.GetStream(); try { while (true) { int i; while ((i = stream.Read(msg, 0, msg.Length)) != 0) { var data = Encoding.ASCII.GetString(msg, 0, i); Console.WriteLine("Received: {0}", data); } } } catch (SocketException e) { Console.WriteLine("Socket exception in thread {0}: {1}", Thread.CurrentThread.ManagedThreadId, e); } } } 

Client main program:

 using System; using System.Threading; namespace ManyThreadsClient { internal class Program { private static void Main(string[] args) { // first argument is the number of threads for (var i = 0; i < Int32.Parse(args[0]); i++) new Thread(RunClient).Start(); } private static void RunClient() { new Client(); } } } 

Using .NET’s integrated Async IO ( BeginRead , etc) is a good idea if you can get all the details right. When you properly set up your socket/file handles it will use the OS’s underlying IOCP implementation, allowing your operations to complete without using any threads (or, in the worst case, using a thread that I believe comes from the kernel’s IO thread pool instead of .NET’s thread pool, which helps alleviate threadpool congestion.)

The main gotcha is to make sure that you open your sockets/files in non-blocking mode. Most of the default convenience functions (like File.OpenRead ) don’t do this, so you’ll need to write your own.

One of the other main concerns is error handling – properly handling errors when writing asynchronous I/O code is much, much harder than doing it in synchronous code. It’s also very easy to end up with race conditions and deadlocks even though you may not be using threads directly, so you need to be aware of this.

If possible, you should try and use a convenience library to ease the process of doing scalable asynchronous IO.

Microsoft’s Concurrency Coordination Runtime is one example of a .NET library designed to ease the difficulty of doing this kind of programming. It looks great, but as I haven’t used it, I can’t comment on how well it would scale.

For my personal projects that need to do asynchronous network or disk I/O, I use a set of .NET concurrency/IO tools that I’ve built over the past year, called Squared.Task . It’s inspired by libraries like imvu.task and twisted , and I’ve included some working examples in the repository that do network I/O. I also have used it in a few applications I’ve written – the largest publicly released one being NDexer (which uses it for threadless disk I/O). The library was written based on my experience with imvu.task and has a set of fairly comprehensive unit tests, so I strongly encourage you to try it out. If you have any issues with it, I’d be glad to offer you some assistance.

In my opinion, based on my experience using asynchronous/threadless IO instead of threads is a worthwhile endeavor on the .NET platform, as long as you’re ready to deal with the learning curve. It allows you to avoid the scalability hassles imposed by the cost of Thread objects, and in many cases, you can completely avoid the use of locks and mutexes by making careful use of concurrency primitives like Futures/Promises.

You can find a nice overview of techniques at the C10k problem page .

I used Kevin’s solution but he says that solution lacks code for reassembly of messages. Developers can use this code for reassembly of messages:

 private static void ReceiveCallback(IAsyncResult asyncResult ) { ClientInfo cInfo = (ClientInfo)asyncResult.AsyncState; cInfo.BytesReceived += cInfo.Soket.EndReceive(asyncResult); if (cInfo.RcvBuffer == null) { // First 2 byte is lenght if (cInfo.BytesReceived >= 2) { //this calculation depends on format which your client use for lenght info byte[] len = new byte[ 2 ] ; len[0] = cInfo.LengthBuffer[1]; len[1] = cInfo.LengthBuffer[0]; UInt16 length = BitConverter.ToUInt16( len , 0); // buffering and nulling is very important cInfo.RcvBuffer = new byte[length]; cInfo.BytesReceived = 0; } } else { if (cInfo.BytesReceived == cInfo.RcvBuffer.Length) { //Put your code here, use bytes comes from "cInfo.RcvBuffer" //Send Response but don't use async send , otherwise your code will not work ( RcvBuffer will be null prematurely and it will ruin your code) int sendLenghts = cInfo.Soket.Send( sendBack, sendBack.Length, SocketFlags.None); // buffering and nulling is very important //Important , set RcvBuffer to null because code will decide to get data or 2 bte lenght according to RcvBuffer's value(null or initialized) cInfo.RcvBuffer = null; cInfo.BytesReceived = 0; } } ContinueReading(cInfo); } private static void ContinueReading(ClientInfo cInfo) { try { if (cInfo.RcvBuffer != null) { cInfo.Soket.BeginReceive(cInfo.RcvBuffer, cInfo.BytesReceived, cInfo.RcvBuffer.Length - cInfo.BytesReceived, SocketFlags.None, ReceiveCallback, cInfo); } else { cInfo.Soket.BeginReceive(cInfo.LengthBuffer, cInfo.BytesReceived, cInfo.LengthBuffer.Length - cInfo.BytesReceived, SocketFlags.None, ReceiveCallback, cInfo); } } catch (SocketException se) { //Handle exception and Close socket here, use your own code return; } catch (Exception ex) { //Handle exception and Close socket here, use your own code return; } } class ClientInfo { private const int BUFSIZE = 1024 ; // Max size of buffer , depends on solution private const int BUFLENSIZE = 2; // lenght of lenght , depends on solution public int BytesReceived = 0 ; public byte[] RcvBuffer { get; set; } public byte[] LengthBuffer { get; set; } public Socket Soket { get; set; } public ClientInfo(Socket clntSock) { Soket = clntSock; RcvBuffer = null; LengthBuffer = new byte[ BUFLENSIZE ]; } } public static void AcceptCallback(IAsyncResult asyncResult) { Socket servSock = (Socket)asyncResult.AsyncState; Socket clntSock = null; try { clntSock = servSock.EndAccept(asyncResult); ClientInfo cInfo = new ClientInfo(clntSock); Receive( cInfo ); } catch (SocketException se) { clntSock.Close(); } } private static void Receive(ClientInfo cInfo ) { try { if (cInfo.RcvBuffer == null) { cInfo.Soket.BeginReceive(cInfo.LengthBuffer, 0, 2, SocketFlags.None, ReceiveCallback, cInfo); } else { cInfo.Soket.BeginReceive(cInfo.RcvBuffer, 0, cInfo.BytesReceived, SocketFlags.None, ReceiveCallback, cInfo); } } catch (SocketException se) { return; } catch (Exception ex) { return; } } 

You could try using a framework called ACE (Adaptive Communications Environment) which is a generic C++ framework for network servers. It’s a very solid, mature product and is designed to support high-reliability, high-volume applications up to telco-grade.

The framework deals with quite a wide range of concurrency models and probably has one suitable for your applciation out of the box. This should make the system easier to debug as most of the nasty concurrency issues have already been sorted out. The trade-off here is that the framework is written in C++ and is not the most warm and fluffy of code bases. On the other hand, you get tested, industrial grade network infrastructure and a highly scalable architecture out of the box.

I would use SEDA or a lightweight threading library (erlang or newer linux see NTPL scalability on the server side ). Async coding is very cumbersome if your communication isn’t 🙂

Well, .NET sockets seem to provide select() – that’s best for handling input. For output I’d have a pool of socket-writer threads listening on a work queue, accepting socket descriptor/object as part of the work item, so you don’t need a thread per socket.

I would use the AcceptAsync/ConnectAsync/ReceiveAsync/SendAsync methods that were added in .Net 3.5. I have done a benchmark and they are approximately 35% faster (response time and bitrate) with 100 users constantly sending and receiving data.

to people copy pasting the accepted answer, you can rewrite the acceptCallback method, removing all calls of _serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket); and put it in a finally{} clause, this way:

 private void acceptCallback(IAsyncResult result) { xConnection conn = new xConnection(); try { //Finish accepting the connection System.Net.Sockets.Socket s = (System.Net.Sockets.Socket)result.AsyncState; conn = new xConnection(); conn.socket = s.EndAccept(result); conn.buffer = new byte[_bufferSize]; lock (_sockets) { _sockets.Add(conn); } //Queue recieving of data from the connection conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn); } catch (SocketException e) { if (conn.socket != null) { conn.socket.Close(); lock (_sockets) { _sockets.Remove(conn); } } } catch (Exception e) { if (conn.socket != null) { conn.socket.Close(); lock (_sockets) { _sockets.Remove(conn); } } } finally { //Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners _serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket); } } 

you could even remove the first catch since its content is the same but it’s a template method and you should use typed exception to better handle the exceptions and understand what caused the error, so just implement those catches with some useful code

I would recommend to read these books on ACE

  • C++ Network Programming: Mastering Complexity Using ACE and Patterns
  • C++ Network Programming: Systematic Reuse with ACE and Frameworks

to get ideas about patterns allowing you to create an efficient server.

Although ACE is implemented in C++ the books cover a lot of useful patterns that can be used in any programming language.

To be clear, i’m looking for .net based solutions (C# if possible, but any .net language will work)

You are not going to get the highest level of scalability if you go purely with .NET. GC pauses can hamper the latency.

I’m going to need to start at least one thread for the service. I am considering using the Asynch API (BeginRecieve, etc..) since I don’t know how many clients I will have connected at any given time (possibly hundreds). I definitely do not want to start a thread for each connection.

Overlapped IO is generally considered to be Windows’ fastest API for network communication. I don’t know if this the same as your Asynch API. Do not use select as each call needs to check every socket that is open instead of having callbacks on active sockets.

You can use Push Framework open source framework for high-performance server development. It is built on IOCP and is suitable for push scenarios and message broadcast.

http://www.pushframework.com