NegotiateStream Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Proporciona una secuencia que utiliza el protocolo de negociación de seguridad para autenticar el cliente, y opcionalmente el servidor, en la comunicación cliente-servidor.
public ref class NegotiateStream : System::Net::Security::AuthenticatedStreampublic class NegotiateStream : System.Net.Security.AuthenticatedStream[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public class NegotiateStream : System.Net.Security.AuthenticatedStreamtype NegotiateStream = class
inherit AuthenticatedStream[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
type NegotiateStream = class
inherit AuthenticatedStreamPublic Class NegotiateStream
Inherits AuthenticatedStream- Herencia
- Herencia
- Atributos
Ejemplos
En el ejemplo siguiente se muestra el lado cliente de una conexión de cliente-servidor que usa .NegotiateStream El cliente se autentica y envía un mensaje al servidor de forma asincrónica.
#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
En el ejemplo de código siguiente se muestra el lado servidor de una conexión cliente-servidor que usa NegotiateStream para autenticar al cliente y leer un mensaje enviado por el 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(); }
}
}
}
Comentarios
Use la clase para la autenticación y para ayudar a proteger la NegotiateStream información transmitida entre un cliente y un servidor. Con NegotiateStream, puede hacer lo siguiente.
Envíe las credenciales del cliente al servidor para suplantación o delegación.
Solicitud de autenticación del servidor.
Cifre o firme los datos antes de transmitirlos.
La autenticación debe realizarse antes de transmitir información. Los clientes solicitan autenticación mediante los métodos sincrónicos AuthenticateAsClient , que bloquean hasta que se completa la autenticación o los métodos asincrónicos BeginAuthenticateAsClient , que no se bloquean mientras esperan a que se complete la autenticación. Los servidores solicitan autenticación mediante los métodos sincrónicos AuthenticateAsServer o asincrónicos BeginAuthenticateAsServer . El cliente y, opcionalmente, el servidor, se autentica mediante el protocolo de seguridad Negotiate. El protocolo Kerberos se usa para la autenticación si tanto el cliente como el servidor lo admiten; de lo contrario, se usa NTLM. La NegotiateStream clase realiza la autenticación mediante la interfaz del proveedor de soporte técnico de seguridad (SSPI).
Cuando la autenticación se realice correctamente, debe comprobar las IsEncrypted propiedades y IsSigned para determinar qué servicios de seguridad usarán NegotiateStream para ayudar a proteger los datos durante la transmisión. Compruebe la IsMutuallyAuthenticated propiedad para determinar si se ha producido la autenticación mutua. Puede obtener información sobre el cliente remoto o el servidor mediante la RemoteIdentity propiedad .
Si se produce un error en la autenticación, recibirá o AuthenticationException .InvalidCredentialException En este caso, puede volver a intentar la autenticación con una credencial diferente.
Los datos se envían mediante los métodos o sincrónicos Write o asincrónicosBeginWrite.WriteAsync Recibirá datos mediante los métodos o sincrónicos Read o BeginRead asincrónicosReadAsync. Si los servicios de seguridad como el cifrado o la firma están habilitados, estos NegotiateStreamse aplican automáticamente a los datos mediante .
NegotiateStream transmite datos mediante una secuencia que se proporciona al crear .NegotiateStream Al proporcionar esta secuencia subyacente, tiene la opción de especificar si el cierre NegotiateStream también cierra la secuencia subyacente.
Constructores
| NegotiateStream(Stream) |
Inicializa una nueva instancia de la clase NegotiateStream utilizando la clase Stream especificada. |
| NegotiateStream(Stream, Boolean) |
Inicializa una nueva instancia de la clase NegotiateStream utilizando el objeto Stream especificado y el comportamiento de cierre de secuencias. |
Propiedades
| CanRead |
Obtiene un valor Boolean que indica si se puede leer la secuencia subyacente. |
| CanSeek |
Obtiene un valor Boolean que indica si se puede buscar en la secuencia subyacente. |
| CanTimeout |
Obtiene un valor Boolean que indica si la secuencia subyacente admite tiempos de espera. |
| CanWrite |
Obtiene un valor Boolean que indica si se puede escribir en la secuencia subyacente. |
| ImpersonationLevel |
Obtiene un valor que indica cómo puede utilizar el servidor las credenciales del cliente. |
| InnerStream |
Obtiene la secuencia utilizado por esta AuthenticatedStream para enviar y recibir datos. (Heredado de AuthenticatedStream) |
| IsAuthenticated |
Obtiene un valor Boolean que indica si la autenticación se realizó correctamente. |
| IsEncrypted |
Obtiene un valor Boolean que indica si esta clase NegotiateStream utiliza el cifrado de datos. |
| IsMutuallyAuthenticated |
Obtiene un valor Boolean que indica si se han autenticado el cliente y el servidor. |
| IsServer |
Obtiene un valor Boolean que indica si el lado local de la conexión utilizada por NegotiateStream se autenticó como el servidor. |
| IsSigned |
Obtiene un valor Boolean que indica si los datos enviados utilizando esta secuencia tienen signo. |
| LeaveInnerStreamOpen |
Obtiene si la secuencia utilizada por esta AuthenticatedStream para enviar y recibir datos se ha dejado abierta. (Heredado de AuthenticatedStream) |
| Length |
Obtiene la longitud de la secuencia subyacente. |
| Position |
Obtiene o establece la posición actual en la secuencia subyacente. |
| ReadTimeout |
Obtiene o establece el período de tiempo que se bloquea una operación de lectura mientras espera datos. |
| RemoteIdentity |
Obtiene información sobre la identidad de la parte remota que comparte esta secuencia autenticada. |
| WriteTimeout |
Obtiene o establece el período de tiempo que se bloquea una operación de escritura mientras espera datos. |
Métodos
| AuthenticateAsClient() |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. |
| AuthenticateAsClient(NetworkCredential, ChannelBinding, String) |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales de cliente y el enlace de canal especificados. |
| AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel) |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales, las opciones de autenticación y el enlace de canal especificados. |
| AuthenticateAsClient(NetworkCredential, String) |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales de cliente especificadas. |
| AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel) |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales y las opciones de autenticación especificadas. |
| AuthenticateAsClientAsync() |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. |
| AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String) |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación utiliza las credenciales de cliente y el enlace de canal especificados. |
| AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel) |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación utiliza las credenciales, las opciones de autenticación y el enlace de canal especificados. |
| AuthenticateAsClientAsync(NetworkCredential, String) |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación utiliza las credenciales de cliente especificadas. |
| AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel) |
Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación utiliza las credenciales y las opciones de autenticación especificadas. |
| AuthenticateAsServer() |
Lo llaman los servidores para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. |
| AuthenticateAsServer(ExtendedProtectionPolicy) |
Lo llaman los servidores para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza la directiva de protección extendida especificada. |
| AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) |
Lo llaman los servidores para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales de servidor, las opciones de autenticación y la directiva de protección extendida especificadas. |
| AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) |
Lo llaman los servidores para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales de servidor y las opciones de autenticación especificadas. |
| AuthenticateAsServerAsync() |
Lo llaman los servidores con el fin de autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. |
| AuthenticateAsServerAsync(ExtendedProtectionPolicy) |
Lo llaman los servidores con el fin de autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación utiliza la directiva de protección extendida especificada. |
| AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) |
Lo llaman los servidores con el fin de autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación utiliza las credenciales de servidor, las opciones de autenticación y la directiva de protección extendida especificadas. |
| AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) |
Lo llaman los servidores con el fin de autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación utiliza las credenciales de servidor y las opciones de autenticación especificadas. |
| BeginAuthenticateAsClient(AsyncCallback, Object) |
Lo llaman los clientes para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. Este método no se bloquea. |
| BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object) |
Lo llaman los clientes para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales y el enlace de canal especificados. Este método no se bloquea. |
| BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) |
Lo llaman los clientes para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales, las opciones de autenticación y el enlace de canal especificados. Este método no se bloquea. |
| BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object) |
Lo llaman los clientes para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales especificadas. Este método no se bloquea. |
| BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) |
Lo llaman los clientes para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales y las opciones de autenticación especificadas. Este método no se bloquea. |
| BeginAuthenticateAsServer(AsyncCallback, Object) |
Lo llaman los servidores para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. Este método no se bloquea. |
| BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object) |
Lo llaman los servidores para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza la directiva de protección extendida especificada. Este método no se bloquea. |
| BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) |
Lo llaman los servidores para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales de servidor, las opciones de autenticación y la directiva de protección extendida especificadas. Este método no se bloquea. |
| BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) |
Lo llaman los servidores para comenzar una operación asincrónica para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. El proceso de autenticación utiliza las credenciales de servidor y las opciones de autenticación especificadas. Este método no se bloquea. |
| BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Inicia una operación de lectura asincrónica que lee los datos de la secuencia y los almacena en la matriz especificada. |
| BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Comienza una operación de lectura asincrónica. (Considere usar ReadAsync(Byte[], Int32, Int32) en su lugar). (Heredado de Stream) |
| BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Inicia una operación de escritura asincrónica que escribe Bytes desde el búfer especificado en la secuencia. |
| BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Comienza una operación de escritura asincrónica. (Considere usar WriteAsync(Byte[], Int32, Int32) en su lugar). (Heredado de Stream) |
| Close() |
Cierra la secuencia actual y libera todos los recursos (como sockets e identificadores de archivo) asociados a esta. En lugar de llamar a este método, asegúrese de que la secuencia se desecha correctamente. (Heredado de Stream) |
| CopyTo(Stream) |
Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyTo(Stream, Int32) |
Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyToAsync(Stream) |
Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyToAsync(Stream, CancellationToken) |
Lee de forma asincrónica los bytes de la secuencia actual y los escribe en otra secuencia mediante un token de cancelación especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyToAsync(Stream, Int32) |
Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyToAsync(Stream, Int32, CancellationToken) |
Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CreateObjRef(Type) |
Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject) |
| CreateWaitHandle() |
Obsoleto.
Obsoleto.
Obsoleto.
Asigna un objeto WaitHandle. (Heredado de Stream) |
| Dispose() |
Libera todos los recursos que usa Stream. (Heredado de Stream) |
| Dispose(Boolean) |
Libera los recursos no administrados que usa NegotiateStream y, de forma opcional, libera los recursos administrados. |
| Dispose(Boolean) |
Libera los recursos no administrados que usa AuthenticatedStream y, de forma opcional, libera los recursos administrados. (Heredado de AuthenticatedStream) |
| DisposeAsync() |
Libera de forma asincrónica los recursos administrados y no administrados que usa NegotiateStream. |
| DisposeAsync() |
Libera de forma asincrónica los recursos administrados y no administrados que usa AuthenticatedStream. (Heredado de AuthenticatedStream) |
| EndAuthenticateAsClient(IAsyncResult) |
Finaliza una operación de autenticación del cliente asincrónica pendiente que se inició con una llamada a BeginAuthenticateAsClient. |
| EndAuthenticateAsServer(IAsyncResult) |
Finaliza una operación de autenticación del cliente asincrónica pendiente que se inició con una llamada a BeginAuthenticateAsServer. |
| EndRead(IAsyncResult) |
Finaliza una operación de lectura asincrónica que se inició con una llamada a BeginRead(Byte[], Int32, Int32, AsyncCallback, Object). |
| EndRead(IAsyncResult) |
Espera a que se complete la lectura asincrónica que se encuentra pendiente. (Considere usar ReadAsync(Byte[], Int32, Int32) en su lugar). (Heredado de Stream) |
| EndWrite(IAsyncResult) |
Finaliza una operación de escritura asincrónica que se inició con una llamada a BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object). |
| EndWrite(IAsyncResult) |
Finaliza una operación de escritura asincrónica. (Considere usar WriteAsync(Byte[], Int32, Int32) en su lugar). (Heredado de Stream) |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object) |
| Flush() |
Provoca la escritura de los datos almacenados en el búfer del dispositivo subyacente. |
| FlushAsync() |
Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. (Heredado de Stream) |
| FlushAsync(CancellationToken) |
Escribe de manera asincrónica cualquier dato almacenado en búfer en el dispositivo subyacente. |
| FlushAsync(CancellationToken) |
Borra asincrónicamente todos los búferes de esta secuencia, y hace que todos los datos almacenados en búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. (Heredado de Stream) |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| GetLifetimeService() |
Obsoleto.
Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject) |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| InitializeLifetimeService() |
Obsoleto.
Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject) |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| MemberwiseClone(Boolean) |
Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject) |
| ObjectInvariant() |
Obsoleto.
Proporciona compatibilidad con una clase Contract. (Heredado de Stream) |
| Read(Byte[], Int32, Int32) |
Lee datos de esta secuencia y los almacena en la matriz especificada. |
| Read(Span<Byte>) |
Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. (Heredado de Stream) |
| ReadAsync(Byte[], Int32, Int32) |
Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. (Heredado de Stream) |
| ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Lee datos de esta secuencia de manera asincrónica y los almacena en la matriz especificada. |
| ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. (Heredado de Stream) |
| ReadAsync(Memory<Byte>, CancellationToken) |
Lee datos de NegotiateStream de manera asincrónica y los almacena en un rango de memoria de bytes como una operación asincrónica. |
| ReadAsync(Memory<Byte>, CancellationToken) |
Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. (Heredado de Stream) |
| ReadAtLeast(Span<Byte>, Int32, Boolean) |
Lee al menos un número mínimo de bytes de la secuencia actual y avanza la posición dentro de la secuencia por el número de bytes leídos. (Heredado de Stream) |
| ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken) |
Lee de forma asincrónica al menos un número mínimo de bytes de la secuencia actual, avanza la posición dentro de la secuencia por el número de bytes leídos y supervisa las solicitudes de cancelación. (Heredado de Stream) |
| ReadByte() |
Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. (Heredado de Stream) |
| ReadExactly(Byte[], Int32, Int32) |
|
| ReadExactly(Span<Byte>) |
Lee bytes de la secuencia actual y avanza la posición dentro de la secuencia hasta |
| ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken) |
Lee |
| ReadExactlyAsync(Memory<Byte>, CancellationToken) |
Lee de forma asincrónica los bytes de la secuencia actual, avanza la posición dentro de la secuencia hasta |
| Seek(Int64, SeekOrigin) |
Produce NotSupportedException. |
| SetLength(Int64) |
Establece la longitud de la secuencia subyacente. |
| ToString() |
Devuelve una cadena que representa el objeto actual. (Heredado de Object) |
| Write(Byte[], Int32, Int32) |
Escriba el número especificado de Bytes en la secuencia subyacente mediante el búfer y el desplazamiento especificados. |
| Write(ReadOnlySpan<Byte>) |
Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. (Heredado de Stream) |
| WriteAsync(Byte[], Int32, Int32) |
Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. (Heredado de Stream) |
| WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Escribe de manera asincrónica el número especificado de Byte en la secuencia subyacente. |
| WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. (Heredado de Stream) |
| WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Escribe de manera asincrónica el número especificado de Byte en la secuencia subyacente. |
| WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. (Heredado de Stream) |
| WriteByte(Byte) |
Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. (Heredado de Stream) |
Métodos de extensión
| ConfigureAwait(IAsyncDisposable, Boolean) |
Configura la forma en la que se realizan las expresiones await en las tareas devueltas desde un elemento asincrónico descartable. |