NegotiateStream Classe

Definição

Fornece um fluxo que usa o protocolo de segurança Negotiate para autenticar o cliente e, opcionalmente, o servidor, em comunicações entre o cliente e o servidor.Provides a stream that uses the Negotiate security protocol to authenticate the client, and optionally the server, in client-server communication.

public ref class NegotiateStream : System::Net::Security::AuthenticatedStream
public class NegotiateStream : System.Net.Security.AuthenticatedStream
type NegotiateStream = class
    inherit AuthenticatedStream
Public Class NegotiateStream
Inherits AuthenticatedStream
Herança
Herança

Exemplos

O exemplo a seguir demonstra o lado do cliente de uma conexão cliente-servidor que usa o NegotiateStream .The following example demonstrates the client side of a client-server connection that uses the NegotiateStream. O cliente autentica e envia uma mensagem para o servidor de forma assíncrona.The client authenticates and sends a message to the server asynchronously.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Text;

// The following class displays the properties of an authenticatedStream.
public ref class AuthenticatedStreamReporter
{
public:
   static void DisplayProperties( AuthenticatedStream^ stream )
   {
      Console::WriteLine( L"IsAuthenticated: {0}", stream->IsAuthenticated );
      Console::WriteLine( L"IsMutuallyAuthenticated: {0}", stream->IsMutuallyAuthenticated );
      Console::WriteLine( L"IsEncrypted: {0}", stream->IsEncrypted );
      Console::WriteLine( L"IsSigned: {0}", stream->IsSigned );
      Console::WriteLine( L"IsServer: {0}", stream->IsServer );
   }

};


public ref class ASynchronousAuthenticatingTcpClient
{
private:
   static TcpClient^ client = nullptr;

public:
   void Main()
   {
      
      // Establish the remote endpoint for the socket.
      // For this example, use the local machine.
      IPHostEntry^ ipHostInfo = Dns::GetHostEntry( Dns::GetHostName() );
      IPAddress^ ipAddress = ipHostInfo->AddressList[ 0 ];
      
      // Client and server use port 11000. 
      IPEndPoint^ remoteEP = gcnew IPEndPoint( ipAddress,11000 );
      
      // Create a TCP/IP socket.
      client = gcnew TcpClient;
      
      // Connect the socket to the remote endpoint.
      client->Connect( remoteEP );
      Console::WriteLine( L"Client connected to {0}.", remoteEP );
      
      // Ensure the client does not close when there is 
      // still data to be sent to the server.
      client->LingerState = (gcnew LingerOption( true,0 ));
      
      // Request authentication.
      NetworkStream^ clientStream = client->GetStream();
      NegotiateStream^ authStream = gcnew NegotiateStream( clientStream,false );
      
      // Pass the NegotiateStream as the AsyncState object 
      // so that it is available to the callback delegate.
      IAsyncResult^ ar = authStream->BeginAuthenticateAsClient( gcnew AsyncCallback( EndAuthenticateCallback ), authStream );
      
      Console::WriteLine( L"Client waiting for authentication..." );
      
      // Wait until the result is available.
      ar->AsyncWaitHandle->WaitOne();
      
      // Display the properties of the authenticated stream.
      AuthenticatedStreamReporter::DisplayProperties( authStream );
      
      // Send a message to the server.
      // Encode the test data into a byte array.
      array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the client." );
      ar = authStream->BeginWrite( message, 0, message->Length, gcnew AsyncCallback( EndWriteCallback ), authStream );
      
      ar->AsyncWaitHandle->WaitOne();
      Console::WriteLine( L"Sent {0} bytes.", message->Length );
      
      // Close the client connection.
      authStream->Close();
      Console::WriteLine( L"Client closed." );
   }


   // The following method is called when the authentication completes.
   static void EndAuthenticateCallback( IAsyncResult^ ar )
   {
      Console::WriteLine( L"Client ending authentication..." );
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(ar->AsyncState);
      
      // End the asynchronous operation.
      authStream->EndAuthenticateAsClient( ar );
      
      //         Console.WriteLine("AllowedImpersonation: {0}", authStream.AllowedImpersonation);
   }


   // The following method is called when the write operation completes.
   static void EndWriteCallback( IAsyncResult^ ar )
   {
      Console::WriteLine( L"Client ending write operation..." );
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(ar->AsyncState);
      
      // End the asynchronous operation.
      authStream->EndWrite( ar );
   }

};

void main()
{
   ASynchronousAuthenticatingTcpClient^ aatc = gcnew ASynchronousAuthenticatingTcpClient;
   aatc->Main();
}
using System;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Text;

namespace Examples.NegotiateStreamExample
{
    public class ASynchronousAuthenticatingTcpClient
    {
        static TcpClient client = null;

        public static void Main(String[] args)
        {
            // Establish the remote endpoint for the socket.
            // For this example, use the local machine.
            IPHostEntry ipHostInfo = Dns.GetHostEntry("localhost");
            IPAddress ipAddress = ipHostInfo.AddressList[0];
            // Client and server use port 11000.
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);
            // Create a TCP/IP socket.
            client = new TcpClient();
            // Connect the socket to the remote endpoint.
            client.Connect(remoteEP);
            Console.WriteLine("Client connected to {0}.", remoteEP.ToString());
            // Ensure the client does not close when there is
            // still data to be sent to the server.
            client.LingerState = new LingerOption(true, 0);
            // Request authentication.
            NetworkStream clientStream = client.GetStream();
            NegotiateStream authStream = new NegotiateStream(clientStream, false);
            // Pass the NegotiateStream as the AsyncState object
            // so that it is available to the callback delegate.
            Task authenticateTask = authStream
                .AuthenticateAsClientAsync()
                .ContinueWith(task =>
                {
                    Console.WriteLine("Client ending authentication...");
                    Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel);
                });

            Console.WriteLine("Client waiting for authentication...");
            // Wait until the result is available.
            authenticateTask.Wait();
            // Display the properties of the authenticated stream.
            AuthenticatedStreamReporter.DisplayProperties(authStream);
            // Send a message to the server.
            // Encode the test data into a byte array.
            byte[] message = Encoding.UTF8.GetBytes("Hello from the client.");
            Task writeTask = authStream
                .WriteAsync(message, 0, message.Length)
                .ContinueWith(task =>
                {
                    Console.WriteLine("Client ending write operation...");
                });

            writeTask.Wait();
            Console.WriteLine("Sent {0} bytes.", message.Length);
            // Close the client connection.
            authStream.Close();
            Console.WriteLine("Client closed.");
        }
    }

    // The following class displays the properties of an authenticatedStream.
    public class AuthenticatedStreamReporter
    {
        public static void DisplayProperties(AuthenticatedStream stream)
        {
            Console.WriteLine("IsAuthenticated: {0}", stream.IsAuthenticated);
            Console.WriteLine("IsMutuallyAuthenticated: {0}", stream.IsMutuallyAuthenticated);
            Console.WriteLine("IsEncrypted: {0}", stream.IsEncrypted);
            Console.WriteLine("IsSigned: {0}", stream.IsSigned);
            Console.WriteLine("IsServer: {0}", stream.IsServer);
        }
    }
}
Imports System.Text
Imports System.Net.Sockets
Imports System.Net.Security
Imports System.Net

Namespace Examples.NegotiateStreamExample

    Public Class ASynchronousAuthenticatingTcpClient

        Shared client As TcpClient = Nothing

        Public Shared Sub Main(args As String())
            ' Establish the remote endpoint for the socket.
            ' For this example, use the local machine.
            Dim ipHostInfo = Dns.GetHostEntry("localhost")
            Dim ipAddress = ipHostInfo.AddressList(0)

            ' Client and server use port 11000. 
            Dim remoteEP As New IPEndPoint(ipAddress, 11000)

            ' Create a TCP/IP socket.
            client = New TcpClient()

            ' Connect the socket to the remote endpoint.
            client.Connect(remoteEP)
            Console.WriteLine("Client connected to {0}.", remoteEP.ToString())

            ' Ensure the client does not close when there is 
            ' still data to be sent to the server.
            client.LingerState = (New LingerOption(True, 0))

            ' Request authentication.
            Dim clientStream = client.GetStream()
            Dim authStream As New NegotiateStream(clientStream, False)

            ' Pass the NegotiateStream as the AsyncState object 
            ' so that it is available to the callback delegate.
            Dim ar = authStream.BeginAuthenticateAsClient(
                New AsyncCallback(AddressOf EndAuthenticateCallback), authStream)

            Console.WriteLine("Client waiting for authentication...")

            ' Wait until the result is available.
            ar.AsyncWaitHandle.WaitOne()

            ' Display the properties of the authenticated stream.
            AuthenticatedStreamReporter.DisplayProperties(authStream)

            ' Send a message to the server.
            ' Encode the test data into a byte array.
            Dim message = Encoding.UTF8.GetBytes("Hello from the client.")
            ar = authStream.BeginWrite(message, 0, message.Length, 
                New AsyncCallback(AddressOf EndWriteCallback), authStream)
            ar.AsyncWaitHandle.WaitOne()
            Console.WriteLine("Sent {0} bytes.", message.Length)

            ' Close the client connection.
            authStream.Close()
            Console.WriteLine("Client closed.")

        End Sub

        ' The following method is called when the authentication completes.
        Public Shared Sub EndAuthenticateCallback(ar As IAsyncResult)

            Console.WriteLine("Client ending authentication...")
            Dim authStream = CType(ar.AsyncState, NegotiateStream)
            Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel)

            ' End the asynchronous operation.
            authStream.EndAuthenticateAsClient(ar)

        End Sub

        ' The following method is called when the write operation completes.
        Public Shared Sub EndWriteCallback(ar As IAsyncResult)

            Console.WriteLine("Client ending write operation...")
            Dim authStream = CType(ar.AsyncState, NegotiateStream)

            ' End the asynchronous operation.
            authStream.EndWrite(ar)

        End Sub
    End Class

    ' The following class displays the properties of an AuthenticatedStream.
    Public Class AuthenticatedStreamReporter
        Public Shared Sub DisplayProperties(stream As AuthenticatedStream)
            Console.WriteLine("IsAuthenticated: {0}", stream.IsAuthenticated)
            Console.WriteLine("IsMutuallyAuthenticated: {0}", stream.IsMutuallyAuthenticated)
            Console.WriteLine("IsEncrypted: {0}", stream.IsEncrypted)
            Console.WriteLine("IsSigned: {0}", stream.IsSigned)
            Console.WriteLine("IsServer: {0}", stream.IsServer)
        End Sub
    End Class
End Namespace

O exemplo de código a seguir demonstra o lado do servidor de uma conexão cliente-servidor que usa o NegotiateStream para autenticar o cliente e ler uma mensagem enviada pelo cliente.The following code example demonstrates the server side of a client-server connection that uses the NegotiateStream to authenticate the client and read a message sent by the client.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Security::Authentication;
using namespace System::Security::Principal;
using namespace System::Text;
using namespace System::IO;
using namespace System::Threading;

// ClientState is the AsyncState object.
private ref class ClientState
{
private:
   AuthenticatedStream^ authStream;
   TcpClient^ client;
   array<Byte>^buffer;
   StringBuilder^ message;
   ManualResetEvent^ waiter;

internal:
   ClientState( AuthenticatedStream^ a, TcpClient^ theClient )
   {
      authStream = a;
      client = theClient;
      message = nullptr;
      buffer = gcnew array<Byte>(2048);
      waiter = gcnew ManualResetEvent( false );
   }

internal:
   property TcpClient^ Client 
   {
      TcpClient^ get()
      {
         return client;
      }
   }

   property AuthenticatedStream^ AuthStream 
   {
      AuthenticatedStream^ get()
      {
         return authStream;
      }
  }

   property array<Byte>^ Buffer 
   {
      array<Byte>^ get()
      {
         return buffer;
      }

   }

   property StringBuilder^ Message 
   {
      StringBuilder^ get()
      {
         if ( message == nullptr )
                  message = gcnew StringBuilder;

         return message;
      }

   }

   property ManualResetEvent^ Waiter 
   {
      ManualResetEvent^ get()
      {
         return waiter;
      }

   }

};

public ref class AsynchronousAuthenticatingTcpListener
{
public:
   int Main()
   {
      
      // Create an IPv4 TCP/IP socket. 
      TcpListener^ listener = gcnew TcpListener( IPAddress::Any,11000 );
      
      // Listen for incoming connections.
      listener->Start();
      while ( true )
      {
         TcpClient^ clientRequest = nullptr;
         
         // Application blocks while waiting for an incoming connection.
         // Type CNTL-C to terminate the server.
         clientRequest = listener->AcceptTcpClient();
         Console::WriteLine( L"Client connected." );
         
         // A client has connected. 
         try
         {
            AuthenticateClient( clientRequest );
         }
         catch ( Exception^ e ) 
         {
            Console::WriteLine( e );
            continue;
         }

      }
   }


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


   // The following method is invoked by the
   // BeginServerAuthenticate callback delegate.
   static void EndAuthenticateCallback( IAsyncResult^ ar )
   {
      
      // Get the saved data.
      ClientState^ cState = dynamic_cast<ClientState^>(ar->AsyncState);
      TcpClient^ clientRequest = cState->Client;
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(cState->AuthStream);
      Console::WriteLine( L"Ending authentication." );
      
      // Any exceptions that occurred during authentication are
      // thrown by the EndServerAuthenticate method.
      try
      {
         
         // This call blocks until the authentication is complete.
         authStream->EndAuthenticateAsServer( ar );
      }
      catch ( AuthenticationException^ e ) 
      {
         Console::WriteLine( e );
         Console::WriteLine( L"Authentication failed - closing connection." );
         cState->Waiter->Set();
         return;
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e );
         Console::WriteLine( L"Closing connection." );
         cState->Waiter->Set();
         return;
      }

      
      // Display properties of the authenticated client.
      IIdentity^ id = authStream->RemoteIdentity;
      Console::WriteLine( L"{0} was authenticated using {1}.", id->Name, id->AuthenticationType );
      cState->Waiter->Set();
   }


   static void EndReadCallback( IAsyncResult^ ar )
   {
      
      // Get the saved data.
      ClientState^ cState = dynamic_cast<ClientState^>(ar->AsyncState);
      TcpClient^ clientRequest = cState->Client;
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(cState->AuthStream);
      
      // Get the buffer that stores the message sent by the client.
      int bytes = -1;
      
      // Read the client message.
      try
      {
         bytes = authStream->EndRead( ar );
         cState->Message->Append( Encoding::UTF8->GetChars( cState->Buffer, 0, bytes ) );
         if ( bytes != 0 )
         {
            authStream->BeginRead( cState->Buffer, 0, cState->Buffer->Length, gcnew AsyncCallback( EndReadCallback ), cState );
            return;
         }
      }
      catch ( Exception^ e ) 
      {
         
         // A real application should do something
         // useful here, such as logging the failure.
         Console::WriteLine( L"Client message exception:" );
         Console::WriteLine( e );
         cState->Waiter->Set();
         return;
      }

      IIdentity^ id = authStream->RemoteIdentity;
      Console::WriteLine( L"{0} says {1}", id->Name, cState->Message );
      cState->Waiter->Set();
   }

};

void main()
{
   AsynchronousAuthenticatingTcpListener^ aatl = gcnew AsynchronousAuthenticatingTcpListener;
   aatl->Main();
}

using System;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Security.Principal;
using System.Text;
using System.IO;
using System.Threading;

namespace Examples.NegotiateStreamExample
{
    public class AsynchronousAuthenticatingTcpListener
    {
        public static void Main()
        {
            // Create an IPv4 TCP/IP socket.
            TcpListener listener = new TcpListener(IPAddress.Any, 11000);
            // Listen for incoming connections.
            listener.Start();
            while (true)
            {
                TcpClient clientRequest;
                // Application blocks while waiting for an incoming connection.
                // Type CNTL-C to terminate the server.
                clientRequest = listener.AcceptTcpClient();
                Console.WriteLine("Client connected.");
                // A client has connected.
                try
                {
                    AuthenticateClient(clientRequest);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            }
        }

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

        private static void EndAuthenticateCallback(ClientState cState)
        {
            // Get the saved data.
            NegotiateStream authStream = (NegotiateStream)cState.AuthenticatedStream;
            Console.WriteLine("Ending authentication.");

            // Display properties of the authenticated client.
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} was authenticated using {1}.",
                id.Name,
                id.AuthenticationType
            );
        }

        private static void EndReadCallback(ClientState cState, int bytes)
        {
            NegotiateStream authStream = (NegotiateStream)cState.AuthenticatedStream;
            // Read the client message.
            try
            {
                cState.Message.Append(Encoding.UTF8.GetChars(cState.Buffer, 0, bytes));
                if (bytes != 0)
                {
                    Task<int> readTask = authStream.ReadAsync(cState.Buffer, 0, cState.Buffer.Length);
                    readTask
                        .ContinueWith(task => { EndReadCallback(cState, task.Result); })
                        .Wait();

                    return;
                }
            }
            catch (Exception e)
            {
                // A real application should do something
                // useful here, such as logging the failure.
                Console.WriteLine("Client message exception:");
                Console.WriteLine(e);
                return;
            }
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} says {1}", id.Name, cState.Message.ToString());
        }
    }
    // ClientState is the AsyncState object.
    internal class ClientState
    {
        private StringBuilder _message = null;

        internal ClientState(AuthenticatedStream a, TcpClient theClient)
        {
            AuthenticatedStream = a;
            Client = theClient;
        }
        internal TcpClient Client { get; }

        internal AuthenticatedStream AuthenticatedStream { get; }

        internal byte[] Buffer { get; } = new byte[2048];

        internal StringBuilder Message
        {
            get { return _message ??= new StringBuilder(); }
        }
    }
}

Comentários

Use a NegotiateStream classe para autenticação e para ajudar a proteger as informações transmitidas entre um cliente e um servidor.Use the NegotiateStream class for authentication and to help secure information transmitted between a client and a server. Usando NegotiateStream o, você pode fazer o seguinte.Using NegotiateStream, you can do the following.

  • Envie as credenciais do cliente para o servidor para representação ou delegação.Send the client's credentials to the server for Impersonation or Delegation.

  • Solicitar autenticação do servidor.Request server authentication.

  • Criptografe e/ou assine os dados antes de transmiti-los.Encrypt and/or sign data before transmitting it.

A autenticação deve ser executada antes de transmitir informações.Authentication must be performed before transmitting information. Os clientes solicitam autenticação usando os métodos síncronos AuthenticateAsClient , que são bloqueados até que a autenticação seja concluída, ou os métodos assíncronos BeginAuthenticateAsClient , que não são bloqueados enquanto aguarda a conclusão da autenticação.Clients request authentication using the synchronous AuthenticateAsClient methods, which block until the authentication completes, or the asynchronous BeginAuthenticateAsClient methods, which do not block while waiting for the authentication to complete. Os servidores solicitam autenticação usando os métodos síncronos AuthenticateAsServer ou assíncronos BeginAuthenticateAsServer .Servers request authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. O cliente e, opcionalmente, o servidor, é autenticado usando o protocolo Negotiate Security.The client, and optionally the server, is authenticated using the Negotiate security protocol. Em sistemas Windows 95/98, o Windows NT LAN Manager (NTLM) é o protocolo usado para autenticação.On Windows 95/98 systems, Windows NT LAN Manager (NTLM) is the protocol used for authentication. Em outras plataformas, o protocolo Kerberos é usado para autenticação se o cliente e o servidor dão suporte a ele; caso contrário, o NTLM será usado.On other platforms the Kerberos protocol is used for authentication if both client and server support it; otherwise NTLM is used. Para obter descrições detalhadas desses protocolos, consulte a documentação do Platform SDK no MSDN, em msdn.microsoft.com/library/.For detailed descriptions of these protocols, see the Platform SDK documentation on MSDN, at msdn.microsoft.com/library/. A NegotiateStream classe executa a autenticação usando a interface de provedor de suporte de segurança (SSPI).The NegotiateStream class performs the authentication using the Security Support Provider Interface (SSPI).

Quando a autenticação é realizada com sucesso, você deve verificar as IsEncrypted IsSigned Propriedades e para determinar quais serviços de segurança serão usados pelo NegotiateStream para ajudar a proteger seus dados durante a transmissão.When authentication succeeds, you must check the IsEncrypted and IsSigned properties to determine what security services will be used by the NegotiateStream to help secure your data during transmission. Verifique a IsMutuallyAuthenticated propriedade para determinar se a autenticação mútua ocorreu.Check the IsMutuallyAuthenticated property to determine whether mutual authentication occurred. Você pode obter informações sobre o cliente ou servidor remoto usando a RemoteIdentity propriedade.You can get information about the remote client or server using the RemoteIdentity property.

Se a autenticação falhar, você receberá um AuthenticationException ou um InvalidCredentialException .If the authentication fails, you will receive an AuthenticationException or a InvalidCredentialException. Nesse caso, você pode repetir a autenticação com uma credencial diferente.In this case, you can retry the authentication with a different credential.

Você envia dados usando os métodos síncronos Write ou assíncronos BeginWrite WriteAsync .You send data using the synchronous Write or asynchronous BeginWrite or WriteAsync methods. Você recebe dados usando os métodos síncronos Read ou assíncronos ReadAsync BeginRead .You receive data using the synchronous Read or asynchronous ReadAsync or BeginRead methods. Se os serviços de segurança, como criptografia ou assinatura, estiverem habilitados, eles serão aplicados automaticamente aos seus dados pelo NegotiateStream .If security services such as encryption or signing are enabled, these are automatically applied to your data by the NegotiateStream.

O NegotiateStream transmite dados usando um fluxo que você fornece ao criar o NegotiateStream .The NegotiateStream transmits data using a stream that you supply when creating the NegotiateStream. Ao fornecer esse fluxo subjacente, você tem a opção de especificar se fechar o NegotiateStream também fecha o fluxo subjacente.When you supply this underlying stream, you have the option to specify whether closing the NegotiateStream also closes the underlying stream.

Construtores

NegotiateStream(Stream)

Inicializa uma nova instância da classe NegotiateStream usando o Stream especificado.Initializes a new instance of the NegotiateStream class using the specified Stream.

NegotiateStream(Stream, Boolean)

Inicializa uma nova instância da classe NegotiateStream usando o Stream e o comportamento de fechamento de fluxo especificados.Initializes a new instance of the NegotiateStream class using the specified Stream and stream closure behavior.

Propriedades

CanRead

Obtém um valor Boolean que indica se o fluxo subjacente é legível.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

Obtém um valor Boolean que indica se o fluxo subjacente é pesquisável.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

Obtém um valor Boolean que indica se o fluxo subjacente dá suporte a tempos limite.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

Obtém um valor Boolean que indica se o fluxo subjacente é gravável.Gets a Boolean value that indicates whether the underlying stream is writable.

ImpersonationLevel

Obtém um valor que indica como o servidor pode usar as credenciais do cliente.Gets a value that indicates how the server can use the client's credentials.

InnerStream

Obtém o fluxo usado por este AuthenticatedStream para envio e recebimento de dados.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Herdado de AuthenticatedStream)
IsAuthenticated

Obtém um valor Boolean que indica se a autenticação foi bem-sucedida.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

Obtém um valor Boolean que indica se esse NegotiateStream usa criptografia de dados.Gets a Boolean value that indicates whether this NegotiateStream uses data encryption.

IsMutuallyAuthenticated

Obtém um valor Boolean que indica se o servidor e o cliente foram autenticados.Gets a Boolean value that indicates whether both the server and the client have been authenticated.

IsServer

Obtém um valor Boolean que indica se o lado local da conexão usada por esse NegotiateStream foi autenticado como o servidor.Gets a Boolean value that indicates whether the local side of the connection used by this NegotiateStream was authenticated as the server.

IsSigned

Obtém um valor Boolean que indica se os dados enviados usando esse fluxo são assinados.Gets a Boolean value that indicates whether the data sent using this stream is signed.

LeaveInnerStreamOpen

Obtém a indicação de se o fluxo usado por este AuthenticatedStream para envio e recebimento de dados foi deixado aberto.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Herdado de AuthenticatedStream)
Length

Obtém o comprimento do fluxo subjacente.Gets the length of the underlying stream.

Position

Obtém ou define a posição atual no fluxo subjacente.Gets or sets the current position in the underlying stream.

ReadTimeout

Obtém ou define a quantidade de tempo que uma operação de leitura é bloqueada aguardando dados.Gets or sets the amount of time a read operation blocks waiting for data.

RemoteIdentity

Obtém informações sobre a identidade da parte remota compartilhando este fluxo autenticado.Gets information about the identity of the remote party sharing this authenticated stream.

WriteTimeout

Obtém ou define a quantidade de tempo pela qual uma operação de gravação fica bloqueada aguardando dados.Gets or sets the amount of time a write operation blocks waiting for data.

Métodos

AuthenticateAsClient()

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String)

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa a credencial do cliente especificada e a associação de canal.The authentication process uses the specified client credential and the channel binding.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as credenciais especificadas, as opções de autenticação e a associação de canal.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClient(NetworkCredential, String)

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa a credencial de cliente especificada.The authentication process uses the specified client credential.

AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as credenciais e as opções de autenticação especificadas.The authentication process uses the specified credentials and authentication options.

AuthenticateAsClientAsync()

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. O processo de autenticação usa a credencial do cliente especificada e a associação de canal.The authentication process uses the specified client credential and the channel binding.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. O processo de autenticação usa as credenciais especificadas, as opções de autenticação e a associação de canal.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClientAsync(NetworkCredential, String)

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. O processo de autenticação usa a credencial de cliente especificada.The authentication process uses the specified client credential.

AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. O processo de autenticação usa as credenciais e as opções de autenticação especificadas.The authentication process uses the specified credentials and authentication options.

AuthenticateAsServer()

Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by servers to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsServer(ExtendedProtectionPolicy)

Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by servers to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa a política de proteção estendida especificada.The authentication process uses the specified extended protection policy.

AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by servers to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as credenciais de servidor especificadas, as opções de autenticação e a política de proteção estendida.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by servers to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas.The authentication process uses the specified server credentials and authentication options.

AuthenticateAsServerAsync()

Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsServerAsync(ExtendedProtectionPolicy)

Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. O processo de autenticação usa a política de proteção estendida especificada.The authentication process uses the specified extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. O processo de autenticação usa as credenciais de servidor especificadas, as opções de autenticação e a política de proteção estendida.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor como uma operação assíncrona.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas.The authentication process uses the specified server credentials and authentication options.

BeginAuthenticateAsClient(AsyncCallback, Object)

Chamado por clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor em uma conexão cliente-servidor.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Esse método não bloqueia.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)

Chamado por clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor em uma conexão cliente-servidor.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as credenciais e a associação de canal especificadas.The authentication process uses the specified credentials and channel binding. Esse método não bloqueia.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)

Chamado por clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor em uma conexão cliente-servidor.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa a credencial especificada, as opções de autenticação e a associação de canal.The authentication process uses the specified credentials, authentication options, and channel binding. Esse método não bloqueia.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)

Chamado por clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor em uma conexão cliente-servidor.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as credenciais especificadas.The authentication process uses the specified credentials. Esse método não bloqueia.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)

Chamado por clientes para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor em uma conexão cliente-servidor.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as credenciais e as opções de autenticação especificadas.The authentication process uses the specified credentials and authentication options. Esse método não bloqueia.This method does not block.

BeginAuthenticateAsServer(AsyncCallback, Object)

Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Esse método não bloqueia.This method does not block.

BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)

Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa a política de proteção estendida especificada.The authentication process uses the specified extended protection policy. Esse método não bloqueia.This method does not block.

BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)

Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as credenciais de servidor especificadas, as opções de autenticação e a política de proteção estendida.The authentication process uses the specified server credentials, authentication options, and extended protection policy. Esse método não bloqueia.This method does not block.

BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)

Chamado por servidores para iniciar uma operação assíncrona para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas.The authentication process uses the specified server credentials and authentication options. Esse método não bloqueia.This method does not block.

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Inicia uma operação de leitura assíncrona que lê os dados do fluxo e os armazena na matriz especificada.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Inicia uma operação de leitura assíncrona.Begins an asynchronous read operation. (Considere o uso de ReadAsync(Byte[], Int32, Int32) em seu lugar.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Herdado de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Inicia uma operação de gravação assíncrona que grava Bytes do buffer especificado no fluxo.Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Inicia uma operação de gravação assíncrona.Begins an asynchronous write operation. (Considere o uso de WriteAsync(Byte[], Int32, Int32) em seu lugar.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Herdado de Stream)
Close()

Fecha o fluxo atual e libera todos os recursos (como soquetes e identificadores de arquivos) associados ao fluxo atual.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Em vez de chamar esse método, verifique se o fluxo é descartado corretamente.Instead of calling this method, ensure that the stream is properly disposed.

(Herdado de Stream)
CopyTo(Stream)

Lê os bytes do fluxo atual e os grava em outro fluxo.Reads the bytes from the current stream and writes them to another stream.

(Herdado de Stream)
CopyTo(Stream, Int32)

Lê os bytes do fluxo atual e os grava em outro fluxo usando um tamanho do buffer especificado.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Herdado de Stream)
CopyToAsync(Stream)

Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Herdado de Stream)
CopyToAsync(Stream, CancellationToken)

Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo usando um token de cancelamento especificado.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Herdado de Stream)
CopyToAsync(Stream, Int32)

Lê de maneira assíncrona os bytes do fluxo atual e os grava em outro fluxo usando um tamanho do buffer especificado.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Herdado de Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo usando um tamanho do buffer especificado e um token de cancelamento.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Herdado de Stream)
CreateObjRef(Type)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Herdado de MarshalByRefObject)
CreateWaitHandle()
Obsoleto.

Aloca um objeto WaitHandle.Allocates a WaitHandle object.

(Herdado de Stream)
Dispose()

Libera todos os recursos usados pelo Stream.Releases all resources used by the Stream.

(Herdado de Stream)
Dispose(Boolean)

Libera os recursos não gerenciados usados pelo NegotiateStream e opcionalmente libera os recursos gerenciados.Releases the unmanaged resources used by the NegotiateStream and optionally releases the managed resources.

Dispose(Boolean)

Libera os recursos não gerenciados usados pelo AuthenticatedStream e opcionalmente libera os recursos gerenciados.Releases the unmanaged resources used by the AuthenticatedStream and optionally releases the managed resources.

(Herdado de AuthenticatedStream)
DisposeAsync()

Libera de forma assíncrona os recursos gerenciados e não gerenciados usados pelo NegotiateStream.Asynchronously releases the unmanaged and managed resources used by the NegotiateStream.

DisposeAsync()

Libera de forma assíncrona os recursos gerenciados e não gerenciados usados pelo AuthenticatedStream.Asynchronously releases the unmanaged and managed resources used by the AuthenticatedStream.

(Herdado de AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)

Encerra uma operação assíncrona de autenticação de cliente pendente iniciada com uma chamada para BeginAuthenticateAsClient.Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Encerra uma operação assíncrona de autenticação de cliente pendente iniciada com uma chamada para BeginAuthenticateAsServer.Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsServer.

EndRead(IAsyncResult)

Encerra uma operação de leitura assíncrona que foi iniciada com uma chamada para BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).Ends an asynchronous read operation that was started with a call to BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndRead(IAsyncResult)

Espera a leitura assíncrona pendente ser concluída.Waits for the pending asynchronous read to complete. (Considere o uso de ReadAsync(Byte[], Int32, Int32) em seu lugar.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Herdado de Stream)
EndWrite(IAsyncResult)

Encerra uma operação de gravação assíncrona que foi iniciada com uma chamada para BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).Ends an asynchronous write operation that was started with a call to BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult)

Encerra uma operação de gravação assíncrona.Ends an asynchronous write operation. (Considere o uso de WriteAsync(Byte[], Int32, Int32) em seu lugar.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Herdado de Stream)
Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
Flush()

Faz com que os dados armazenados em buffer sejam gravados no dispositivo subjacente.Causes any buffered data to be written to the underlying device.

FlushAsync()

Limpa de forma assíncrona todos os buffers nesse fluxo e faz com que os dados armazenados em buffer sejam gravados no dispositivo subjacente.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Herdado de Stream)
FlushAsync(CancellationToken)

Grava de modo assíncrono todos os dados armazenados em buffer no dispositivo subjacente.Asynchronously writes any buffered data to the underlying device.

FlushAsync(CancellationToken)

Limpa todos os buffers nesse fluxo de forma assíncrona, faz com que os dados armazenados em buffer sejam gravados no dispositivo subjacente e monitora as solicitações de cancelamento.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

(Herdado de Stream)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetLifetimeService()

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Herdado de MarshalByRefObject)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
InitializeLifetimeService()

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.Obtains a lifetime service object to control the lifetime policy for this instance.

(Herdado de MarshalByRefObject)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.Creates a shallow copy of the current MarshalByRefObject object.

(Herdado de MarshalByRefObject)
ObjectInvariant()
Obsoleto.

Oferece suporte a um Contract.Provides support for a Contract.

(Herdado de Stream)
Read(Byte[], Int32, Int32)

Lê os dados desse fluxo e o armazena na matriz especificada.Reads data from this stream and stores it in the specified array.

Read(Span<Byte>)

Quando for substituído em uma classe derivada, lê uma sequência de bytes do fluxo atual e avança a posição dentro do fluxo até o número de bytes lidos.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Herdado de Stream)
ReadAsync(Byte[], Int32, Int32)

Lê uma sequência de bytes do fluxo atual de forma assíncrona e avança a posição no fluxo até o número de bytes lidos.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Herdado de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lê os dados de modo assíncrono desse fluxo e os armazena na matriz especificada.Reads data asynchronously from this stream and stores it in the specified array.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lê de forma assíncrona uma sequência de bytes do fluxo atual, avança a posição no fluxo até o número de bytes lidos e monitora as solicitações de cancelamento.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Herdado de Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Lê dados de modo assíncrono do NegotiateStream e os armazena em um intervalo de memória de bytes como uma operação assíncrona.Reads data asynchronously from the NegotiateStream and stores it in a byte memory range as an asynchronous operation.

ReadAsync(Memory<Byte>, CancellationToken)

Lê de forma assíncrona uma sequência de bytes do fluxo atual, avança a posição no fluxo até o número de bytes lidos e monitora as solicitações de cancelamento.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Herdado de Stream)
ReadByte()

Lê um byte do fluxo e avança a posição no fluxo em um byte ou retorna -1 caso esteja no final do fluxo.Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

(Herdado de Stream)
Seek(Int64, SeekOrigin)

Gera NotSupportedException.Throws NotSupportedException.

SetLength(Int64)

Define o comprimento do fluxo subjacente.Sets the length of the underlying stream.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)
Write(Byte[], Int32, Int32)

Grave o número especificado de Bytes no fluxo subjacente usando o buffer e o deslocamento especificados.Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>)

Quando for substituído em uma classe derivada, grava uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo até o número de bytes gravados.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Herdado de Stream)
WriteAsync(Byte[], Int32, Int32)

Grava assincronamente uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo no número de bytes gravados.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Herdado de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Grava de forma assíncrona o número especificado de Bytes no fluxo subjacente.Write asynchronously the specified number of Bytes to the underlying stream.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Grava uma sequência de bytes no fluxo atual assincronamente, avança a posição atual dentro desse fluxo pelo número de bytes gravados e monitora as solicitações de cancelamento.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Herdado de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Grava de forma assíncrona o número especificado de Bytes no fluxo subjacente.Write asynchronously the specified number of Bytes to the underlying stream.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Grava uma sequência de bytes no fluxo atual assincronamente, avança a posição atual dentro desse fluxo pelo número de bytes gravados e monitora as solicitações de cancelamento.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Herdado de Stream)
WriteByte(Byte)

Grava um byte na posição atual no fluxo e avança a posição dentro no fluxo em um byte.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Herdado de Stream)

Implantações explícitas de interface

IDisposable.Dispose()

Libera todos os recursos usados pelo Stream.Releases all resources used by the Stream.

(Herdado de Stream)

Métodos de Extensão

ConfigureAwait(IAsyncDisposable, Boolean)

Configura como as esperas nas tarefas retornadas de um descartável assíncrono são realizadas.Configures how awaits on the tasks returned from an async disposable are performed.

Aplica-se a

Confira também