Socket.BeginAccept Methode

Definition

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.Begins an asynchronous operation to accept an incoming connection attempt.

Überlädt

BeginAccept(AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.Begins an asynchronous operation to accept an incoming connection attempt.

BeginAccept(Int32, AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen, und empfängt den ersten von der Clientanwendung gesendeten Datenblock.Begins an asynchronous operation to accept an incoming connection attempt and receives the first block of data sent by the client application.

BeginAccept(Socket, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung von einem angegebenen Socket anzunehmen, und empfängt den ersten von der Clientanwendung gesendeten Datenblock.Begins an asynchronous operation to accept an incoming connection attempt from a specified socket and receives the first block of data sent by the client application.

BeginAccept(AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen.Begins an asynchronous operation to accept an incoming connection attempt.

public:
 IAsyncResult ^ BeginAccept(AsyncCallback ^ callback, System::Object ^ state);
public IAsyncResult BeginAccept (AsyncCallback callback, object state);
member this.BeginAccept : AsyncCallback * obj -> IAsyncResult
Public Function BeginAccept (callback As AsyncCallback, state As Object) As IAsyncResult

Parameter

callback
AsyncCallback

Der AsyncCallback-Delegat.The AsyncCallback delegate.

state
Object

Ein Objekt mit Zustandsinformationen für diese Anforderung.An object that contains state information for this request.

Gibt zurück

Ein IAsyncResult, das auf die asynchrone Socket-Erstellung verweist.An IAsyncResult that references the asynchronous Socket creation.

Ausnahmen

Das Socket-Objekt wurde geschlossen.The Socket object has been closed.

Für diese Methode ist Windows NT erforderlich.Windows NT is required for this method.

Der annehmende Socket überwacht keine Verbindungen.The accepting socket is not listening for connections. Vor dem Aufruf von Bind(EndPoint) müssen Sie Listen(Int32) und BeginAccept(AsyncCallback, Object) aufrufen.You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

- oder --or- Der angenommene Socket ist gebunden.The accepted socket is bound.

receiveSize ist kleiner als 0.receiveSize is less than 0.

Fehler beim Versuch, auf den Socket zuzugreifen.An error occurred when attempting to access the socket.

Beispiele

Im folgenden Codebeispiel wird versucht, asynchron eine eingehende Verbindung zu empfangen.The following code example attempts to receive an incoming connection asynchronously.

IPHostEntry^ lipa = Dns::Resolve( "host.contoso.com" );
IPEndPoint^ lep = gcnew IPEndPoint( lipa->AddressList[ 0 ], 11000 );

Socket^ s = gcnew Socket( lep->Address->AddressFamily,
   SocketType::Stream,
   ProtocolType::Tcp );
try
{
   s->Bind( lep );
   s->Listen( 1000 );

   while ( true )
   {
      allDone->Reset();

      Console::WriteLine( "Waiting for a connection..." );
      s->BeginAccept( gcnew AsyncCallback( &Async_Send_Receive::Connect_Callback ), s );

      allDone->WaitOne();
   }
}
catch ( Exception^ e ) 
{
   Console::WriteLine( e );
}
IPHostEntry lipa = Dns.Resolve("host.contoso.com");
IPEndPoint lep = new IPEndPoint(lipa.AddressList[0], 11000);

   Socket s = new Socket(lep.Address.AddressFamily,
                               SocketType.Stream,
                                     ProtocolType.Tcp);
   try{
        s.Bind(lep);
        s.Listen(1000);

        while(true){
             allDone.Reset();

             Console.WriteLine("Waiting for a connection...");
             s.BeginAccept(new AsyncCallback(Async_Send_Receive.Listen_Callback), s);

             allDone.WaitOne();
        }
   }
   catch (Exception e){
        Console.WriteLine(e.ToString());
   }
   Dim lipa As IPHostEntry = Dns.Resolve("host.contoso.com")
   Dim lep As New IPEndPoint(lipa.AddressList(0), 11000)
   
   Dim s As New Socket(lep.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp)
   Try
      s.Bind(lep)
      s.Listen(1000)
      
      While True
         allDone.Reset()
         
         Console.WriteLine("Waiting for a connection...")
         s.BeginAccept(New AsyncCallback(AddressOf Async_Send_Receive.Listen_Callback), s)
         
         allDone.WaitOne()
      End While
   Catch e As Exception
      Console.WriteLine(e.ToString())
   End Try
End Sub

Hinweise

Verbindungs orientierte Protokolle können die BeginAccept-Methode verwenden, um eingehende Verbindungsversuche asynchron zu verarbeiten.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. Durch die asynchrone Annahme von Verbindungen haben Sie die Möglichkeit, Daten in einem separaten Ausführungs Thread zu senden und zu empfangen.Accepting connections asynchronously gives you the ability to send and receive data within a separate execution thread. Bevor Sie die BeginAccept-Methode aufrufen, müssen Sie die Listen-Methode aufrufen, um eingehende Verbindungsanforderungen abzuhören und in die Warteschlange zuBefore calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Sie müssen eine Rückruf Methode erstellen, die den AsyncCallback Delegaten implementiert und seinen Namen an die BeginAccept-Methode übergibt.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Um dies zu erreichen, müssen Sie das ÜberwachungSocket Objekt an BeginAccept über den state-Parameter übergeben.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. Wenn Ihr Rückruf Weitere Informationen benötigt, können Sie eine kleine Klasse erstellen, um die Socket und die anderen erforderlichen Informationen zu speichern.If your callback needs more information, you can create a small class to hold the Socket and the other required information. Übergeben Sie mithilfe des state-Parameters eine Instanz dieser Klasse an die BeginAccept-Methode.Pass an instance of this class to the BeginAccept method through the state parameter.

Die Rückruf Methode sollte die EndAccept-Methode aufrufen.Your callback method should invoke the EndAccept method. Wenn die Anwendung BeginAcceptaufruft, verwendet das System in der Regel einen separaten Thread, um die angegebene Rückruf Methode auszuführen und Blöcke auf EndAccept auszuführen, bis eine ausstehende Verbindung abgerufen wird.When your application calls BeginAccept, the system usually uses a separate thread to execute the specified callback method and blocks on EndAccept until a pending connection is retrieved. EndAccept gibt ein neues Socket Objekt zurück, das zum Senden und empfangen von Daten mit dem Remote Host verwendet werden kann.EndAccept will return a new Socket object that you can use to send and receive data with the remote host. Sie können dieses zurückgegebene Socket nicht verwenden, um zusätzliche Verbindungen aus der Verbindungs Warteschlange zu akzeptieren.You cannot use this returned Socket to accept any additional connections from the connection queue. Wenn der ursprüngliche Thread blockiert werden soll, nachdem Sie die BeginAccept-Methode aufgerufen haben, verwenden Sie WaitHandle.WaitOne.If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Rufen Sie die Set-Methode für eine ManualResetEvent in der Rückruf Methode auf, wenn der ursprüngliche Thread weiter ausgeführt werden soll.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

Das System kann auch den aufrufenden Thread verwenden, um die Rückruf Methode aufzurufen.The system may also use the calling thread to invoke the callback method. In diesem Fall wird die CompletedSynchronously-Eigenschaft des zurückgegebenen IAsyncResult festgelegt, um anzugeben, dass die BeginAccept-Methode synchron abgeschlossen wurde.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

Weitere Informationen zum Schreiben von Rückruf Methoden finden Sie unter Mars Hallen eines Delegaten als Rückruf Methode.For additional information on writing callback methods see Marshaling a Delegate as a Callback Method.

Um einen ausstehenden aufzurufenden BeginAccept-Methode abzubrechen, schließen Sie die Socket.To cancel a pending call to the BeginAccept method, close the Socket. Wenn die Close-Methode aufgerufen wird, während ein asynchroner Vorgang ausgeführt wird, wird der Rückruf, der für die BeginAccept-Methode bereitgestellt wird, aufgerufen.When the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Bei einem nachfolgenden-Rückruf der EndAccept-Methode wird ein ObjectDisposedException ausgelöst, um anzugeben, dass der Vorgang abgebrochen wurde.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Hinweis

Sie können die RemoteEndPoint-Eigenschaft des zurückgegebenen Socket verwenden, um die Netzwerkadresse und die Portnummer des Remote Hosts zu identifizieren.You can use the RemoteEndPoint property of the returned Socket to identify the remote host's network address and port number.

Hinweis

Wenn Sie erhalten eine SocketException, verwenden die SocketException.ErrorCode Eigenschaft, um den spezifischen Fehlercode zu erhalten.If you receive a SocketException, use the SocketException.ErrorCode property to obtain the specific error code. Nachdem Sie diesen Code abgerufen haben, finden Sie in der API-Fehlercode Dokumentation der Windows Sockets, Version 2 , eine ausführliche Beschreibung des Fehlers.After you have obtained this code, refer to the Windows Sockets version 2 API error code documentation for a detailed description of the error.

Hinweis

Dieser Member gibt Ablaufverfolgungsinformationen aus, wenn Sie die Netzwerkablaufverfolgung in der Anwendung aktivieren.This member outputs trace information when you enable network tracing in your application. Weitere Informationen finden Sie unter Netzwerk Ablauf Verfolgung in der .NET Framework.For more information, see Network Tracing in the .NET Framework.

Hinweis

Der Ausführungs Kontext (der Sicherheitskontext, der Benutzer, dessen Identität angenommen wurde, und der aufrufende Kontext) wird für die asynchronen Socket Methoden zwischengespeichert.The execution context (the security context, the impersonated user, and the calling context) is cached for the asynchronous Socket methods. Nach der ersten Verwendung eines bestimmten Kontexts (einer bestimmten asynchronen Socket Methode, einer bestimmten Socket Instanz und eines bestimmten Rückrufs) wird bei der nachfolgenden Verwendung dieses Kontexts eine Leistungsverbesserung angezeigt.After the first use of a particular context (a specific asynchronous Socket method, a specific Socket instance, and a specific callback), subsequent uses of that context will see a performance improvement.

Siehe auch

BeginAccept(Int32, AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung anzunehmen, und empfängt den ersten von der Clientanwendung gesendeten Datenblock.Begins an asynchronous operation to accept an incoming connection attempt and receives the first block of data sent by the client application.

public:
 IAsyncResult ^ BeginAccept(int receiveSize, AsyncCallback ^ callback, System::Object ^ state);
public IAsyncResult BeginAccept (int receiveSize, AsyncCallback callback, object state);
member this.BeginAccept : int * AsyncCallback * obj -> IAsyncResult
Public Function BeginAccept (receiveSize As Integer, callback As AsyncCallback, state As Object) As IAsyncResult

Parameter

receiveSize
Int32

Die Anzahl der Bytes vom Absender, die angenommen werden sollen.The number of bytes to accept from the sender.

callback
AsyncCallback

Der AsyncCallback-Delegat.The AsyncCallback delegate.

state
Object

Ein Objekt mit Zustandsinformationen für diese Anforderung.An object that contains state information for this request.

Gibt zurück

Ein IAsyncResult, das auf die asynchrone Socket-Erstellung verweist.An IAsyncResult that references the asynchronous Socket creation.

Ausnahmen

Das Socket-Objekt wurde geschlossen.The Socket object has been closed.

Für diese Methode ist Windows NT erforderlich.Windows NT is required for this method.

Der annehmende Socket überwacht keine Verbindungen.The accepting socket is not listening for connections. Vor dem Aufruf von Bind(EndPoint) müssen Sie Listen(Int32) und BeginAccept(AsyncCallback, Object) aufrufen.You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

- oder --or- Der angenommene Socket ist gebunden.The accepted socket is bound.

receiveSize ist kleiner als 0.receiveSize is less than 0.

Fehler beim Versuch, auf den Socket zuzugreifen.An error occurred when attempting to access the socket.

Beispiele

Im folgenden Codebeispiel wird ein Socket geöffnet und eine asynchrone Verbindung akzeptiert.The following code example opens a socket and accepts an asynchronous connection. In diesem Beispiel nimmt der Socket die ersten 10 Bytes an Daten an.In this example, the socket accepts the initial 10 bytes of data. Die Anzahl der empfangenen Bytes und die Daten werden vom Rückruf Delegaten in der Konsole angezeigt.The number of bytes received and the data are displayed on the console by the callback delegate. Unter BeginReceive finden Sie eine Beschreibung, wie die verbleibenden Daten empfangen werden.See BeginReceive for a description of how the remaining data is received.

   // This server waits for a connection and then uses asynchronous operations to
   // accept the connection with initial data sent from the client.
   // Establish the local endpoint for the socket.
   IPHostEntry^ ipHostInfo = Dns::GetHostEntry( Dns::GetHostName() );
   IPAddress^ ipAddress = ipHostInfo->AddressList[ 0 ];
   IPEndPoint^ localEndPoint = gcnew IPEndPoint( ipAddress,11000 );
   
   // Create a TCP/IP socket.
   Socket^ listener = gcnew Socket( AddressFamily::InterNetwork,SocketType::Stream,ProtocolType::Tcp );
   
   // Bind the socket to the local endpoint, and listen for incoming connections.
   listener->Bind( localEndPoint );
   listener->Listen( 100 );
   for ( ; ;  )
   {
      
      // Set the event to nonsignaled state.
      allDone->Reset();
      
      // Start an asynchronous socket to listen for connections and receive data from the client.
      Console::WriteLine( "Waiting for a connection..." );
      
      // Accept the connection and receive the first 10 bytes of data.
      int receivedDataSize = 10;
      listener->BeginAccept( receivedDataSize, gcnew AsyncCallback( AcceptReceiveCallback ), listener );
      
      // Wait until a connection is made and processed before continuing.
      allDone->WaitOne();

   }
}

static void AcceptReceiveCallback( IAsyncResult^ ar )
{
   // Get the socket that handles the client request.
   Socket^ listener = dynamic_cast<Socket^>(ar->AsyncState);

   // End the operation and display the received data on the console.
   array<Byte>^Buffer;
   int bytesTransferred;
   Socket^ handler = listener->EndAccept( Buffer, bytesTransferred, ar );
   String^ stringTransferred = Encoding::ASCII->GetString( Buffer, 0, bytesTransferred );
   Console::WriteLine( stringTransferred );
   Console::WriteLine( "Size of data transferred is {0}", bytesTransferred );

   // Create the state object for the asynchronous receive.
   StateObject^ state = gcnew StateObject;
   state->workSocket = handler;
   handler->BeginReceive( state->buffer, 0, StateObject::BufferSize, static_cast<SocketFlags>(0), gcnew AsyncCallback( ReadCallback ), state );
}


       // This server waits for a connection and then uses asynchronous operations to
       // accept the connection with initial data sent from the client.
            
       
       // Establish the local endpoint for the socket.
   
       IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
       IPAddress ipAddress = ipHostInfo.AddressList[0];
       IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
      
       // Create a TCP/IP socket.
       Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );

       // Bind the socket to the local endpoint, and listen for incoming connections.
       listener.Bind(localEndPoint);
       listener.Listen(100);

       while (true) 
       {
           // Set the event to nonsignaled state.
           allDone.Reset();

           // Start an asynchronous socket to listen for connections and receive data from the client.
           Console.WriteLine("Waiting for a connection...");

           // Accept the connection and receive the first 10 bytes of data.
           int receivedDataSize = 10;
           listener.BeginAccept(receivedDataSize, new AsyncCallback(AcceptReceiveCallback), listener);
            
           // Wait until a connection is made and processed before continuing.
           allDone.WaitOne();
       }
 
   }


   public static void AcceptReceiveCallback(IAsyncResult ar) 
   {
       // Get the socket that handles the client request.
       Socket listener = (Socket) ar.AsyncState;
       
       // End the operation and display the received data on the console.
       byte[] Buffer;
       int bytesTransferred;
       Socket handler = listener.EndAccept(out Buffer, out bytesTransferred, ar);
       string stringTransferred = Encoding.ASCII.GetString(Buffer, 0, bytesTransferred);

       Console.WriteLine(stringTransferred);
       Console.WriteLine("Size of data transferred is {0}", bytesTransferred);
             
       // Create the state object for the asynchronous receive.
       StateObject state = new StateObject();
       state.workSocket = handler;
       handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
       new AsyncCallback(ReadCallback), state);
   }

Hinweise

Verbindungs orientierte Protokolle können die BeginAccept-Methode verwenden, um eingehende Verbindungsversuche asynchron zu verarbeiten.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. Das asynchrone akzeptieren von Verbindungen ermöglicht das Senden und empfangen von Daten in einem separaten Ausführungs Thread.Accepting connections asynchronously enables you to send and receive data within a separate execution thread. Diese Überladung ermöglicht es Ihnen, die Anzahl der Bytes anzugeben, die bei der anfänglichen Übertragung im receiveSize-Parameter akzeptiert werden sollen.This overload allows you to specify the number of bytes to accept in the initial transfer in the receiveSize parameter.

Bevor Sie die BeginAccept-Methode aufrufen, müssen Sie die Listen-Methode aufrufen, um eingehende Verbindungsanforderungen abzuhören und in die Warteschlange zuBefore calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Sie müssen eine Rückruf Methode erstellen, die den AsyncCallback Delegaten implementiert und seinen Namen an die BeginAccept-Methode übergibt.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Um dies zu erreichen, müssen Sie das ÜberwachungSocket Objekt an BeginAccept über den state-Parameter übergeben.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. Wenn Ihr Rückruf Weitere Informationen benötigt, können Sie eine kleine Klasse erstellen, um die Socket und die anderen erforderlichen Informationen zu speichern.If your callback needs more information, you can create a small class to hold the Socket and the other required information. Übergeben Sie mithilfe des state-Parameters eine Instanz dieser Klasse an die BeginAccept-Methode.Pass an instance of this class to the BeginAccept method through the state parameter.

Die Rückruf Methode sollte die EndAccept-Methode aufrufen.Your callback method should invoke the EndAccept method. Wenn die Anwendung BeginAcceptaufruft, verwendet das System in der Regel einen separaten Thread, um die angegebene Rückruf Methode auszuführen und Blöcke auf EndAccept auszuführen, bis eine ausstehende Verbindung abgerufen wird.When your application calls BeginAccept, the system usually uses a separate thread to execute the specified callback method and blocks on EndAccept until a pending connection is retrieved.

EndAccept gibt einen neuen Socket zurück, den Sie zum Senden und empfangen von Daten mit dem Remote Host verwenden können.EndAccept returns a new Socket that you can use to send and receive data with the remote host. Sie können dieses zurückgegebene Socket nicht verwenden, um zusätzliche Verbindungen aus der Verbindungs Warteschlange zu akzeptieren.You cannot use this returned Socket to accept any additional connections from the connection queue. Wenn der ursprüngliche Thread blockiert werden soll, nachdem Sie die BeginAccept-Methode aufgerufen haben, verwenden Sie WaitHandle.WaitOne.If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Rufen Sie die Set-Methode für eine ManualResetEvent in der Rückruf Methode auf, wenn der ursprüngliche Thread weiter ausgeführt werden soll.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

Das System kann auch den aufrufenden Thread verwenden, um die Rückruf Methode aufzurufen.The system may also use the calling thread to invoke the callback method. In diesem Fall wird die CompletedSynchronously-Eigenschaft des zurückgegebenen IAsyncResult festgelegt, um anzugeben, dass die BeginAccept-Methode synchron abgeschlossen wurde.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

Weitere Informationen zum Schreiben von Rückruf Methoden finden Sie unter Mars Hallen eines Delegaten als Rückruf Methode.For additional information on writing callback methods see Marshaling a Delegate as a Callback Method.

Um einen ausstehenden aufzurufenden BeginAccept-Methode abzubrechen, schließen Sie die Socket.To cancel a pending call to the BeginAccept method, close the Socket. Wenn die Close-Methode aufgerufen wird, während ein asynchroner Vorgang ausgeführt wird, wird der Rückruf, der für die BeginAccept-Methode bereitgestellt wird, aufgerufen.When the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Bei einem nachfolgenden-Rückruf der EndAccept-Methode wird ein ObjectDisposedException ausgelöst, um anzugeben, dass der Vorgang abgebrochen wurde.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Hinweis

Sie können mit der RemoteEndPoint-Eigenschaft des zurückgegebenen Socket Objekts aufzurufen, um die Netzwerkadresse und die Portnummer des Remote Hosts zu identifizieren.You can call use the RemoteEndPoint property of the returned Socket object to identify the remote host's network address and port number.

Hinweis

Wenn Sie erhalten eine SocketException, verwenden die SocketException.ErrorCode Eigenschaft, um den spezifischen Fehlercode zu erhalten.If you receive a SocketException, use the SocketException.ErrorCode property to obtain the specific error code. Nachdem Sie diesen Code abgerufen haben, finden Sie in der API-Fehlercode Dokumentation der Windows Sockets, Version 2 , eine ausführliche Beschreibung des Fehlers.After you have obtained this code, refer to the Windows Sockets version 2 API error code documentation for a detailed description of the error.

Hinweis

Dieser Member gibt Ablaufverfolgungsinformationen aus, wenn Sie die Netzwerkablaufverfolgung in der Anwendung aktivieren.This member outputs trace information when you enable network tracing in your application. Weitere Informationen finden Sie unter Netzwerk Ablauf Verfolgung in der .NET Framework.For more information, see Network Tracing in the .NET Framework.

Hinweis

Der Ausführungs Kontext (der Sicherheitskontext, der Benutzer, dessen Identität angenommen wurde, und der aufrufende Kontext) wird für die asynchronen Socket Methoden zwischengespeichert.The execution context (the security context, the impersonated user, and the calling context) is cached for the asynchronous Socket methods. Nach der ersten Verwendung eines bestimmten Kontexts (einer bestimmten asynchronen Socket Methode, einer bestimmten Socket Instanz und eines bestimmten Rückrufs) wird bei der nachfolgenden Verwendung dieses Kontexts eine Leistungsverbesserung angezeigt.After the first use of a particular context (a specific asynchronous Socket method, a specific Socket instance, and a specific callback), subsequent uses of that context will see a performance improvement.

Siehe auch

BeginAccept(Socket, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Vorgang, um eine eingehende Verbindung von einem angegebenen Socket anzunehmen, und empfängt den ersten von der Clientanwendung gesendeten Datenblock.Begins an asynchronous operation to accept an incoming connection attempt from a specified socket and receives the first block of data sent by the client application.

public:
 IAsyncResult ^ BeginAccept(System::Net::Sockets::Socket ^ acceptSocket, int receiveSize, AsyncCallback ^ callback, System::Object ^ state);
public IAsyncResult BeginAccept (System.Net.Sockets.Socket acceptSocket, int receiveSize, AsyncCallback callback, object state);
member this.BeginAccept : System.Net.Sockets.Socket * int * AsyncCallback * obj -> IAsyncResult
Public Function BeginAccept (acceptSocket As Socket, receiveSize As Integer, callback As AsyncCallback, state As Object) As IAsyncResult

Parameter

acceptSocket
Socket

Das angenommene Socket-Objekt.The accepted Socket object. Dieser Wert kann null sein.This value may be null.

receiveSize
Int32

Die maximale Anzahl der zu empfangenden Bytes.The maximum number of bytes to receive.

callback
AsyncCallback

Der AsyncCallback-Delegat.The AsyncCallback delegate.

state
Object

Ein Objekt mit Zustandsinformationen für diese Anforderung.An object that contains state information for this request.

Gibt zurück

Ein IAsyncResult, das auf die asynchrone Socket-Objekterstellung verweist.An IAsyncResult object that references the asynchronous Socket object creation.

Ausnahmen

Das Socket-Objekt wurde geschlossen.The Socket object has been closed.

Für diese Methode ist Windows NT erforderlich.Windows NT is required for this method.

Der annehmende Socket überwacht keine Verbindungen.The accepting socket is not listening for connections. Vor dem Aufruf von Bind(EndPoint) müssen Sie Listen(Int32) und BeginAccept(AsyncCallback, Object) aufrufen.You must call Bind(EndPoint) and Listen(Int32) before calling BeginAccept(AsyncCallback, Object).

- oder --or- Der angenommene Socket ist gebunden.The accepted socket is bound.

receiveSize ist kleiner als 0.receiveSize is less than 0.

Fehler beim Versuch, auf den Socket zuzugreifen.An error occurred when attempting to access the socket.

Beispiele

Im folgenden Codebeispiel wird ein Socket geöffnet und eine asynchrone Verbindung akzeptiert.The following code example opens a socket and accepts an asynchronous connection. In diesem Beispiel akzeptiert der Socket die anfänglichen 10 Bytes an Daten, und der acceptSocket-Parameter ist null, wodurch die BeginAccept-Methode gezwungen wird, den akzeptierten Socket zu erstellen.In this example, the socket accepts the initial 10 bytes of data and the acceptSocket parameter is null, which forces the BeginAccept method to create the accepted socket. Die Anzahl der empfangenen Bytes und die Daten werden vom Rückruf Delegaten in der Konsole angezeigt.The number of bytes received and the data are displayed on the console by the callback delegate. Unter BeginReceive finden Sie eine Beschreibung, wie die verbleibenden Daten empfangen werden.See BeginReceive for a description of how the remaining data is received.

   // This server waits for a connection and then uses asynchronous operations to
   // accept the connection with initial data sent from the client.
   // Establish the local endpoint for the socket.
   IPHostEntry^ ipHostInfo = Dns::GetHostEntry( Dns::GetHostName() );
   IPAddress^ ipAddress = ipHostInfo->AddressList[ 0 ];
   IPEndPoint^ localEndPoint = gcnew IPEndPoint( ipAddress,11000 );

   // Create a TCP/IP socket.
   Socket^ listener = gcnew Socket( AddressFamily::InterNetwork,SocketType::Stream,ProtocolType::Tcp );

   // Bind the socket to the local endpoint, and listen for incoming connections.
   listener->Bind( localEndPoint );
   listener->Listen( 100 );
   for ( ; ;  )
   {
      // Set the event to nonsignaled state.
      allDone->Reset();

      // Start an asynchronous socket to listen for connections and receive data from the client.
      Console::WriteLine( "Waiting for a connection..." );

      // Accept the connection and receive the first 10 bytes of data. 
      // BeginAccept() creates the accepted socket.
      int receivedDataSize = 10;
      listener->BeginAccept( nullptr, receivedDataSize, gcnew AsyncCallback( AcceptReceiveDataCallback ), listener );

      // Wait until a connection is made and processed before continuing.
      allDone->WaitOne();
   }
}

static void AcceptReceiveDataCallback( IAsyncResult^ ar )
{
   // Get the socket that handles the client request.
   Socket^ listener = dynamic_cast<Socket^>(ar->AsyncState);
   
   // End the operation and display the received data on the console.
   array<Byte>^Buffer;
   int bytesTransferred;
   Socket^ handler = listener->EndAccept( Buffer, bytesTransferred, ar );
   String^ stringTransferred = Encoding::ASCII->GetString( Buffer, 0, bytesTransferred );
   Console::WriteLine( stringTransferred );
   Console::WriteLine( "Size of data transferred is {0}", bytesTransferred );
   
   // Create the state object for the asynchronous receive.
   StateObject^ state = gcnew StateObject;
   state->workSocket = handler;
   handler->BeginReceive( state->buffer, 0, StateObject::BufferSize, static_cast<SocketFlags>(0), gcnew AsyncCallback( ReadCallback ), state );
}

        // This server waits for a connection and then uses asynchronous operations to
        // accept the connection with initial data sent from the client.
                   
        // Establish the local endpoint for the socket.
    
        IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
        IPAddress ipAddress = ipHostInfo.AddressList[0];
        IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

        // Create a TCP/IP socket.
        Socket listener = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp );

        // Bind the socket to the local endpoint, and listen for incoming connections.
        listener.Bind(localEndPoint);
        listener.Listen(100);

        while (true) 
        {
            // Set the event to nonsignaled state.
            allDone.Reset();

            // Start an asynchronous socket to listen for connections and receive data from the client.
            Console.WriteLine("Waiting for a connection...");

            // Accept the connection and receive the first 10 bytes of data. 
            // BeginAccept() creates the accepted socket.
            int receivedDataSize = 10;
            listener.BeginAccept(null, receivedDataSize, new AsyncCallback(AcceptReceiveDataCallback), listener);

            // Wait until a connection is made and processed before continuing.
            allDone.WaitOne();
        }
    }



    public static void AcceptReceiveDataCallback(IAsyncResult ar) 
    {
        // Get the socket that handles the client request.
        Socket listener = (Socket) ar.AsyncState;
        
        // End the operation and display the received data on the console.
        byte[] Buffer;
        int bytesTransferred;
        Socket handler = listener.EndAccept(out Buffer, out bytesTransferred, ar);
        string stringTransferred = Encoding.ASCII.GetString(Buffer, 0, bytesTransferred);

        Console.WriteLine(stringTransferred);
        Console.WriteLine("Size of data transferred is {0}", bytesTransferred);

        // Create the state object for the asynchronous receive.
        StateObject state = new StateObject();
        state.workSocket = handler;
        handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
        new AsyncCallback(ReadCallback), state);
    }

Hinweise

Verbindungs orientierte Protokolle können die BeginAccept-Methode verwenden, um eingehende Verbindungsversuche asynchron zu verarbeiten.Connection-oriented protocols can use the BeginAccept method to asynchronously process incoming connection attempts. Durch die asynchrone Annahme von Verbindungen haben Sie die Möglichkeit, Daten in einem separaten Ausführungs Thread zu senden und zu empfangen.Accepting connections asynchronously gives you the ability to send and receive data within a separate execution thread. Mit dieser Überladung können Sie den akzeptierten Socket im acceptSocket-Parameter angeben.This overload allows you to specify the accepted socket in the acceptSocket parameter. Wenn dieser Parameter nullist, wird der akzeptierte Socket von der BeginAccept-Methode erstellt.If this parameter is null, the accepted socket is created by the BeginAccept method. Sie können die Anzahl der Bytes angeben, die bei der anfänglichen Übertragung im receiveSize-Parameter akzeptiert werden sollen.You can specify the number of bytes to accept in the initial transfer in the receiveSize parameter.

Bevor Sie die BeginAccept-Methode aufrufen, müssen Sie die Listen-Methode aufrufen, um eingehende Verbindungsanforderungen abzuhören und in die Warteschlange zuBefore calling the BeginAccept method, you must call the Listen method to listen for and queue incoming connection requests.

Sie müssen eine Rückruf Methode erstellen, die den AsyncCallback Delegaten implementiert und seinen Namen an die BeginAccept-Methode übergibt.You must create a callback method that implements the AsyncCallback delegate and pass its name to the BeginAccept method. Um dies zu erreichen, müssen Sie das ÜberwachungSocket Objekt an BeginAccept über den state-Parameter übergeben.To do this, at the very minimum, you must pass the listening Socket object to BeginAccept through the state parameter. Wenn Ihr Rückruf Weitere Informationen benötigt, können Sie eine kleine Klasse erstellen, um die Socket und die anderen erforderlichen Informationen zu speichern.If your callback needs more information, you can create a small class to hold the Socket and the other required information. Übergeben Sie mithilfe des state-Parameters eine Instanz dieser Klasse an die BeginAccept-Methode.Pass an instance of this class to the BeginAccept method through the state parameter.

Die Rückruf Methode sollte die EndAccept-Methode aufrufen.Your callback method should invoke the EndAccept method. Wenn die Anwendung BeginAcceptaufruft, verwendet das System in der Regel einen separaten Thread, um die angegebene Rückruf Methode auszuführen und Blöcke auf EndAccept auszuführen, bis eine ausstehende Verbindung abgerufen wird.When your application calls BeginAccept, the system usually uses a separate thread to execute the specified callback method and blocks on EndAccept until a pending connection is retrieved.

EndAccept gibt ein neues Socket-Objekt zurück, das Sie zum Senden und empfangen von Daten mit dem Remote Host verwenden können.EndAccept returns a new Socket object that you can use to send and receive data with the remote host. Sie können dieses zurückgegebene Socket nicht verwenden, um zusätzliche Verbindungen aus der Verbindungs Warteschlange zu akzeptieren.You cannot use this returned Socket to accept any additional connections from the connection queue. Wenn der ursprüngliche Thread blockiert werden soll, nachdem Sie die BeginAccept-Methode aufgerufen haben, verwenden Sie WaitHandle.WaitOne.If you want the original thread to block after you call the BeginAccept method, use WaitHandle.WaitOne. Rufen Sie die Set-Methode für eine ManualResetEvent in der Rückruf Methode auf, wenn der ursprüngliche Thread weiter ausgeführt werden soll.Call the Set method on a ManualResetEvent in the callback method when you want the original thread to continue executing.

Das System kann auch den aufrufenden Thread verwenden, um die Rückruf Methode aufzurufen.The system may also use the calling thread to invoke the callback method. In diesem Fall wird die CompletedSynchronously-Eigenschaft des zurückgegebenen IAsyncResult festgelegt, um anzugeben, dass die BeginAccept-Methode synchron abgeschlossen wurde.In this case, the CompletedSynchronously property on the returned IAsyncResult will be set to indicate that the BeginAccept method completed synchronously.

Weitere Informationen zum Schreiben von Rückruf Methoden finden Sie unter Mars Hallen eines Delegaten als Rückruf Methode.For additional information on writing callback methods, see Marshaling a Delegate as a Callback Method.

Um einen ausstehenden aufzurufenden BeginAccept-Methode abzubrechen, schließen Sie die Socket.To cancel a pending call to the BeginAccept method, close the Socket. Wenn die Close-Methode aufgerufen wird, während ein asynchroner Vorgang ausgeführt wird, wird der Rückruf, der für die BeginAccept-Methode bereitgestellt wird, aufgerufen.When the Close method is called while an asynchronous operation is in progress, the callback provided to the BeginAccept method is called. Bei einem nachfolgenden-Rückruf der EndAccept-Methode wird ein ObjectDisposedException ausgelöst, um anzugeben, dass der Vorgang abgebrochen wurde.A subsequent call to the EndAccept method will throw an ObjectDisposedException to indicate that the operation has been cancelled.

Hinweis

Sie können die RemoteEndPoint-Eigenschaft des zurückgegebenen Socket-Objekts verwenden, um die Netzwerkadresse und die Portnummer des Remote Hosts zu identifizieren.You can use the RemoteEndPoint property of the returned Socket object to identify the remote host's network address and port number.

Hinweis

Wenn Sie erhalten eine SocketException, verwenden die SocketException.ErrorCode Eigenschaft, um den spezifischen Fehlercode zu erhalten.If you receive a SocketException, use the SocketException.ErrorCode property to obtain the specific error code. Nachdem Sie diesen Code abgerufen haben, finden Sie in der API-Fehlercode Dokumentation der Windows Sockets, Version 2 , eine ausführliche Beschreibung des Fehlers.After you have obtained this code, refer to the Windows Sockets version 2 API error code documentation for a detailed description of the error.

Hinweis

Dieser Member gibt Ablaufverfolgungsinformationen aus, wenn Sie die Netzwerkablaufverfolgung in der Anwendung aktivieren.This member outputs trace information when you enable network tracing in your application. Weitere Informationen finden Sie unter Netzwerk Ablauf Verfolgung in der .NET Framework.For more information, see Network Tracing in the .NET Framework.

Hinweis

Der Ausführungs Kontext (der Sicherheitskontext, der Benutzer, dessen Identität angenommen wurde, und der aufrufende Kontext) wird für die asynchronen Socket Methoden zwischengespeichert.The execution context (the security context, the impersonated user, and the calling context) is cached for the asynchronous Socket methods. Nach der ersten Verwendung eines bestimmten Kontexts (einer bestimmten asynchronen Socket Methode, einer bestimmten Socket Instanz und eines bestimmten Rückrufs) wird bei der nachfolgenden Verwendung dieses Kontexts eine Leistungsverbesserung angezeigt.After the first use of a particular context (a specific asynchronous Socket method, a specific Socket instance, and a specific callback), subsequent uses of that context will see a performance improvement.

Siehe auch

Gilt für: