SocketAsyncEventArgs Class


Stellt einen asynchronen Socketvorgang dar.Represents an asynchronous socket operation.

public ref class SocketAsyncEventArgs : EventArgs, IDisposable
public class SocketAsyncEventArgs : EventArgs, IDisposable
type SocketAsyncEventArgs = class
    inherit EventArgs
    interface IDisposable
Public Class SocketAsyncEventArgs
Inherits EventArgs
Implements IDisposable


Im folgenden Codebeispiel wird die Verbindungs Logik für den Socketserver implementiert, der die SocketAsyncEventArgs-Klasse verwendet.The following code example implements the connection logic for the socket server that uses the SocketAsyncEventArgs class. Nachdem eine Verbindung akzeptiert wurde, werden alle vom Client gelesenen Daten zurück an den Client gesendet.After accepting a connection, all data read from the client is sent back to the client. Der Lese-und Echo Vorgang des Client Musters wird fortgesetzt, bis der Client die Verbindung trennt.The read and echo back to the client pattern is continued until the client disconnects. Die von diesem Beispiel verwendete BufferManager-Klasse wird im Codebeispiel für die SetBuffer(Byte[], Int32, Int32)-Methode angezeigt.The BufferManager class that is used by this example is displayed in the code example for the SetBuffer(Byte[], Int32, Int32) method. Die socketasynceventargspool-Klasse, die in diesem Beispiel verwendet wird, wird im Codebeispiel für den SocketAsyncEventArgs-Konstruktor angezeigt.The SocketAsyncEventArgsPool class that is used in this example is displayed in the code example for the SocketAsyncEventArgs constructor.

// Implements the connection logic for the socket server.
// After accepting a connection, all data read from the client
// is sent back to the client. The read and echo back to the client pattern
// is continued until the client disconnects.
class Server
    private int m_numConnections;   // the maximum number of connections the sample is designed to handle simultaneously
    private int m_receiveBufferSize;// buffer size to use for each socket I/O operation
    BufferManager m_bufferManager;  // represents a large reusable set of buffers for all socket operations
    const int opsToPreAlloc = 2;    // read, write (don't alloc buffer space for accepts)
    Socket listenSocket;            // the socket used to listen for incoming connection requests
    // pool of reusable SocketAsyncEventArgs objects for write, read and accept socket operations
    SocketAsyncEventArgsPool m_readWritePool;
    int m_totalBytesRead;           // counter of the total # bytes received by the server
    int m_numConnectedSockets;      // the total number of clients connected to the server
    Semaphore m_maxNumberAcceptedClients;

    // Create an uninitialized server instance.
    // To start the server listening for connection requests
    // call the Init method followed by Start method
    // <param name="numConnections">the maximum number of connections the sample is designed to handle simultaneously</param>
    // <param name="receiveBufferSize">buffer size to use for each socket I/O operation</param>
    public Server(int numConnections, int receiveBufferSize)
        m_totalBytesRead = 0;
        m_numConnectedSockets = 0;
        m_numConnections = numConnections;
        m_receiveBufferSize = receiveBufferSize;
        // allocate buffers such that the maximum number of sockets can have one outstanding read and
        //write posted to the socket simultaneously
        m_bufferManager = new BufferManager(receiveBufferSize * numConnections * opsToPreAlloc,

        m_readWritePool = new SocketAsyncEventArgsPool(numConnections);
        m_maxNumberAcceptedClients = new Semaphore(numConnections, numConnections);

    // Initializes the server by preallocating reusable buffers and
    // context objects.  These objects do not need to be preallocated
    // or reused, but it is done this way to illustrate how the API can
    // easily be used to create reusable objects to increase server performance.
    public void Init()
        // Allocates one large byte buffer which all I/O operations use a piece of.  This gaurds
        // against memory fragmentation

        // preallocate pool of SocketAsyncEventArgs objects
        SocketAsyncEventArgs readWriteEventArg;

        for (int i = 0; i < m_numConnections; i++)
            //Pre-allocate a set of reusable SocketAsyncEventArgs
            readWriteEventArg = new SocketAsyncEventArgs();
            readWriteEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
            readWriteEventArg.UserToken = new AsyncUserToken();

            // assign a byte buffer from the buffer pool to the SocketAsyncEventArg object

            // add SocketAsyncEventArg to the pool

    // Starts the server such that it is listening for
    // incoming connection requests.
    // <param name="localEndPoint">The endpoint which the server will listening
    // for connection requests on</param>
    public void Start(IPEndPoint localEndPoint)
        // create the socket which listens for incoming connections
        listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
        // start the server with a listen backlog of 100 connections

        // post accepts on the listening socket

        //Console.WriteLine("{0} connected sockets with one outstanding receive posted to any key", m_outstandingReadCount);
        Console.WriteLine("Press any key to terminate the server process....");

    // Begins an operation to accept a connection request from the client
    // <param name="acceptEventArg">The context object to use when issuing
    // the accept operation on the server's listening socket</param>
    public void StartAccept(SocketAsyncEventArgs acceptEventArg)
        if (acceptEventArg == null)
            acceptEventArg = new SocketAsyncEventArgs();
            acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptEventArg_Completed);
            // socket must be cleared since the context object is being reused
            acceptEventArg.AcceptSocket = null;

        bool willRaiseEvent = listenSocket.AcceptAsync(acceptEventArg);
        if (!willRaiseEvent)

    // This method is the callback method associated with Socket.AcceptAsync
    // operations and is invoked when an accept operation is complete
    void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e)

    private void ProcessAccept(SocketAsyncEventArgs e)
        Interlocked.Increment(ref m_numConnectedSockets);
        Console.WriteLine("Client connection accepted. There are {0} clients connected to the server",

        // Get the socket for the accepted client connection and put it into the
        //ReadEventArg object user token
        SocketAsyncEventArgs readEventArgs = m_readWritePool.Pop();
        ((AsyncUserToken)readEventArgs.UserToken).Socket = e.AcceptSocket;

        // As soon as the client is connected, post a receive to the connection
        bool willRaiseEvent = e.AcceptSocket.ReceiveAsync(readEventArgs);

        // Accept the next connection request

    // This method is called whenever a receive or send operation is completed on a socket
    // <param name="e">SocketAsyncEventArg associated with the completed receive operation</param>
    void IO_Completed(object sender, SocketAsyncEventArgs e)
        // determine which type of operation just completed and call the associated handler
        switch (e.LastOperation)
            case SocketAsyncOperation.Receive:
            case SocketAsyncOperation.Send:
                throw new ArgumentException("The last operation completed on the socket was not a receive or send");

    // This method is invoked when an asynchronous receive operation completes.
    // If the remote host closed the connection, then the socket is closed.
    // If data was received then the data is echoed back to the client.
    private void ProcessReceive(SocketAsyncEventArgs e)
        // check if the remote host closed the connection
        AsyncUserToken token = (AsyncUserToken)e.UserToken;
        if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
            //increment the count of the total bytes receive by the server
            Interlocked.Add(ref m_totalBytesRead, e.BytesTransferred);
            Console.WriteLine("The server has read a total of {0} bytes", m_totalBytesRead);

            //echo the data received back to the client
            e.SetBuffer(e.Offset, e.BytesTransferred);
            bool willRaiseEvent = token.Socket.SendAsync(e);
            if (!willRaiseEvent)

    // This method is invoked when an asynchronous send operation completes.
    // The method issues another receive on the socket to read any additional
    // data sent from the client
    // <param name="e"></param>
    private void ProcessSend(SocketAsyncEventArgs e)
        if (e.SocketError == SocketError.Success)
            // done echoing data back to the client
            AsyncUserToken token = (AsyncUserToken)e.UserToken;
            // read the next block of data send from the client
            bool willRaiseEvent = token.Socket.ReceiveAsync(e);
            if (!willRaiseEvent)

    private void CloseClientSocket(SocketAsyncEventArgs e)
        AsyncUserToken token = e.UserToken as AsyncUserToken;

        // close the socket associated with the client
        // throws if client process has already closed
        catch (Exception) { }

        // decrement the counter keeping track of the total number of clients connected to the server
        Interlocked.Decrement(ref m_numConnectedSockets);

        // Free the SocketAsyncEventArg so they can be reused by another client

        Console.WriteLine("A client has been disconnected from the server. There are {0} clients connected to the server", m_numConnectedSockets);


Die SocketAsyncEventArgs-Klasse ist Teil einer Reihe von Erweiterungen für die System.Net.Sockets.Socket-Klasse, die ein alternatives asynchrones Muster bereitstellen, das von spezialisierten hochleistungsfähigen Socketanwendungen verwendet werden kann.The SocketAsyncEventArgs class is part of a set of enhancements to the System.Net.Sockets.Socket class that provide an alternative asynchronous pattern that can be used by specialized high-performance socket applications. Diese Klasse wurde speziell für Netzwerkserver Anwendungen entwickelt, die eine hohe Leistung erfordern.This class was specifically designed for network server applications that require high performance. Eine Anwendung kann das erweiterte asynchrone Muster exklusiv oder nur in Ziel-Hot-Bereichen verwenden (z. b. beim Empfang großer Datenmengen).An application can use the enhanced asynchronous pattern exclusively or only in targeted hot areas (for example, when receiving large amounts of data).

Die Hauptfunktion dieser Erweiterungen ist die Vermeidung der wiederholten Zuordnung und Synchronisierung von Objekten während asynchroner Socket-E/A mit hohem Volumen.The main feature of these enhancements is the avoidance of the repeated allocation and synchronization of objects during high-volume asynchronous socket I/O. Das Begin/End-Entwurfsmuster, das derzeit von der System.Net.Sockets.Socket-Klasse implementiert wird, erfordert, dass für jeden asynchronen Socketvorgang ein System.IAsyncResult Objekt zugeordnet wird.The Begin/End design pattern currently implemented by the System.Net.Sockets.Socket class requires a System.IAsyncResult object be allocated for each asynchronous socket operation.

In den neuen Erweiterungen der System.Net.Sockets.Socket-Klasse werden asynchrone Socketvorgänge durch wiederverwendbare SocketAsyncEventArgs Objekte beschrieben, die von der Anwendung zugewiesen und verwaltet werden.In the new System.Net.Sockets.Socket class enhancements, asynchronous socket operations are described by reusable SocketAsyncEventArgs objects allocated and maintained by the application. Socketanwendungen mit hoher Leistung kennen die Menge an überlappenden Socketvorgängen, die aufrechterhalten werden müssen, am besten.High-performance socket applications know best the amount of overlapped socket operations that must be sustained. Die Anwendung kann so viele SocketAsyncEventArgs-Objekte erstellen wie nötig.The application can create as many of the SocketAsyncEventArgs objects that it needs. Wenn z. b. für eine Serveranwendung immer 15 Socket-Accept-Vorgänge ausstehen müssen, um eingehende Client Verbindungsraten zu unterstützen, kann Sie 15 wiederverwendbare SocketAsyncEventArgs Objekte zu diesem Zweck zuordnen.For example, if a server application needs to have 15 socket accept operations outstanding at all times to support incoming client connection rates, it can allocate 15 reusable SocketAsyncEventArgs objects for that purpose.

Das Muster zum Ausführen eines asynchronen Socketvorgangs mit dieser Klasse besteht aus den folgenden Schritten:The pattern for performing an asynchronous socket operation with this class consists of the following steps:

  1. Zuweisen eines neuen SocketAsyncEventArgs-Kontextobjekt oder Abrufen eines kostenlosen aus einem Anwendungspool.Allocate a new SocketAsyncEventArgs context object, or get a free one from an application pool.

  2. Legen Sie Eigenschaften für das Kontext Objekt auf den Vorgang fest, der ausgeführt werden soll (die Abschluss Rückruf Methode, der Datenpuffer, der Offset im Puffer und die maximale zu übertragenden Datenmenge).Set properties on the context object to the operation about to be performed (the completion callback method, the data buffer, the offset into the buffer, and the maximum amount of data to transfer, for example).

  3. Aufrufen der entsprechenden Socketmethode (XxxAsync) zum Initiieren des asynchronen Vorgangs.Call the appropriate socket method (xxxAsync) to initiate the asynchronous operation.

  4. Wenn die asynchrone Socketmethode (xxxAsync) true zurückgibt, Fragen Sie im Rückruf die Kontexteigenschaften nach Abschluss Status ab.If the asynchronous socket method (xxxAsync) returns true, in the callback, query the context properties for completion status.

  5. Wenn die asynchrone Socketmethode (xxxAsync) false zurückgibt, wurde der Vorgang synchron abgeschlossen.If the asynchronous socket method (xxxAsync) returns false, the operation completed synchronously. Die Kontexteigenschaften könnten möglicherweise für das Betriebsergebnis abgefragt werden.The context properties may be queried for the operation result.

  6. Verwenden Sie den Kontext für einen anderen Vorgang erneut, fügen Sie ihn wieder in den Pool ein, oder verwerfen Sie ihn.Reuse the context for another operation, put it back in the pool, or discard it.

Die Lebensdauer des neuen Kontext Objekts für den asynchronen Socketvorgang wird durch Verweise durch den Anwendungscode und asynchrone e/a-Verweise bestimmt.The lifetime of the new asynchronous socket operation context object is determined by references by the application code and asynchronous I/O references. Es ist nicht erforderlich, dass die Anwendung einen Verweis auf das Kontextobjekt des asynchronen Socketvorgangs beibehält, nachdem er als Parameter an eine der Methoden des asynchronen Socketvorgangs gesendet wurde.It is not necessary for the application to retain a reference to an asynchronous socket operation context object after it is submitted as a parameter to one of the asynchronous socket operation methods. Der Verweis bleibt bestehen, bis der Abschlussrückruf zurückgegeben wird.It will remain referenced until the completion callback returns. Es ist jedoch von Vorteil, dass die Anwendung den Verweis auf den Kontext beibehält, damit Sie für einen zukünftigen asynchronen Socketvorgang wieder verwendet werden kann.However it is advantageous for the application to retain the reference to the context so that it can be reused for a future asynchronous socket operation.



Erstellt eine leere SocketAsyncEventArgs-Instanz.Creates an empty SocketAsyncEventArgs instance.




Ruft den Socket ab, der zum Akzeptieren einer Verbindung mit einer asynchronen Socketmethode erstellt wird, oder legt ihn fest.Gets or sets the socket to use or the socket created for accepting a connection with an asynchronous socket method.


Ruft den Datenpuffer ab, der mit einer asynchronen Socketmethode verwendet werden soll.Gets the data buffer to use with an asynchronous socket method.


Ruft ein Array von Datenpuffern ab, die mit einer asynchronen Socketmethode verwendet werden sollen, oder legt es fest.Gets or sets an array of data buffers to use with an asynchronous socket method.


Ruft die Anzahl der im Socketvorgang übertragenen Bytes ab.Gets the number of bytes transferred in the socket operation.


Ruft die Ausnahme im Fall eines Verbindungsfehlers ab, wenn DnsEndPoint verwendet wurde.Gets the exception in the case of a connection failure when a DnsEndPoint was used.


Das erstellte und verbundene Socket-Objekt nach dem erfolgreichen Beenden der ConnectAsync-Methode.The created and connected Socket object after successful completion of the ConnectAsync method.


Ruft die maximale Datenmenge in Bytes ab, die in einem asynchronen Vorgang gesendet oder empfangen wird.Gets the maximum amount of data, in bytes, to send or receive in an asynchronous operation.


Ruft einen Wert ab, der angibt, ob ein Socket nach einem Trennvorgang wiederverwendet werden kann, oder legt ihn fest.Gets or sets a value that specifies if socket can be reused after a disconnect operation.


Ruft den Typ des Socketvorgangs ab, der zuletzt mit diesem Kontextobjekt ausgeführt wurde.Gets the type of socket operation most recently performed with this context object.


Ruft den Arbeitsspeicherbereich ab, der als Puffer mit einer asynchronen Socketmethode verwendet werden soll.Gets the region of memory to use as a buffer with an asynchronous socket method.


Ruft den Offset in Bytes im Datenpuffer ab, auf den von der Buffer-Eigenschaft verwiesen wird.Gets the offset, in bytes, into the data buffer referenced by the Buffer property.


Ruft die IP-Adresse und Schnittstelle eines empfangenen Pakets ab.Gets the IP address and interface of a received packet.


Ruft den Remote-IP-Endpunkt für einen asynchronen Vorgang ab oder legt ihn fest.Gets or sets the remote IP endpoint for an asynchronous operation.


Ruft ein Array von Puffern ab, die für einen von der SendPacketsAsync(SocketAsyncEventArgs)-Methode verwendeten asynchronen Vorgang gesendet werden sollen, oder legt es fest.Gets or sets an array of buffers to be sent for an asynchronous operation used by the SendPacketsAsync(SocketAsyncEventArgs) method.


Ruft eine bitweise Kombination von TransmitFileOptions-Werten für einen asynchronen Vorgang ab, der von der SendPacketsAsync(SocketAsyncEventArgs)-Methode verwendet wird, oder legt sie fest.Gets or sets a bitwise combination of TransmitFileOptions values for an asynchronous operation used by the SendPacketsAsync(SocketAsyncEventArgs) method.


Ruft die Größe des im Sendevorgang verwendeten Datenblocks in Bytes ab oder legt diese fest.Gets or sets the size, in bytes, of the data block used in the send operation.


Ruft das Protokoll ab, das verwendet wird, um die Socketclient-Zugriffsrichtliniendatei herunterzuladen, oder legt es fest.Gets or sets the protocol to use to download the socket client access policy file.


Ruft das Ergebnis des asynchronen Socketvorgangs ab oder legt dieses fest.Gets or sets the result of the asynchronous socket operation.


Ruft die Ergebnisse eines asynchronen Socketvorgangs ab oder legt das Verhalten eines asynchronen Vorgangs fest.Gets the results of an asynchronous socket operation or sets the behavior of an asynchronous operation.


Ruft ein Benutzer- oder Anwendungsobjekt ab, das diesem asynchronen Socketvorgang zugeordnet ist, oder legt es fest.Gets or sets a user or application object associated with this asynchronous socket operation.



Gibt die von der SocketAsyncEventArgs-Instanz verwendeten nicht verwalteten Ressourcen zurück und verwirft optional die verwalteten Ressourcen.Releases the unmanaged resources used by the SocketAsyncEventArgs instance and optionally disposes of the managed resources.


Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)

Gibt von der SocketAsyncEventArgs-Klasse verwendete Ressourcen frei.Frees resources used by the SocketAsyncEventArgs class.


Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)

Stellt eine Methode dar, die beim Abschluss eines asynchronen Vorgangs aufgerufen wird.Represents a method that is called when an asynchronous operation completes.

SetBuffer(Byte[], Int32, Int32)

Legt den Datenpuffer fest, der mit einer asynchronen Socketmethode verwendet werden soll.Sets the data buffer to use with an asynchronous socket method.

SetBuffer(Int32, Int32)

Legt den Datenpuffer fest, der mit einer asynchronen Socketmethode verwendet werden soll.Sets the data buffer to use with an asynchronous socket method.


Legt den Arbeitsspeicherbereich fest, der als Puffer mit einer asynchronen Socketmethode verwendet werden soll.Sets the region of memory to use as a buffer with an asynchronous socket method.


Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)



Das Ereignis, das zum Abschließen eines asynchronen Vorgangs verwendet wird.The event used to complete an asynchronous operation.

Applies to

See also