SocketAsyncEventArgs Třída

Definice

Obor názvů:: System.Net.Sockets

Sestavení:: System.dll, System.Net.Sockets.dll

Sestavení:: netstandard.dll, System.Net.Sockets.dll

Sestavení:: System.Net.Sockets.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Zdroj:: SocketAsyncEventArgs.cs

Zdroj:: SocketAsyncEventArgs.cs

Zdroj:: SocketAsyncEventArgs.cs

Zdroj:: SocketAsyncEventArgs.cs

Zdroj:: SocketAsyncEventArgs.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Představuje asynchronní operaci soketu.

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

Dědičnost: Object

EventArgs
SocketAsyncEventArgs

Implementuje: IDisposable

Příklady

Následující příklad kódu implementuje logiku připojení pro server soketu, který používá SocketAsyncEventArgs třídu. Po přijetí připojení se všechna data načtená z klienta odešlou zpět klientovi. Čtení a odezva zpět na vzor klienta pokračuje, dokud se klient neodpojí. BufferManager třída, která je použita v tomto příkladu je zobrazena v kódu příklad pro metodu SetBuffer(Byte[], Int32, Int32) . SocketAsyncEventArgsPool třída, která se používá v tomto příkladu, se zobrazí v příkladu SocketAsyncEventArgs kódu pro konstruktor.

// 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);

            // 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
        SocketAsyncEventArgs acceptEventArg = new SocketAsyncEventArgs();
        acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptEventArg_Completed);
        StartAccept(acceptEventArg);

        //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)
    {
        // loop while the method completes synchronously
        bool willRaiseEvent = false;
        while (!willRaiseEvent)
        {
            m_maxNumberAcceptedClients.WaitOne();

            // socket must be cleared since the context object is being reused
            acceptEventArg.AcceptSocket = null;            
            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);
        
        // Accept the next connection request
        StartAccept(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();
        readEventArgs.UserToken = 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);
        }
    }

    // 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
        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);
            Socket socket = (Socket)e.UserToken;
            bool willRaiseEvent = 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
            Socket socket = (Socket)e.UserToken;
            // read the next block of data send from the client
            bool willRaiseEvent = socket.ReceiveAsync(e);
            if (!willRaiseEvent)
            {
                ProcessReceive(e);
            }
        }
        else
        {
            CloseClientSocket(e);
        }
    }

    private void CloseClientSocket(SocketAsyncEventArgs e)
    {
        Socket socket = (Socket)e.UserToken;

        // close the socket associated with the client
        try
        {
            socket.Shutdown(SocketShutdown.Send);
        }
        // throws if client process has already closed
        catch (Exception) { }
        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);
    }
}

Poznámky

Třída SocketAsyncEventArgs je součástí sady vylepšení System.Net.Sockets.Socket třídy, která poskytují alternativní asynchronní vzor, který lze použít specializovanými vysoce výkonnými aplikacemi soketů. Tato třída byla speciálně navržena pro síťové serverové aplikace, které vyžadují vysoký výkon. Aplikace může používat vylepšený asynchronní vzor výhradně nebo pouze v cílových horkých oblastech (například při příjmu velkých objemů dat).

Hlavní funkcí těchto vylepšení je zabránění opakovanému přidělování a synchronizaci objektů během vstupně-výstupních operací asynchronního soketu s velkým objemem. Model návrhu System.Net.Sockets.Socket Begin/End aktuálně implementovaný třídou vyžaduje přidělení objektu System.IAsyncResult pro každou asynchronní operaci soketu.

V nových System.Net.Sockets.Socket vylepšeních tříd jsou asynchronní operace soketů popsány opakovaně použitelnými SocketAsyncEventArgs objekty přidělenými a udržovanými aplikací. Vysoce výkonné aplikace soketů znají nejlepší množství překrývajících se operací soketů, které musí být zachovány. Aplikace může vytvořit tolik SocketAsyncEventArgs objektů, které potřebuje. Pokud například serverová aplikace musí mít vždy nevyřízené operace 15 soketů, aby podporovala rychlost příchozího připojení klientů, může pro tento účel přidělit 15 opakovaně použitelných SocketAsyncEventArgs objektů.

Vzor pro provedení asynchronní operace soketu s touto třídou se skládá z následujících kroků:

Přidělte nový SocketAsyncEventArgs kontextový objekt nebo získejte bezplatný objekt z fondu aplikací.
Nastavte vlastnosti kontextového objektu na operaci, která se má provést (metoda zpětného volání dokončení, vyrovnávací paměť dat, posun do vyrovnávací paměti a maximální množství dat k přenosu, například).
Zavoláte příslušnou metodu soketu (xxxAsync), která zahájí asynchronní operaci.
Pokud asynchronní metoda soketu (xxxAsync) vrátí hodnotu true, v zpětném volání zadejte dotaz na kontextové vlastnosti stavu dokončení.
Pokud asynchronní metoda soketu (xxxAsync) vrátí hodnotu false, operace se dokončila synchronně. Na výsledek operace se můžou dotazovat vlastnosti kontextu.
Znovu použijte kontext pro jinou operaci, vložte ho zpět do fondu nebo ho zahoďte.

Životnost nového objektu kontextu asynchronní operace soketu je určena odkazy na kód aplikace a asynchronní vstupně-výstupní odkazy. Po odeslání jako parametr do jedné z metod asynchronní operace soketu není nutné, aby aplikace zachovala odkaz na objekt kontextu asynchronní operace soketu. Zůstane odkazován až do vrácení zpětného volání dokončení. Je však výhodné, aby aplikace zachovala odkaz na kontext, aby ji bylo možné znovu použít pro budoucí asynchronní operaci soketu.

Konstruktory

Name	Description
SocketAsyncEventArgs()	Vytvoří prázdnou SocketAsyncEventArgs instanci.
SocketAsyncEventArgs(Boolean)	Inicializuje SocketAsyncEventArgs.

Vlastnosti

Name	Description
AcceptSocket	Získá nebo nastaví soket pro použití nebo soket vytvořený pro příjem připojení pomocí asynchronní soket metody.
Buffer	Získá datovou vyrovnávací paměť pro použití s asynchronní metodou soketu.
BufferList	Získá nebo nastaví pole vyrovnávací paměti dat pro použití s asynchronní soket metoda.
BytesTransferred	Získá počet bajtů přenesených v operaci soketu.
ConnectByNameError	Získá výjimku v případě selhání připojení při DnsEndPoint použití.
ConnectSocket	Vytvořený a připojený Socket objekt po úspěšném dokončení ConnectAsync metody.
Count	Získá maximální množství dat v bajtech pro odesílání nebo příjem v asynchronní operaci.
DisconnectReuseSocket	Získá nebo nastaví hodnotu, která určuje, zda lze soket znovu použít po operaci odpojení.
LastOperation	Získá typ operace soketu naposledy provedené s tímto kontextovým objektem.
MemoryBuffer	Získá oblast paměti, která se má použít jako vyrovnávací paměť s asynchronní metodou soketu.
Offset	Získá posun v bajtech do vyrovnávací paměti dat odkazované vlastností Buffer .
ReceiveMessageFromPacketInfo	Získá IP adresu a rozhraní přijatého paketu.
RemoteEndPoint	Získá nebo nastaví koncový bod vzdálené IP adresy pro asynchronní operaci.
SendPacketsElements	Získá nebo nastaví pole vyrovnávacích pamětí, které se mají odeslat pro asynchronní operaci používanou metodou SendPacketsAsync(SocketAsyncEventArgs) .
SendPacketsFlags	Získá nebo nastaví bitové kombinace TransmitFileOptions hodnot pro asynchronní operaci používanou metodou SendPacketsAsync(SocketAsyncEventArgs) .
SendPacketsSendSize	Získá nebo nastaví velikost datového bloku použitého v operaci odeslání v bajtech.
SocketClientAccessPolicyProtocol	Zastaralé. Získá nebo nastaví protokol, který se má použít ke stažení souboru zásad přístupu klienta soketu.
SocketError	Získá nebo nastaví výsledek asynchronní operace soketu.
SocketFlags	Získá výsledky asynchronní operace soketu nebo nastaví chování asynchronní operace.
UserToken	Získá nebo nastaví objekt uživatele nebo aplikace přidružené k této asynchronní soket operace.

Metody

Name	Description
Dispose()	Uvolní nespravované prostředky používané SocketAsyncEventArgs instancí a volitelně odstraní spravované prostředky.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
Finalize()	Uvolní prostředky používané SocketAsyncEventArgs třídou.
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
OnCompleted(SocketAsyncEventArgs)	Představuje metodu, která se volá při dokončení asynchronní operace.
SetBuffer(Byte[], Int32, Int32)	Nastaví vyrovnávací paměť dat tak, aby se používala s asynchronní metodou soketu.
SetBuffer(Int32, Int32)	Nastaví vyrovnávací paměť dat tak, aby se používala s asynchronní metodou soketu.
SetBuffer(Memory<Byte>)	Nastaví oblast paměti, která se má použít jako vyrovnávací paměť s asynchronní metodou soketu.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

Událost

Name	Description
Completed	Událost použitá k dokončení asynchronní operace.

Platí pro

Viz také

Váš názor

Byla tato stránka užitečná?