NegotiateStream Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
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.
public ref class NegotiateStream : System::Net::Security::AuthenticatedStream
public class NegotiateStream : System.Net.Security.AuthenticatedStream
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public class NegotiateStream : System.Net.Security.AuthenticatedStream
type NegotiateStream = class
inherit AuthenticatedStream
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
type NegotiateStream = class
inherit AuthenticatedStream
Public Class NegotiateStream
Inherits AuthenticatedStream
- Herança
- Herança
- Atributos
Exemplos
O exemplo a seguir demonstra o lado do cliente de uma conexão cliente-servidor que usa o NegotiateStream. O cliente autentica e envia uma mensagem ao servidor de forma assíncrona.
#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.
#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. Usando NegotiateStream, você pode fazer o seguinte.
Envie as credenciais do cliente para o servidor para Representação ou Delegação.
Solicitar autenticação de servidor.
Criptografar e/ou assinar dados antes de transmiti-los.
A autenticação deve ser executada antes de transmitir informações. Os clientes solicitam autenticação usando os métodos AuthenticateAsClient síncronos, que bloqueiam até que a autenticação seja concluída ou os métodos assíncronos BeginAuthenticateAsClient , que não bloqueiam enquanto aguardam a conclusão da autenticação. Os servidores solicitam autenticação usando os métodos AuthenticateAsServer síncronos ou assíncronos BeginAuthenticateAsServer . O cliente e, opcionalmente, o servidor, são autenticados usando o protocolo de segurança Negotiate. O protocolo Kerberos será usado para autenticação se o cliente e o servidor derem suporte a ele; caso contrário, NTLM é usado. A NegotiateStream classe executa a autenticação usando a SSPI (Interface do Provedor de Suporte de Segurança).
Quando a autenticação for bem-sucedida, você deverá marcar as IsEncrypted propriedades e IsSigned para determinar quais serviços de segurança serão usados pelo NegotiateStream para ajudar a proteger seus dados durante a transmissão. Verifique a IsMutuallyAuthenticated propriedade para determinar se a autenticação mútua ocorreu. Você pode obter informações sobre o cliente ou servidor remoto usando a RemoteIdentity propriedade .
Se a autenticação falhar, você receberá um AuthenticationException ou um InvalidCredentialException. Nesse caso, você pode repetir a autenticação com uma credencial diferente.
Você envia dados usando os métodos Write síncronos ou assíncronos BeginWrite ou WriteAsync . Você recebe dados usando os métodos Read síncronos ou assíncronos ReadAsync ou BeginRead . Se os serviços de segurança, como criptografia ou assinatura, estiverem habilitados, eles serão aplicados automaticamente aos seus dados pelo NegotiateStream.
O NegotiateStream transmite dados usando um fluxo que você fornece ao criar o NegotiateStream. Ao fornecer esse fluxo subjacente, você tem a opção de especificar se fechar o NegotiateStream também fecha o fluxo subjacente.
Construtores
NegotiateStream(Stream) |
Inicializa uma nova instância da classe NegotiateStream usando o Stream especificado. |
NegotiateStream(Stream, Boolean) |
Inicializa uma nova instância da classe NegotiateStream usando o Stream e o comportamento de fechamento de fluxo especificados. |
Propriedades
CanRead |
Obtém um valor Boolean que indica se o fluxo subjacente é legível. |
CanSeek |
Obtém um valor Boolean que indica se o fluxo subjacente é pesquisável. |
CanTimeout |
Obtém um valor Boolean que indica se o fluxo subjacente dá suporte a tempos limite. |
CanWrite |
Obtém um valor Boolean que indica se o fluxo subjacente é gravável. |
ImpersonationLevel |
Obtém um valor que indica como o servidor pode usar as credenciais do cliente. |
InnerStream |
Obtém o fluxo usado por este AuthenticatedStream para envio e recebimento de dados. (Herdado de AuthenticatedStream) |
IsAuthenticated |
Obtém um valor Boolean que indica se a autenticação foi bem-sucedida. |
IsEncrypted |
Obtém um valor Boolean que indica se esse NegotiateStream usa criptografia de dados. |
IsMutuallyAuthenticated |
Obtém um valor Boolean que indica se o servidor e o cliente foram autenticados. |
IsServer |
Obtém um valor Boolean que indica se o lado local da conexão usada por esse NegotiateStream foi autenticado como o servidor. |
IsSigned |
Obtém um valor Boolean que indica se os dados enviados usando esse fluxo são assinados. |
LeaveInnerStreamOpen |
Obtém a indicação de se o fluxo usado por este AuthenticatedStream para envio e recebimento de dados foi deixado aberto. (Herdado de AuthenticatedStream) |
Length |
Obtém o comprimento do fluxo subjacente. |
Position |
Obtém ou define a posição atual no fluxo subjacente. |
ReadTimeout |
Obtém ou define a quantidade de tempo que uma operação de leitura é bloqueada aguardando dados. |
RemoteIdentity |
Obtém informações sobre a identidade da parte remota compartilhando este fluxo autenticado. |
WriteTimeout |
Obtém ou define a quantidade de tempo pela qual uma operação de gravação fica bloqueada aguardando dados. |
Métodos
AuthenticateAsClient() |
Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. |
AuthenticateAsClient(NetworkCredential, ChannelBinding, String) |
Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. O processo de autenticação usa a credencial do cliente especificada e a associação de canal. |
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel) |
Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. O processo de autenticação usa as credenciais especificadas, as opções de autenticação e a associação de canal. |
AuthenticateAsClient(NetworkCredential, String) |
Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. O processo de autenticação usa a credencial de cliente especificada. |
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel) |
Chamado por clientes para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. O processo de autenticação usa as credenciais e as opções de autenticação especificadas. |
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. |
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. O processo de autenticação usa a credencial do cliente especificada e a associação de canal. |
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. O processo de autenticação usa as credenciais especificadas, as opções de autenticação e a associação de canal. |
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. O processo de autenticação usa a credencial de cliente especificada. |
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. O processo de autenticação usa as credenciais e as opções de autenticação especificadas. |
AuthenticateAsServer() |
Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. |
AuthenticateAsServer(ExtendedProtectionPolicy) |
Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. O processo de autenticação usa a política de proteção estendida especificada. |
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) |
Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. 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. |
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) |
Chamado por servidores para autenticar o cliente e, opcionalmente, o servidor, em uma conexão de cliente-servidor. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas. |
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. |
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. O processo de autenticação usa a política de proteção estendida especificada. |
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. 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. |
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. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas. |
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. Esse método não bloqueia. |
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. O processo de autenticação usa as credenciais e a associação de canal especificadas. Esse método não bloqueia. |
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. O processo de autenticação usa a credencial especificada, as opções de autenticação e a associação de canal. Esse método não bloqueia. |
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. O processo de autenticação usa as credenciais especificadas. Esse método não bloqueia. |
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. O processo de autenticação usa as credenciais e as opções de autenticação especificadas. Esse método não bloqueia. |
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. Esse método não bloqueia. |
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. O processo de autenticação usa a política de proteção estendida especificada. Esse método não bloqueia. |
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. 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. Esse método não bloqueia. |
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. O processo de autenticação usa as opções de autenticação e credenciais de servidor especificadas. Esse método não bloqueia. |
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. |
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Inicia uma operação de leitura assíncrona. (Considere o uso de ReadAsync(Byte[], Int32, Int32) em seu lugar.) (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. |
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Inicia uma operação de gravação assíncrona. (Considere o uso de WriteAsync(Byte[], Int32, Int32) em seu lugar.) (Herdado de Stream) |
Close() |
Fecha o fluxo atual e libera todos os recursos (como soquetes e identificadores de arquivos) associados ao fluxo atual. Em vez de chamar esse método, verifique se o fluxo é descartado corretamente. (Herdado de Stream) |
CopyTo(Stream) |
Lê os bytes do fluxo atual e os grava em outro fluxo. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream) |
CopyTo(Stream, Int32) |
Lê os bytes do fluxo atual e os grava em outro fluxo usando um tamanho do buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream) |
CopyToAsync(Stream) |
Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (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. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (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. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (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. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (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. (Herdado de MarshalByRefObject) |
CreateWaitHandle() |
Obsoleto.
Obsoleto.
Obsoleto.
Aloca um objeto WaitHandle. (Herdado de Stream) |
Dispose() |
Libera todos os recursos usados pelo Stream. (Herdado de Stream) |
Dispose(Boolean) |
Libera os recursos não gerenciados usados pelo NegotiateStream e opcionalmente libera os recursos gerenciados. |
Dispose(Boolean) |
Libera os recursos não gerenciados usados pelo AuthenticatedStream e opcionalmente libera os recursos gerenciados. (Herdado de AuthenticatedStream) |
DisposeAsync() |
Libera de forma assíncrona os recursos gerenciados e não gerenciados usados pelo NegotiateStream. |
DisposeAsync() |
Libera de forma assíncrona os recursos gerenciados e não gerenciados usados pelo AuthenticatedStream. (Herdado de AuthenticatedStream) |
EndAuthenticateAsClient(IAsyncResult) |
Encerra uma operação assíncrona de autenticação de cliente pendente iniciada com uma chamada para BeginAuthenticateAsClient. |
EndAuthenticateAsServer(IAsyncResult) |
Encerra uma operação assíncrona de autenticação de cliente pendente iniciada com uma chamada para BeginAuthenticateAsServer. |
EndRead(IAsyncResult) |
Encerra uma operação de leitura assíncrona que foi iniciada com uma chamada para BeginRead(Byte[], Int32, Int32, AsyncCallback, Object). |
EndRead(IAsyncResult) |
Espera a leitura assíncrona pendente ser concluída. (Considere o uso de ReadAsync(Byte[], Int32, Int32) em seu lugar.) (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). |
EndWrite(IAsyncResult) |
Encerra uma operação de gravação assíncrona. (Considere o uso de WriteAsync(Byte[], Int32, Int32) em seu lugar.) (Herdado de Stream) |
Equals(Object) |
Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object) |
Flush() |
Faz com que os dados armazenados em buffer sejam gravados no dispositivo subjacente. |
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. (Herdado de Stream) |
FlushAsync(CancellationToken) |
Grava de modo assíncrono todos os dados armazenados em buffer no dispositivo subjacente. |
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. (Herdado de Stream) |
GetHashCode() |
Serve como a função de hash padrão. (Herdado de Object) |
GetLifetimeService() |
Obsoleto.
Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject) |
GetType() |
Obtém o Type da instância atual. (Herdado de Object) |
InitializeLifetimeService() |
Obsoleto.
Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject) |
MemberwiseClone() |
Cria uma cópia superficial do Object atual. (Herdado de Object) |
MemberwiseClone(Boolean) |
Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject) |
ObjectInvariant() |
Obsoleto.
Oferece suporte a um Contract. (Herdado de Stream) |
Read(Byte[], Int32, Int32) |
Lê os dados desse fluxo e o armazena na matriz especificada. |
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. (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. (Herdado de Stream) |
ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Lê os dados de modo assíncrono desse fluxo e os armazena na matriz especificada. |
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. (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. |
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. (Herdado de Stream) |
ReadAtLeast(Span<Byte>, Int32, Boolean) |
Lê pelo menos um número mínimo de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream) |
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken) |
Lê de forma assíncrona pelo menos um número mínimo de bytes do fluxo atual, avança a posição dentro do fluxo pelo número de bytes lidos e monitora as solicitações de cancelamento. (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. (Herdado de Stream) |
ReadExactly(Byte[], Int32, Int32) |
Lê |
ReadExactly(Span<Byte>) |
Lê bytes do fluxo atual e avança a posição dentro do fluxo até que o |
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken) |
Lê |
ReadExactlyAsync(Memory<Byte>, CancellationToken) |
Lê bytes de forma assíncrona do fluxo atual, avança a posição dentro do fluxo até que o |
Seek(Int64, SeekOrigin) |
Gera NotSupportedException. |
SetLength(Int64) |
Define o comprimento do fluxo subjacente. |
ToString() |
Retorna uma cadeia de caracteres que representa o objeto atual. (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(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. (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. (Herdado de Stream) |
WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Grava de forma assíncrona o número especificado de Bytes no fluxo subjacente. |
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. (Herdado de Stream) |
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Grava de forma assíncrona o número especificado de Bytes no fluxo subjacente. |
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. (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. (Herdado de Stream) |
Métodos de Extensão
CopyToAsync(Stream, PipeWriter, CancellationToken) |
Lê de forma assíncrona os bytes do Stream e grava-os no PipeWriter especificado usando um token de cancelamento especificado. |
ConfigureAwait(IAsyncDisposable, Boolean) |
Configura como as esperas nas tarefas retornadas de um descartável assíncrono são realizadas. |
Aplica-se a
Confira também
Comentários
https://aka.ms/ContentUserFeedback.
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulteEnviar e exibir comentários de