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

Definition

Namespace:

System.Net.Security

Assembly:

System.Net.Security.dll

Quelle:

NegotiateStream.cs

Startet einen asynchronen Lesevorgang, der Daten aus dem Stream liest und im angegebenen Array speichert.

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

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

buffer

Byte[]

Ein Byte-Array, das die Bytes empfängt, die aus dem Stream gelesen werden.

offset

Int32

Der nullbasierte Speicherort im buffer, ab dem die aus diesem Stream gelesenen Daten gespeichert werden.

count

Int32

Die maximale Anzahl an Bytes, die aus dem Stream gelesen werden sollen.

asyncCallback

AsyncCallback

Ein AsyncCallback-Delegat, der auf die Methode verweist, die aufgerufen wird, wenn der Lesevorgang beendet ist.

asyncState

Object

Ein benutzerdefiniertes Objekt, das Informationen zum Lesevorgang enthält. Dieses Objekt wird bei Abschluss des Vorgangs an den asyncCallback-Delegaten übergeben.

Gibt zurück

IAsyncResult

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

Ausnahmen

ArgumentNullException

buffer ist null.

ArgumentException

offset ist kleiner als 0.

- oder -

offset ist größer als die Länge von buffer.

- oder -

offset plus count ist größer als die Länge von buffer.

IOException

Fehler beim Lesevorgang.

- oder -

Die Verschlüsselung wird verwendet, die Daten konnten jedoch nicht entschlüsselt werden.

NotSupportedException

Es wird bereits ein Lesevorgang ausgeführt.

ObjectDisposedException

Dieses Objekt wurde geschlossen.

InvalidOperationException

Es ist keine Authentifizierung erfolgt.

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.