SocketAsyncEventArgs Classe

Definizione

Rappresenta un'operazione socket asincrona.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
Ereditarietà
SocketAsyncEventArgs
Implementazioni

Esempi

Nell'esempio di codice seguente viene implementata la logica di connessione per il server socket che utilizza la classe SocketAsyncEventArgs.The following code example implements the connection logic for the socket server that uses the SocketAsyncEventArgs class. Dopo aver accettato una connessione, tutti i dati letti dal client vengono restituiti al client.After accepting a connection, all data read from the client is sent back to the client. La lettura e l'eco al modello client vengono continuate fino a quando il client non si disconnette.The read and echo back to the client pattern is continued until the client disconnects. La classe gestore buffer usata da questo esempio viene visualizzata nell'esempio di codice per il metodo SetBuffer(Byte[], Int32, Int32).The BufferManager class that is used by this example is displayed in the code example for the SetBuffer(Byte[], Int32, Int32) method. La classe SocketAsyncEventArgsPool usata in questo esempio viene visualizzata nell'esempio di codice per il costruttore SocketAsyncEventArgs.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,
            receiveBufferSize);
  
        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
        m_bufferManager.InitBuffer();

        // 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
            m_bufferManager.SetBuffer(readWriteEventArg);

            // add SocketAsyncEventArg to the pool
            m_readWritePool.Push(readWriteEventArg);
        }

    }

    // 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);
        listenSocket.Bind(localEndPoint);
        // start the server with a listen backlog of 100 connections
        listenSocket.Listen(100);
        
        // post accepts on the listening socket
        StartAccept(null);            

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


    // 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);
        }
        else
        {
            // socket must be cleared since the context object is being reused
            acceptEventArg.AcceptSocket = null;
        }

        m_maxNumberAcceptedClients.WaitOne();
        bool willRaiseEvent = listenSocket.AcceptAsync(acceptEventArg);
        if (!willRaiseEvent)
        {
            ProcessAccept(acceptEventArg);
        }
    }

    // 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)
    {
        ProcessAccept(e);
    }

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

        // 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);
        if(!willRaiseEvent){
            ProcessReceive(readEventArgs);
        }

        // Accept the next connection request
        StartAccept(e);
    }

    // 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:
                ProcessReceive(e);
                break;
            case SocketAsyncOperation.Send:
                ProcessSend(e);
                break;
            default:
                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)
            {
                ProcessSend(e);
            }
          
        }
        else
        {
            CloseClientSocket(e);
        }
    }

    // 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)
            {
                ProcessReceive(e);
            }
        }
        else
        {
            CloseClientSocket(e);
        }
    }

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

        // close the socket associated with the client
        try
        {
            token.Socket.Shutdown(SocketShutdown.Send);
        }
        // throws if client process has already closed
        catch (Exception) { }
        token.Socket.Close();

        // 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
        m_readWritePool.Push(e);
        
        m_maxNumberAcceptedClients.Release();
        Console.WriteLine("A client has been disconnected from the server. There are {0} clients connected to the server", m_numConnectedSockets);
    }

}    

Commenti

La classe SocketAsyncEventArgs fa parte di un set di miglioramenti apportati alla classe System.Net.Sockets.Socket che forniscono un modello asincrono alternativo che può essere utilizzato da applicazioni socket ad alte prestazioni specializzate.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. Questa classe è stata progettata appositamente per le applicazioni server di rete che richiedono prestazioni elevate.This class was specifically designed for network server applications that require high performance. Un'applicazione può usare il modello asincrono migliorato esclusivamente o solo in aree sensibili mirate, ad esempio quando si ricevono grandi quantità di dati.An application can use the enhanced asynchronous pattern exclusively or only in targeted hot areas (for example, when receiving large amounts of data).

La funzionalità principale di questi miglioramenti è evitare l'allocazione ripetuta e la sincronizzazione degli oggetti durante operazioni di I/O su socket asincrone con volumi elevati di dati.The main feature of these enhancements is the avoidance of the repeated allocation and synchronization of objects during high-volume asynchronous socket I/O. Il modello di progettazione Begin/End attualmente implementato dalla classe System.Net.Sockets.Socket richiede l'allocazione di un oggetto System.IAsyncResult per ogni operazione socket asincrona.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.

Nei nuovi miglioramenti apportati alla classe System.Net.Sockets.Socket, le operazioni socket asincrone sono descritte dagli oggetti riutilizzabili di SocketAsyncEventArgs allocati e gestiti dall'applicazione.In the new System.Net.Sockets.Socket class enhancements, asynchronous socket operations are described by reusable SocketAsyncEventArgs objects allocated and maintained by the application. Le applicazioni ad alte prestazioni che usano socket conoscono bene la quantità di operazioni su socket sovrapposte che occorre supportare.High-performance socket applications know best the amount of overlapped socket operations that must be sustained. L'applicazione può creare il numero di oggetti SocketAsyncEventArgs necessari.The application can create as many of the SocketAsyncEventArgs objects that it needs. Se, ad esempio, un'applicazione server deve disporre di 15 operazioni di accettazione socket in ogni momento per supportare le tariffe di connessione client in ingresso, può allocare 15 oggetti SocketAsyncEventArgs riutilizzabili a tale scopo.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.

Il modello per l'esecuzione di un'operazione socket asincrona con questa classe è costituito dai passaggi seguenti:The pattern for performing an asynchronous socket operation with this class consists of the following steps:

  1. Allocare un nuovo oggetto contesto SocketAsyncEventArgs oppure ottenerne uno libero da un pool di applicazioni.Allocate a new SocketAsyncEventArgs context object, or get a free one from an application pool.

  2. Impostare le proprietà dell'oggetto di contesto sull'operazione da eseguire (il metodo di callback di completamento, il buffer dei dati, l'offset nel buffer e la quantità massima di dati da trasferire, ad esempio).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. Chiamare il metodo socket appropriato (xxxAsync) per avviare l'operazione asincrona.Call the appropriate socket method (xxxAsync) to initiate the asynchronous operation.

  4. Se il metodo socket asincrono (xxxAsync) restituisce true, nel callback eseguire una query sulle proprietà di contesto per lo stato di completamento.If the asynchronous socket method (xxxAsync) returns true, in the callback, query the context properties for completion status.

  5. Se il metodo socket asincrono (xxxAsync) restituisce false, l'operazione viene completata in modo sincrono.If the asynchronous socket method (xxxAsync) returns false, the operation completed synchronously. È possibile recuperare il risultato dell'operazione dalle proprietà di contesto.The context properties may be queried for the operation result.

  6. Riutilizzare il contesto per un'altra operazione, inserirlo nuovamente nel pool o rimuoverlo.Reuse the context for another operation, put it back in the pool, or discard it.

La durata del nuovo oggetto di contesto dell'operazione socket asincrona è determinata dai riferimenti del codice dell'applicazione e dei riferimenti di I/O asincroni.The lifetime of the new asynchronous socket operation context object is determined by references by the application code and asynchronous I/O references. Non è necessario che l'applicazione mantenga un riferimento a un oggetto di contesto dell'operazione socket asincrona dopo l'invio come parametro a uno dei metodi per operazioni socket asincrone.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. Il riferimento verrà mantenuto attivo fino a quando il callback di completamento non restituisce il controllo.It will remain referenced until the completion callback returns. Tuttavia è vantaggioso per l'applicazione mantenere il riferimento al contesto in modo che possa essere riutilizzato per un'operazione socket asincrona futura.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.

Costruttori

SocketAsyncEventArgs()

Crea un'istanza vuota della classe SocketAsyncEventArgs.Creates an empty SocketAsyncEventArgs instance.

Proprietà

AcceptSocket

Ottiene o imposta il socket da utilizzare o il socket creato per accettare una connessione con un metodo socket asincrono.Gets or sets the socket to use or the socket created for accepting a connection with an asynchronous socket method.

Buffer

Ottiene il buffer di dati da utilizzare con un metodo socket asincrono.Gets the data buffer to use with an asynchronous socket method.

BufferList

Ottiene o imposta una matrice di buffer di dati da utilizzare con un metodo socket asincrono.Gets or sets an array of data buffers to use with an asynchronous socket method.

BytesTransferred

Ottiene il numero di byte trasferiti nell'operazione socket.Gets the number of bytes transferred in the socket operation.

ConnectByNameError

Ottiene l'eccezione nel caso di errore di connessione quando viene utilizzato DnsEndPoint.Gets the exception in the case of a connection failure when a DnsEndPoint was used.

ConnectSocket

Oggetto Socket creato e connesso dopo il completamento del metodo ConnectAsync.The created and connected Socket object after successful completion of the ConnectAsync method.

Count

Ottiene la quantità massima di dati, in byte, da inviare o ricevere in un'operazione asincrona.Gets the maximum amount of data, in bytes, to send or receive in an asynchronous operation.

DisconnectReuseSocket

Ottiene o imposta un valore che specifica se il socket può essere riutilizzato dopo un'operazione di disconnessione.Gets or sets a value that specifies if socket can be reused after a disconnect operation.

LastOperation

Ottiene il tipo di operazione socket eseguita più di recente con questo oggetto di contesto.Gets the type of socket operation most recently performed with this context object.

MemoryBuffer

Ottiene l'area di memoria da usare come buffer con un metodo socket asincrono.Gets the region of memory to use as a buffer with an asynchronous socket method.

Offset

Ottiene l'offset, in byte, nel buffer di dati a cui fa riferimento la proprietà Buffer.Gets the offset, in bytes, into the data buffer referenced by the Buffer property.

ReceiveMessageFromPacketInfo

Ottiene l'indirizzo IP e l'interfaccia di un pacchetto ricevuto.Gets the IP address and interface of a received packet.

RemoteEndPoint

Ottiene o imposta l'endpoint IP remoto per un'operazione asincrona.Gets or sets the remote IP endpoint for an asynchronous operation.

SendPacketsElements

Ottiene o imposta una matrice di buffer da inviare per un'operazione asincrona utilizzata dal metodo SendPacketsAsync(SocketAsyncEventArgs).Gets or sets an array of buffers to be sent for an asynchronous operation used by the SendPacketsAsync(SocketAsyncEventArgs) method.

SendPacketsFlags

Ottiene o imposta una combinazione bit per bit di valori TransmitFileOptions per un'operazione asincrona utilizzata dal metodo SendPacketsAsync(SocketAsyncEventArgs).Gets or sets a bitwise combination of TransmitFileOptions values for an asynchronous operation used by the SendPacketsAsync(SocketAsyncEventArgs) method.

SendPacketsSendSize

Ottiene o imposta la dimensione, in byte, del blocco di dati utilizzato nell'operazione di invio.Gets or sets the size, in bytes, of the data block used in the send operation.

SocketClientAccessPolicyProtocol

Ottiene o imposta il protocollo da utilizzare per scaricare il file dei criteri di accesso del client socket.Gets or sets the protocol to use to download the socket client access policy file.

SocketError

Ottiene o imposta i risultati dell'operazione socket asincrona.Gets or sets the result of the asynchronous socket operation.

SocketFlags

Ottiene i risultati di un'operazione socket asincrona o imposta il comportamento di un'operazione asincrona.Gets the results of an asynchronous socket operation or sets the behavior of an asynchronous operation.

UserToken

Ottiene o imposta un oggetto utente o applicazione associato a questa operazione socket asincrona.Gets or sets a user or application object associated with this asynchronous socket operation.

Metodi

Dispose()

Rilascia le risorse non gestite utilizzate dall'istanza SocketAsyncEventArgs e facoltativamente elimina anche le risorse gestite.Releases the unmanaged resources used by the SocketAsyncEventArgs instance and optionally disposes of the managed resources.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Finalize()

Rilascia le risorse usate dalla classe SocketAsyncEventArgs.Frees resources used by the SocketAsyncEventArgs class.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
OnCompleted(SocketAsyncEventArgs)

Rappresenta un metodo chiamato quando un'operazione asincrona viene completata.Represents a method that is called when an asynchronous operation completes.

SetBuffer(Byte[], Int32, Int32)

Imposta il buffer di dati da utilizzare con un metodo socket asincrono.Sets the data buffer to use with an asynchronous socket method.

SetBuffer(Int32, Int32)

Imposta il buffer di dati da utilizzare con un metodo socket asincrono.Sets the data buffer to use with an asynchronous socket method.

SetBuffer(Memory<Byte>)

Imposta l'area di memoria da usare come buffer con un metodo socket asincrono.Sets the region of memory to use as a buffer with an asynchronous socket method.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Eventi

Completed

Evento utilizzato per completare un'operazione asincrona.The event used to complete an asynchronous operation.

Si applica a

Vedi anche