NegotiateStream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) Methode

public:
 override IAsyncResult ^ BeginRead(cli::array <System::Byte> ^ buffer, int offset, int count, AsyncCallback ^ asyncCallback, System::Object ^ asyncState);

public override IAsyncResult BeginRead (byte[] buffer, int offset, int count, AsyncCallback? asyncCallback, object? asyncState);

public override IAsyncResult BeginRead (byte[] buffer, int offset, int count, AsyncCallback asyncCallback, object asyncState);

override this.BeginRead : byte[] * int * int * AsyncCallback * obj -> IAsyncResult

Public Overrides Function BeginRead (buffer As Byte(), offset As Integer, count As Integer, asyncCallback As AsyncCallback, asyncState As Object) As IAsyncResult

Parameter

Gibt zurück

Ein IAsyncResult-Objekt, das den Status des asynchronen Vorgangs angibt.

Ausnahmen

Beispiele

Im folgenden Codebeispiel wird das Starten eines asynchronen Lesevorgangs veranschaulicht. Dieses Codebeispiel ist Teil eines größeren Beispiels, das für die NegotiateStream-Klasse bereitgestellt wird.

static void AuthenticateClient( TcpClient^ clientRequest )
{
   NetworkStream^ stream = clientRequest->GetStream();
   
   // Create the NegotiateStream.
   NegotiateStream^ authStream = gcnew NegotiateStream( stream,false );
   
   // Save the current client and NegotiateStream instance 
   // in a ClientState object.
   ClientState^ cState = gcnew ClientState( authStream,clientRequest );
   
   // Listen for the client authentication request.
   authStream->BeginAuthenticateAsServer( gcnew AsyncCallback( EndAuthenticateCallback ), cState );
   
   // Wait until the authentication completes.
   cState->Waiter->WaitOne();
   cState->Waiter->Reset();
   authStream->BeginRead( cState->Buffer, 0, cState->Buffer->Length, gcnew AsyncCallback( EndReadCallback ), cState );
   cState->Waiter->WaitOne();
   
   // Finished with the current client.
   authStream->Close();
   clientRequest->Close();
}

public static void AuthenticateClient(TcpClient clientRequest)
{
    NetworkStream stream = clientRequest.GetStream();
    // Create the NegotiateStream.
    NegotiateStream authStream = new NegotiateStream(stream, false);
    // Save the current client and NegotiateStream instance
    // in a ClientState object.
    ClientState cState = new ClientState(authStream, clientRequest);
    // Listen for the client authentication request.
    Task authTask = authStream
        .AuthenticateAsServerAsync()
        .ContinueWith(task => { EndAuthenticateCallback(cState); });

    // Any exceptions that occurred during authentication are
    // thrown by the EndAuthenticateAsServer method.
    try
    {
        // This call blocks until the authentication is complete.
        authTask.Wait();
    }
    catch (AuthenticationException e)
    {
        Console.WriteLine(e);
        Console.WriteLine("Authentication failed - closing connection.");
        return;
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
        Console.WriteLine("Closing connection.");
        return;
    }

    Task<int> readTask = authStream
        .ReadAsync(cState.Buffer, 0, cState.Buffer.Length);

    readTask
        .ContinueWith((task) => { EndReadCallback(cState, task.Result); })
        .Wait();
    // Finished with the current client.
    authStream.Close();
    clientRequest.Close();
}

Hinweise

Wenn Verschlüsselung, Signatur oder Verschlüsselung und Signatur aktiviert sind, liest der Lesevorgang die Daten aus dem zugrunde liegenden Stream, überprüft die Integrität der Daten und entschlüsselt sie. Wenn keine Sicherheitsdienste wie Datenverschlüsselung oder Signatur verwendet werden, startet diese Methode einen asynchronen Lesevorgang für den zugrunde liegenden Stream.

Diese Methode ist asynchron und blockiert nicht, während der Vorgang abgeschlossen ist. Verwenden Sie die -Methode, um zu blockieren, bis der Read Vorgang abgeschlossen ist.

Der asynchrone Lesevorgang muss durch Aufrufen der EndRead -Methode abgeschlossen werden. In der Regel wird die -Methode vom asyncCallback Delegaten aufgerufen. Ausführliche Informationen zur Verwendung des asynchronen Programmiermodells finden Sie unter Asynchrones Aufrufen synchroner Methoden.

Die NegotiateStream -Klasse unterstützt keine gleichzeitigen Lesevorgänge. Wenn Sie versuchen, einen Lesevorgang zu starten, während bereits ein anderer Lesevorgang für denselben Stream ausgeführt wird, wird eine NotSupportedException Ausnahme ausgelöst.

Sie können diese Methode erst aufrufen, wenn Sie sich erfolgreich authentifiziert haben. Rufen Sie zum Authentifizieren eine der AuthenticateAsClientMethoden , AuthenticateAsClientAsync, BeginAuthenticateAsClient, AuthenticateAsServer, AuthenticateAsServerAsyncoder BeginAuthenticateAsServer auf.

Gilt für: