NegotiateStream Clase

Definición

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.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
Herencia

Ejemplos

En el ejemplo siguiente se muestra el lado cliente de una conexión cliente-servidor que NegotiateStreamusa.The following example demonstrates the client side of a client-server connection that uses the NegotiateStream. El cliente se autentica y envía un mensaje al servidor de forma asincrónica.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.
            IAsyncResult ar = authStream.BeginAuthenticateAsClient(
                new AsyncCallback(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.
            byte[] message = Encoding.UTF8.GetBytes("Hello from the client.");
            ar = authStream.BeginWrite(message, 0, message.Length,
                new AsyncCallback(EndWriteCallback),
                authStream);
            ar.AsyncWaitHandle.WaitOne();
            Console.WriteLine("Sent {0} bytes.", message.Length);
            // Close the client connection.
            authStream.Close();
            Console.WriteLine("Client closed.");
        }
        // The following method is called when the authentication completes.
        public static void EndAuthenticateCallback (IAsyncResult ar)
        {
            Console.WriteLine("Client ending authentication...");
            NegotiateStream authStream = (NegotiateStream) ar.AsyncState;
            Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel);

            // End the asynchronous operation.
            authStream.EndAuthenticateAsClient(ar);
        }
        // The following method is called when the write operation completes.
        public static void EndWriteCallback (IAsyncResult ar)
        {
            Console.WriteLine("Client ending write operation...");
            NegotiateStream authStream = (NegotiateStream) ar.AsyncState;

            // End the asynchronous operation.
            authStream.EndWrite(ar);
        }
    }

    // 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

NegotiateStream En el ejemplo de código siguiente se muestra el lado del servidor de una conexión cliente-servidor que utiliza para autenticar el cliente y leer un mensaje enviado por el 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 = null;
                // 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);
                    continue;
                }

            }
        
        }
        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.
            authStream.BeginAuthenticateAsServer (
                new AsyncCallback(EndAuthenticateCallback),
                cState
                );
            // Wait until the authentication completes.
            cState.Waiter.WaitOne();
            cState.Waiter.Reset();
            authStream.BeginRead(cState.Buffer, 0, cState.Buffer.Length, 
                   new AsyncCallback(EndReadCallback), 
                   cState);
            cState.Waiter.WaitOne();
            // Finished with the current client.
            authStream.Close();
            clientRequest.Close();
        }
        // The following method is invoked by the
        // BeginAuthenticateAsServer callback delegate.

        public static void EndAuthenticateCallback (IAsyncResult ar)
        {
            // Get the saved data.
            ClientState cState = (ClientState) ar.AsyncState;
            TcpClient clientRequest = cState.Client;
            NegotiateStream authStream = (NegotiateStream) cState.AuthenticatedStream;
            Console.WriteLine("Ending authentication.");
            // Any exceptions that occurred during authentication are
            // thrown by the EndAuthenticateAsServer method.
            try 
            {
                // This call blocks until the authentication is complete.
                authStream.EndAuthenticateAsServer(ar);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Authentication failed - closing connection.");
                cState.Waiter.Set();
                return;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Closing connection.");
                cState.Waiter.Set();
                return;
            }
            // Display properties of the authenticated client.
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} was authenticated using {1}.", 
                id.Name, 
                id.AuthenticationType
                );
            cState.Waiter.Set();

    }
        public static void EndReadCallback(IAsyncResult ar)
        {
            // Get the saved data.
            ClientState cState = (ClientState) ar.AsyncState;
            TcpClient clientRequest = cState.Client;
            NegotiateStream authStream = (NegotiateStream) cState.AuthenticatedStream; 
            // 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, 
                               new AsyncCallback(EndReadCallback), 
                               cState);
                               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);
                cState.Waiter.Set();
                return;
            }
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} says {1}", id.Name, cState.Message.ToString());
            cState.Waiter.Set();
        }
    }
    // ClientState is the AsyncState object.
    internal class ClientState
    {
        private AuthenticatedStream authStream = null;
        private  TcpClient client = null;
        byte[] buffer = new byte[2048];
        StringBuilder message = null;
        ManualResetEvent waiter = new ManualResetEvent(false);
        internal ClientState(AuthenticatedStream a, TcpClient theClient)
        {
            authStream = a;
            client = theClient;
        }
        internal TcpClient Client
        { 
            get { return client;}
        }
        internal AuthenticatedStream AuthenticatedStream
        {
            get { return authStream;}
        }
        internal byte[] Buffer
        {
              get { return buffer;}
        }
        internal StringBuilder Message
        {
            get 
            { 
                if (message == null)
                    message = new StringBuilder();
                return message;
             }
        }
        internal ManualResetEvent Waiter
        {
            get 
            { 
                return waiter;
             }
        }
    }
}

Comentarios

Use la NegotiateStream clase para la autenticación y para ayudar a proteger la información transmitida entre un cliente y un servidor.Use the NegotiateStream class for authentication and to help secure information transmitted between a client and a server. Con NegotiateStream, puede hacer lo siguiente.Using NegotiateStream, you can do the following.

  • Envíe las credenciales del cliente al servidor para la suplantación o delegación.Send the client's credentials to the server for Impersonation or Delegation.

  • Solicitar autenticación del servidor.Request server authentication.

  • Cifrar y/o firmar datos antes de transmitirlos.Encrypt and/or sign data before transmitting it.

La autenticación debe realizarse antes de transmitir la información.Authentication must be performed before transmitting information. Los clientes solicitan autenticación mediante los AuthenticateAsClient métodos sincrónicos, que se bloquean hasta que se completa la BeginAuthenticateAsClient autenticación, o los métodos asincrónicos, que no se bloquean mientras esperan a que se complete la autenticación.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. Los servidores solicitan la autenticación mediante AuthenticateAsServer BeginAuthenticateAsServer métodos sincrónicos o asincrónicos.Servers request authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. El cliente, y opcionalmente el servidor, se autentica mediante el protocolo de seguridad Negotiate.The client, and optionally the server, is authenticated using the Negotiate security protocol. En los sistemas 95/98 de Windows, el administrador de LAN de Windows NT (NTLM) es el protocolo utilizado para la autenticación.On Windows 95/98 systems, Windows NT LAN Manager (NTLM) is the protocol used for authentication. En otras plataformas, se usa el protocolo Kerberos para la autenticación si tanto el cliente como el servidor lo admiten; en caso contrario, se utiliza NTLM.On other platforms the Kerberos protocol is used for authentication if both client and server support it; otherwise NTLM is used. Para obtener descripciones detalladas de estos protocolos, vea la documentación de Platform SDK en MSDN, en msdn.microsoft.com/library/.For detailed descriptions of these protocols, see the Platform SDK documentation on MSDN, at msdn.microsoft.com/library/. La NegotiateStream clase realiza la autenticación mediante la interfaz del proveedor de compatibilidad para seguridad (SSPI).The NegotiateStream class performs the authentication using the Security Support Provider Interface (SSPI).

Cuando la autenticación se realiza correctamente, debe comprobar IsEncrypted las IsSigned propiedades y para determinar qué servicios de seguridad utilizará para NegotiateStream ayudar a proteger los datos durante la transmisión.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. Compruebe la IsMutuallyAuthenticated propiedad para determinar si se ha producido la autenticación mutua.Check the IsMutuallyAuthenticated property to determine whether mutual authentication occurred. Puede obtener información sobre el cliente o el servidor remoto mediante la RemoteIdentity propiedad.You can get information about the remote client or server using the RemoteIdentity property.

Si se produce un error en la autenticación, AuthenticationException recibirá InvalidCredentialExceptionuna o una.If the authentication fails, you will receive an AuthenticationException or a InvalidCredentialException. En este caso, puede volver a intentar la autenticación con una credencial diferente.In this case, you can retry the authentication with a different credential.

Los datos se envían mediante Write BeginWrite métodos sincrónicos o asincrónicos.You send data using the synchronous Write or asynchronous BeginWrite methods. Los datos se reciben mediante Read BeginRead métodos sincrónicos o asincrónicos.You receive data using the synchronous Read or asynchronous BeginRead methods. Si los servicios de seguridad, como el NegotiateStreamcifrado o la firma están habilitados, se aplican automáticamente a los datos por parte de.If security services such as encryption or signing are enabled, these are automatically applied to your data by the NegotiateStream.

Transmite NegotiateStream los datos mediante una secuencia que se proporciona al NegotiateStreamcrear.The NegotiateStream transmits data using a stream that you supply when creating the NegotiateStream. Al proporcionar esta secuencia subyacente, tiene la opción de especificar si al cerrar NegotiateStream también se cierra la secuencia subyacente.When you supply this underlying stream, you have the option to specify whether closing the NegotiateStream also closes the underlying stream.

Constructores

NegotiateStream(Stream)

Inicializa una nueva instancia de la clase NegotiateStream utilizando la clase Stream especificada.Initializes a new instance of the NegotiateStream class using the specified Stream.

NegotiateStream(Stream, Boolean)

Inicializa una nueva instancia de la clase NegotiateStream utilizando el objeto Stream especificado y el comportamiento de cierre de secuencias.Initializes a new instance of the NegotiateStream class using the specified Stream and stream closure behavior.

Propiedades

CanRead

Obtiene un valor Boolean que indica si se puede leer la secuencia subyacente.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

Obtiene un valor Boolean que indica si se puede buscar en la secuencia subyacente.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

Obtiene un valor Boolean que indica si la secuencia subyacente admite tiempos de espera.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

Obtiene un valor Boolean que indica si se puede escribir en la secuencia subyacente.Gets a Boolean value that indicates whether the underlying stream is writable.

ImpersonationLevel

Obtiene un valor que indica cómo puede utilizar el servidor las credenciales del cliente.Gets a value that indicates how the server can use the client's credentials.

InnerStream

Obtiene la secuencia utilizado por esta AuthenticatedStream para enviar y recibir datos.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Heredado de AuthenticatedStream)
IsAuthenticated

Obtiene un valor Boolean que indica si la autenticación se realizó correctamente.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

Obtiene un valor Boolean que indica si esta clase NegotiateStream utiliza el cifrado de datos.Gets a Boolean value that indicates whether this NegotiateStream uses data encryption.

IsMutuallyAuthenticated

Obtiene un valor Boolean que indica si se han autenticado el cliente y el servidor.Gets a Boolean value that indicates whether both the server and the client have been authenticated.

IsServer

Obtiene un valor Boolean que indica si el lado local de la conexión utilizada por NegotiateStream se autenticó como el servidor.Gets a Boolean value that indicates whether the local side of the connection used by this NegotiateStream was authenticated as the server.

IsSigned

Obtiene un valor Boolean que indica si los datos enviados utilizando esta secuencia tienen signo.Gets a Boolean value that indicates whether the data sent using this stream is signed.

LeaveInnerStreamOpen

Obtiene si la secuencia utilizada por esta AuthenticatedStream para enviar y recibir datos se ha dejado abierta.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Heredado de AuthenticatedStream)
Length

Obtiene la longitud de la secuencia subyacente.Gets the length of the underlying stream.

Position

Obtiene o establece la posición actual en la secuencia subyacente.Gets or sets the current position in the underlying stream.

ReadTimeout

Obtiene o establece el período de tiempo que se bloquea una operación de lectura mientras espera datos.Gets or sets the amount of time a read operation blocks waiting for data.

RemoteIdentity

Obtiene información sobre la identidad de la parte remota que comparte esta secuencia autenticada.Gets information about the identity of the remote party sharing this authenticated stream.

WriteTimeout

Obtiene o establece el período de tiempo que se bloquea una operación de escritura mientras espera datos.Gets or sets the amount of time a write operation blocks waiting for data.

Métodos

AuthenticateAsClient()

Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String)

Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales de cliente y el enlace de canal especificados.The authentication process uses the specified client credential and the channel binding.

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

Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales, las opciones de autenticación y el enlace de canal especificados.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClient(NetworkCredential, String)

Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales de cliente especificadas.The authentication process uses the specified client credential.

AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Lo llaman los clientes para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by clients to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales y las opciones de autenticación especificadas.The authentication process uses the specified credentials and authentication options.

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.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

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.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. El proceso de autenticación utiliza las credenciales de cliente y el enlace de canal especificados.The authentication process uses the specified client credential and the channel binding.

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.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. El proceso de autenticación utiliza las credenciales, las opciones de autenticación y el enlace de canal especificados.The authentication process uses the specified credential, authentication options, and channel binding.

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.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. El proceso de autenticación utiliza las credenciales de cliente especificadas.The authentication process uses the specified client credential.

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.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. El proceso de autenticación utiliza las credenciales y las opciones de autenticación especificadas.The authentication process uses the specified credentials and authentication options.

AuthenticateAsServer()

Lo llaman los servidores para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by servers to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsServer(ExtendedProtectionPolicy)

Lo llaman los servidores para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by servers to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza la directiva de protección extendida especificada.The authentication process uses the specified extended protection policy.

AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Lo llaman los servidores para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by servers to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales de servidor, las opciones de autenticación y la directiva de protección extendida especificadas.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Lo llaman los servidores para autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor.Called by servers to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales de servidor y las opciones de autenticación especificadas.The authentication process uses the specified server credentials and authentication options.

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.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

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.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. El proceso de autenticación utiliza la directiva de protección extendida especificada.The authentication process uses the specified extended protection policy.

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.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. El proceso de autenticación utiliza las credenciales de servidor, las opciones de autenticación y la directiva de protección extendida especificadas.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

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.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. El proceso de autenticación utiliza las credenciales de servidor y las opciones de autenticación especificadas.The authentication process uses the specified server credentials and authentication options.

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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Este método no se bloquea.This method does not block.

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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales y el enlace de canal especificados.The authentication process uses the specified credentials and channel binding. Este método no se bloquea.This method does not block.

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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales, las opciones de autenticación y el enlace de canal especificados.The authentication process uses the specified credentials, authentication options, and channel binding. Este método no se bloquea.This method does not block.

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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales especificadas.The authentication process uses the specified credentials. Este método no se bloquea.This method does not block.

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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales y las opciones de autenticación especificadas.The authentication process uses the specified credentials and authentication options. Este método no se bloquea.This method does not block.

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.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Este método no se bloquea.This method does not block.

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.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza la directiva de protección extendida especificada.The authentication process uses the specified extended protection policy. Este método no se bloquea.This method does not block.

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.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales de servidor, las opciones de autenticación y la directiva de protección extendida especificadas.The authentication process uses the specified server credentials, authentication options, and extended protection policy. Este método no se bloquea.This method does not block.

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.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. El proceso de autenticación utiliza las credenciales de servidor y las opciones de autenticación especificadas.The authentication process uses the specified server credentials and authentication options. Este método no se bloquea.This method does not block.

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.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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.Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

Close()

Cierra la secuencia actual y libera todos los recursos (como sockets e identificadores de archivo) asociados a esta.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. En lugar de llamar a este método, asegúrese de que la secuencia se desecha correctamente.Instead of calling this method, ensure that the stream is properly disposed.

(Heredado de Stream)
CopyTo(Stream)

Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino.Reads the bytes from the current stream and writes them to another stream.

(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.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Heredado de Stream)
CopyToAsync(Stream)

Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia.Asynchronously reads the bytes from the current stream and writes them to another stream.

(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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Heredado de MarshalByRefObject)
CreateWaitHandle()

Asigna un objeto WaitHandle.Allocates a WaitHandle object.

(Heredado de Stream)
Dispose()

Libera todos los recursos que usa Stream.Releases all resources used by the Stream.

(Heredado de Stream)
Dispose(Boolean)

Libera los recursos no administrados que usa NegotiateStream y, de forma opcional, libera los recursos administrados.Releases the unmanaged resources used by the NegotiateStream and optionally releases the managed resources.

DisposeAsync()

Libera de forma asincrónica los recursos administrados y no administrados que usa NegotiateStream.Asynchronously releases the unmanaged and managed resources used by the NegotiateStream.

EndAuthenticateAsClient(IAsyncResult)

Finaliza una operación de autenticación del cliente asincrónica pendiente que se inició con una llamada a BeginAuthenticateAsClient.Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Finaliza una operación de autenticación del cliente asincrónica pendiente que se inició con una llamada a BeginAuthenticateAsServer.Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsServer.

EndRead(IAsyncResult)

Finaliza una operación de lectura asincrónica que se inició con una llamada a BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).Ends an asynchronous read operation that was started with a call to BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult)

Finaliza una operación de escritura asincrónica que se inició con una llamada a BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).Ends an asynchronous write operation that was started with a call to BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
Flush()

Provoca la escritura de los datos almacenados en el búfer del dispositivo subyacente.Causes any buffered data to be written to the underlying device.

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.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Heredado de Stream)
FlushAsync(CancellationToken)
GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Heredado de MarshalByRefObject)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
InitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Heredado de MarshalByRefObject)
MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
MemberwiseClone(Boolean)

Crea una copia superficial del objeto MarshalByRefObject actual.Creates a shallow copy of the current MarshalByRefObject object.

(Heredado de MarshalByRefObject)
ObjectInvariant()

Proporciona compatibilidad con una clase Contract.Provides support for a Contract.

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

Lee datos de esta secuencia y los almacena en la matriz especificada.Reads data from this stream and stores it in the specified array.

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.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.

(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.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Heredado de Stream)
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.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.

(Heredado de Stream)
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.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.

(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.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.

(Heredado de Stream)
Seek(Int64, SeekOrigin)

Produce NotSupportedException.Throws NotSupportedException.

SetLength(Int64)

Establece la longitud de la secuencia subyacente.Sets the length of the underlying stream.

ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(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 the specified number of Bytes to the underlying stream using the specified buffer and offset.

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.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.

(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.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Heredado de Stream)
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.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.

(Heredado de Stream)
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.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.

(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.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Heredado de Stream)

Implementaciones de interfaz explícitas

IDisposable.Dispose()

Libera todos los recursos que usa Stream.Releases all resources used by the Stream.

(Heredado de Stream)

Se aplica a

Consulte también: