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

Definicja

Przestrzeń nazw:

System.Net.Security

Zestaw:

System.Net.Security.dll

Źródło:

NegotiateStream.cs

Rozpoczyna asynchroniczną operację odczytu, która odczytuje dane ze strumienia i zapisuje je w określonej tablicy.

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[]

Tablica Byte , która odbiera bajty odczytane ze strumienia.

offset

Int32

Lokalizacja oparta na zerze, w buffer której należy rozpocząć przechowywanie danych odczytanych ze strumienia.

count

Int32

Maksymalna liczba bajtów do odczytu ze strumienia.

asyncCallback

AsyncCallback

Delegat AsyncCallback , który odwołuje się do metody wywoływania po zakończeniu operacji odczytu.

asyncState

Object

Obiekt zdefiniowany przez użytkownika zawierający informacje o operacji odczytu. Ten obiekt jest przekazywany do delegata po zakończeniu asyncCallback operacji.

Zwraca

IAsyncResult

IAsyncResult Obiekt wskazujący stan operacji asynchronicznej.

Wyjątki

ArgumentNullException

buffer to null.

ArgumentException

offset wartość jest mniejsza niż 0.

-lub-

offsetjest większa niż długość .buffer

-lub-

offset plus count jest większy niż długość buffer.

IOException

Operacja odczytu nie powiodła się.

-lub-

Szyfrowanie jest używane, ale nie można odszyfrować danych.

NotSupportedException

Trwa już operacja odczytu.

ObjectDisposedException

Ten obiekt został zamknięty.

InvalidOperationException

Uwierzytelnianie nie wystąpiło.

Przykłady

Poniższy przykład kodu przedstawia uruchamianie asynchronicznej operacji odczytu. Ten przykład kodu jest częścią większego przykładu udostępnionego NegotiateStream dla klasy .

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

Uwagi

Jeśli włączono szyfrowanie, podpisywanie lub szyfrowanie i podpisywanie, operacja odczytu odczytuje dane ze strumienia bazowego, sprawdza integralność danych i odszyfrowuje je. Jeśli nie są używane żadne usługi zabezpieczeń, takie jak szyfrowanie danych lub logowanie, ta metoda uruchamia asynchroniczną operację odczytu na bazowym strumieniu.

Ta metoda jest asynchroniczna i nie blokuje jej podczas wykonywania operacji. Aby zablokować działanie do momentu zakończenia operacji, użyj Read metody .

Operacja odczytu asynchronicznego musi zostać ukończona przez wywołanie EndRead metody . Zazwyczaj metoda jest wywoływana przez delegata asyncCallback . Aby uzyskać szczegółowe informacje na temat korzystania z modelu programowania asynchronicznego, zobacz Asynchroniczne wywoływanie metod synchronicznych

Klasa NegotiateStream nie obsługuje wielu jednoczesnych operacji odczytu. Jeśli spróbujesz uruchomić operację odczytu, gdy inna operacja odczytu jest już wykonywana na tym samym strumieniu, NotSupportedException zostanie zgłoszony wyjątek.

Nie można wywołać tej metody do momentu pomyślnego uwierzytelnienia. Aby przeprowadzić uwierzytelnianie, wywołaj AuthenticateAsClientjedną z metod , , AuthenticateAsClientAsyncBeginAuthenticateAsClient, AuthenticateAsServer, AuthenticateAsServerAsynclub BeginAuthenticateAsServer .