NegotiateStream Classe

Définition

Fournit un flux qui utilise le protocole de sécurité Negotiate pour authentifier le client et éventuellement le serveur, dans les communications client-serveur.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
Héritage

Exemples

L’exemple suivant illustre le côté client d’une connexion client-serveur qui utilise NegotiateStream.The following example demonstrates the client side of a client-server connection that uses the NegotiateStream. Le client s’authentifie et envoie un message au serveur de façon asynchrone.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

L’exemple de code suivant illustre le côté serveur d’une connexion client-serveur qui utilise NegotiateStream pour authentifier le client et lire un message envoyé par le client.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;
             }
        }
    }
}

Remarques

Utilisez la NegotiateStream classe pour l’authentification et pour aider à sécuriser les informations transmises entre un client et un serveur.Use the NegotiateStream class for authentication and to help secure information transmitted between a client and a server. À NegotiateStreaml’aide de, vous pouvez effectuer les opérations suivantes.Using NegotiateStream, you can do the following.

  • Envoyer les informations d’identification du client au serveur pour l’emprunt d’identité ou la délégation.Send the client's credentials to the server for Impersonation or Delegation.

  • Demandez l’authentification du serveur.Request server authentication.

  • Chiffrez et/ou signez les données avant de les transmettre.Encrypt and/or sign data before transmitting it.

L’authentification doit être effectuée avant de transmettre des informations.Authentication must be performed before transmitting information. Les clients demandent l’authentification à AuthenticateAsClient l’aide des méthodes synchrones, qui sont bloquées jusqu’à BeginAuthenticateAsClient la fin de l’authentification, ou les méthodes asynchrones qui ne se bloquent pas en attendant la fin de l’authentification.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. Les serveurs demandent l’authentification à AuthenticateAsServer l’aide BeginAuthenticateAsServer des méthodes synchrones ou asynchrones.Servers request authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. Le client, et éventuellement le serveur, est authentifié à l’aide du protocole de sécurité Negotiate.The client, and optionally the server, is authenticated using the Negotiate security protocol. Sur les systèmes Windows 95/98, Windows NT LAN Manager (NTLM) est le protocole utilisé pour l’authentification.On Windows 95/98 systems, Windows NT LAN Manager (NTLM) is the protocol used for authentication. Sur les autres plateformes, le protocole Kerberos est utilisé pour l’authentification si le client et le serveur le prennent en charge. Sinon, NTLM est utilisé.On other platforms the Kerberos protocol is used for authentication if both client and server support it; otherwise NTLM is used. Pour obtenir une description détaillée de ces protocoles, consultez la documentation du kit de développement Platform SDK sur MSDN, sur msdn.microsoft.com/library/.For detailed descriptions of these protocols, see the Platform SDK documentation on MSDN, at msdn.microsoft.com/library/. La NegotiateStream classe effectue l’authentification à l’aide de l’interface SSPI (Security Support Provider Interface).The NegotiateStream class performs the authentication using the Security Support Provider Interface (SSPI).

Une fois l’authentification réussie, vous devez vérifier IsEncrypted les IsSigned propriétés et pour déterminer les services de sécurité qui seront utilisés NegotiateStream par le pour sécuriser vos données pendant la transmission.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. Vérifiez la IsMutuallyAuthenticated propriété pour déterminer si l’authentification mutuelle s’est produite.Check the IsMutuallyAuthenticated property to determine whether mutual authentication occurred. Vous pouvez obtenir des informations sur le client ou le serveur distant RemoteIdentity à l’aide de la propriété.You can get information about the remote client or server using the RemoteIdentity property.

Si l’authentification échoue, vous recevrez un AuthenticationException ou un InvalidCredentialException.If the authentication fails, you will receive an AuthenticationException or a InvalidCredentialException. Dans ce cas, vous pouvez réessayer l’authentification avec des informations d’identification différentes.In this case, you can retry the authentication with a different credential.

Vous envoyez des données à l' Write aide des BeginWrite méthodes synchrones ou asynchrones.You send data using the synchronous Write or asynchronous BeginWrite methods. Vous recevez des données à l' Read aide des BeginRead méthodes synchrones ou asynchrones.You receive data using the synchronous Read or asynchronous BeginRead methods. Si des services de sécurité tels que le chiffrement ou la signature sont activés, ils sont automatiquement NegotiateStreamappliqués à vos données par le.If security services such as encryption or signing are enabled, these are automatically applied to your data by the NegotiateStream.

Le NegotiateStream transmet des données à l’aide d’un flux que vous fournissez lors de la création du. NegotiateStreamThe NegotiateStream transmits data using a stream that you supply when creating the NegotiateStream. Lorsque vous fournissez ce flux sous-jacent, vous avez la possibilité de spécifier NegotiateStream si la fermeture de ferme également le flux sous-jacent.When you supply this underlying stream, you have the option to specify whether closing the NegotiateStream also closes the underlying stream.

Constructeurs

NegotiateStream(Stream)

Initialise une nouvelle instance de la classe NegotiateStream à l'aide du Stream spécifié.Initializes a new instance of the NegotiateStream class using the specified Stream.

NegotiateStream(Stream, Boolean)

Initialise une nouvelle instance de la classe NegotiateStream en utilisant le Stream et le comportement de clôture de flux spécifiés.Initializes a new instance of the NegotiateStream class using the specified Stream and stream closure behavior.

Propriétés

CanRead

Obtient une valeur Boolean qui indique si le flux sous-jacent est accessible en lecture.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

Obtient une valeur Boolean qui indique si le flux sous-jacent peut faire l'objet d'une recherche.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

Obtient une valeur Boolean qui indique si le flux sous-jacent prend en charge les délais d'attente.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

Obtient une valeur Boolean qui indique si le flux sous-jacent est accessible en écriture.Gets a Boolean value that indicates whether the underlying stream is writable.

ImpersonationLevel

Obtient une valeur qui indique comment le serveur peut utiliser les informations d'identification du client.Gets a value that indicates how the server can use the client's credentials.

InnerStream

Obtient le flux utilisé par ce AuthenticatedStream pour envoyer et recevoir des données.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Hérité de AuthenticatedStream)
IsAuthenticated

Obtient une valeur Boolean qui indique si l'authentification a réussi.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

Obtient une valeur Boolean qui indique si ce NegotiateStream utilise le chiffrement de données.Gets a Boolean value that indicates whether this NegotiateStream uses data encryption.

IsMutuallyAuthenticated

Obtient une valeur Boolean qui indique si le serveur et le client ont tous les deux été authentifiés.Gets a Boolean value that indicates whether both the server and the client have been authenticated.

IsServer

Obtient une valeur Boolean qui indique si le côté local de la connexion utilisée par ce NegotiateStream a été authentifié comme serveur.Gets a Boolean value that indicates whether the local side of the connection used by this NegotiateStream was authenticated as the server.

IsSigned

Obtient une valeur Boolean qui indique si les données envoyées à l'aide de ce flux sont signées.Gets a Boolean value that indicates whether the data sent using this stream is signed.

LeaveInnerStreamOpen

Obtient une valeur indiquant si le flux utilisé par ce AuthenticatedStream pour envoyer et recevoir des données a été laissé ouvert.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Hérité de AuthenticatedStream)
Length

Obtient la longueur du flux sous-jacent.Gets the length of the underlying stream.

Position

Obtient ou définit la position actuelle dans le flux sous-jacent.Gets or sets the current position in the underlying stream.

ReadTimeout

Obtient ou définit la durée pendant laquelle une opération de lecture reste bloquée en attendant des données.Gets or sets the amount of time a read operation blocks waiting for data.

RemoteIdentity

Obtient des informations à propos de l'identité du tiers distant qui partage ce flux authentifié.Gets information about the identity of the remote party sharing this authenticated stream.

WriteTimeout

Obtient ou définit la durée pendant laquelle une opération d'écriture reste bloquée en attendant des données.Gets or sets the amount of time a write operation blocks waiting for data.

Méthodes

AuthenticateAsClient()

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by clients to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String)

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les informations d'identification du client et la liaison de canal spécifiées.The authentication process uses the specified client credential and the channel binding.

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

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les informations d'identification du client, les options d'authentification et la liaison de canal spécifiées.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClient(NetworkCredential, String)

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les informations d'identification du client spécifiées.The authentication process uses the specified client credential.

AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les options d'authentification et les informations d'identification spécifiées.The authentication process uses the specified credentials and authentication options.

AuthenticateAsClientAsync()

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Le processus d'authentification utilise les informations d'identification du client et la liaison de canal spécifiées.The authentication process uses the specified client credential and the channel binding.

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

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Le processus d'authentification utilise les informations d'identification du client, les options d'authentification et la liaison de canal spécifiées.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClientAsync(NetworkCredential, String)

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Le processus d'authentification utilise les informations d'identification du client spécifiées.The authentication process uses the specified client credential.

AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Appelé par les clients pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Le processus d'authentification utilise les options d'authentification et les informations d'identification spécifiées.The authentication process uses the specified credentials and authentication options.

AuthenticateAsServer()

Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by servers to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsServer(ExtendedProtectionPolicy)

Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise la stratégie de protection étendue spécifiée.The authentication process uses the specified extended protection policy.

AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les informations d'identification du serveur, les options d'authentification et la stratégie de protection étendue spécifiées.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les options d'authentification et les informations d'identification du serveur spécifiées.The authentication process uses the specified server credentials and authentication options.

AuthenticateAsServerAsync()

Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsServerAsync(ExtendedProtectionPolicy)

Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Le processus d'authentification utilise la stratégie de protection étendue spécifiée.The authentication process uses the specified extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Le processus d'authentification utilise les informations d'identification du serveur, les options d'authentification et la stratégie de protection étendue spécifiées.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Appelé par les serveurs pour authentifier le client, et éventuellement le serveur, dans une connexion client-serveur sous forme d'opération asynchrone.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Le processus d'authentification utilise les options d'authentification et les informations d'identification du serveur spécifiées.The authentication process uses the specified server credentials and authentication options.

BeginAuthenticateAsClient(AsyncCallback, Object)

Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Cette méthode ne provoque pas de blocage.This method does not block.

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

Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les informations d'identification et la liaison de canal spécifiées.The authentication process uses the specified credentials and channel binding. Cette méthode ne provoque pas de blocage.This method does not block.

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

Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les informations d'identification, les options d'authentification et la liaison de canal spécifiées.The authentication process uses the specified credentials, authentication options, and channel binding. Cette méthode ne provoque pas de blocage.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)

Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les informations d'identification spécifiées.The authentication process uses the specified credentials. Cette méthode ne provoque pas de blocage.This method does not block.

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

Appelé par les clients pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les options d'authentification et les informations d'identification spécifiées.The authentication process uses the specified credentials and authentication options. Cette méthode ne provoque pas de blocage.This method does not block.

BeginAuthenticateAsServer(AsyncCallback, Object)

Appelé par les serveurs pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Cette méthode ne provoque pas de blocage.This method does not block.

BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)

Appelé par les serveurs pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise la stratégie de protection étendue spécifiée.The authentication process uses the specified extended protection policy. Cette méthode ne provoque pas de blocage.This method does not block.

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

Appelé par les serveurs pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les informations d'identification du serveur, les options d'authentification et la stratégie de protection étendue spécifiées.The authentication process uses the specified server credentials, authentication options, and extended protection policy. Cette méthode ne provoque pas de blocage.This method does not block.

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

Appelé par les serveurs pour commencer une opération asynchrone d'authentification du client, et éventuellement du serveur, dans une connexion client-serveur.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Le processus d'authentification utilise les options d'authentification et les informations d'identification du serveur spécifiées.The authentication process uses the specified server credentials and authentication options. Cette méthode ne provoque pas de blocage.This method does not block.

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

Commence une opération de lecture asynchrone qui lit des données du flux et les stocke dans le tableau spécifié.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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

Commence une opération d'écriture asynchrone qui écrit des Bytes de la mémoire tampon spécifiée vers le flux.Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

Close()

Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Au lieu d'appeler cette méthode, assurez-vous que le flux est correctement supprimé.Instead of calling this method, ensure that the stream is properly disposed.

(Hérité de Stream)
CopyTo(Stream)

Lit les octets du flux actuel et les écrit dans un autre flux.Reads the bytes from the current stream and writes them to another stream.

(Hérité de Stream)
CopyTo(Stream, Int32)

Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Hérité de Stream)
CopyToAsync(Stream)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Hérité de Stream)
CopyToAsync(Stream, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant un jeton d’annulation spécifié.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Hérité de Stream)
CopyToAsync(Stream, Int32)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Hérité de Stream)
CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
CreateWaitHandle()

Alloue un objet WaitHandle.Allocates a WaitHandle object.

(Hérité de Stream)
Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the Stream.

(Hérité de Stream)
Dispose(Boolean)

Libère les ressources non managées utilisées par NegotiateStream et libère éventuellement les ressources managées.Releases the unmanaged resources used by the NegotiateStream and optionally releases the managed resources.

DisposeAsync()

Libère de façon asynchrone les ressources non managées et managées utilisées par NegotiateStream.Asynchronously releases the unmanaged and managed resources used by the NegotiateStream.

EndAuthenticateAsClient(IAsyncResult)

Termine une opération d'authentification du client asynchrone en attente qui a été démarrée avec un appel à BeginAuthenticateAsClient.Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Termine une opération d'authentification du client asynchrone en attente qui a été démarrée avec un appel à BeginAuthenticateAsServer.Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsServer.

EndRead(IAsyncResult)

Termine une opération de lecture asynchrone qui a été démarrée avec un appel à 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)

Termine une opération d'écriture asynchrone qui a été démarrée avec un appel à 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)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Flush()

Provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent.Causes any buffered data to be written to the underlying device.

FlushAsync()

Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Hérité de Stream)
FlushAsync(CancellationToken)
GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
ObjectInvariant()

Assure la prise en charge d'un Contract.Provides support for a Contract.

(Hérité de Stream)
Read(Byte[], Int32, Int32)

Lit les données de ce flux et les stocke dans le tableau spécifié.Reads data from this stream and stores it in the specified array.

Read(Span<Byte>)

En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.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.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32)

Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation.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.

(Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation.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.

(Hérité de Stream)
ReadByte()

Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte.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.

(Hérité de Stream)
Seek(Int64, SeekOrigin)

Lève NotSupportedException.Throws NotSupportedException.

SetLength(Int64)

Définit la longueur du flux sous-jacent.Sets the length of the underlying stream.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
Write(Byte[], Int32, Int32)

Écrivez le nombre spécifié de Bytes dans le flux sous-jacent à l'aide de la mémoire tampon et de l'offset spécifiés.Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>)

En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits.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.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.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.

(Hérité de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.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.

(Hérité de Stream)
WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Hérité de Stream)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the Stream.

(Hérité de Stream)

S’applique à

Voir aussi