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

Definice

Obor názvů:

System.Net.Security

Sestavení:

System.Net.Security.dll

Zdroj:

NegotiateStream.cs

Spustí asynchronní operaci čtení, která čte data ze streamu a uloží je do zadaného pole.

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

Parametry

buffer

Byte[]

Pole Byte , které přijímá bajty načtené z datového proudu.

offset

Int32

Umístění založené na nule, do buffer kterého chcete začít ukládat data načtená z tohoto datového proudu.

count

Int32

Maximální počet bajtů, které se mají číst ze streamu.

asyncCallback

AsyncCallback

Delegát AsyncCallback , který odkazuje na metodu, která se má vyvolat po dokončení operace čtení.

asyncState

Object

Objekt definovaný uživatelem obsahující informace o operaci čtení. Tento objekt se po dokončení operace předá asyncCallback delegátu.

Návraty

IAsyncResult

Objekt IAsyncResult označující stav asynchronní operace.

Výjimky

ArgumentNullException

buffer je null.

ArgumentException

offset je menší než 0.

-nebo-

offsetje větší než délka .buffer

-nebo-

offsetplus count je větší než délka .buffer

IOException

Operace čtení se nezdařila.

-nebo-

Šifrování se používá, ale data nelze dešifrovat.

NotSupportedException

Operace čtení již probíhá.

ObjectDisposedException

Tento objekt byl uzavřen.

InvalidOperationException

K ověření nedošlo.

Příklady

Následující příklad kódu ukazuje spuštění asynchronní operace čtení. Tento příklad kódu je součástí většího příkladu NegotiateStream pro třídu.

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

Poznámky

Pokud je povolené šifrování, podepisování nebo šifrování a podepisování, operace čtení přečte data z podkladového datového proudu, zkontroluje integritu dat a dešifruje je. Pokud se nepoužívají žádné služby zabezpečení, jako je šifrování dat nebo podepisování, spustí tato metoda asynchronní operaci čtení v podkladovém datovém proudu.

Tato metoda je asynchronní a během dokončení operace neblokuje. Pokud chcete blokovat, dokud se operace neskoní, použijte metodu Read .

Asynchronní operace čtení musí být dokončena voláním EndRead metody . Obvykle je metoda vyvolána delegátem asyncCallback . Podrobné informace o použití asynchronního programovacího modelu najdete v tématu Asynchronní volání synchronních metod.

Třída NegotiateStream nepodporuje více souběžných operací čtení. Pokud se pokusíte spustit operaci čtení, zatímco ve stejném datovém proudu již probíhá jiná operace čtení, NotSupportedException vyvolá se výjimka.

Tuto metodu nelze volat, dokud se úspěšně neověříte. Pokud chcete provést ověření, zavolejte jednu z AuthenticateAsClientmetod , AuthenticateAsClientAsyncBeginAuthenticateAsClient, AuthenticateAsServer, AuthenticateAsServerAsync, nebo BeginAuthenticateAsServer .