SslStream Classe

Définition

Fournit un flux utilisé pour la communication client-serveur qui passe par le protocole de sécurité Secure Socket Layer (SSL) pour authentifier le serveur et éventuellement le client.Provides a stream used for client-server communication that uses the Secure Socket Layer (SSL) security protocol to authenticate the server and optionally the client.

public ref class SslStream : System::Net::Security::AuthenticatedStream
public class SslStream : System.Net.Security.AuthenticatedStream
type SslStream = class
    inherit AuthenticatedStream
type SslStream = class
    inherit AuthenticatedStream
    interface IDisposable
Public Class SslStream
Inherits AuthenticatedStream
Héritage
Héritage
Implémente

Exemples

L’exemple de code suivant montre comment créer un TcpListener qui utilise la SslStream classe pour communiquer avec les clients.The following code example demonstrates creating an TcpListener that uses the SslStream class to communicate with clients.

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Net::Security;
using namespace System::Security::Authentication;
using namespace System::Text;
using namespace System::Security::Cryptography::X509Certificates;
using namespace System::IO;
public ref class SslTcpServer sealed
{
private:
   static X509Certificate^ serverCertificate = nullptr;

public:

   // The certificate parameter specifies the name of the file 
   // containing the machine certificate.
   static void RunServer( String^ certificate )
   {
      serverCertificate = X509Certificate::CreateFromCertFile( certificate );
      
      // Create a TCP/IP (IPv4) socket and listen for incoming connections.
      TcpListener^ listener = gcnew TcpListener( IPAddress::Any,8080 );
      listener->Start();
      
      while (true) 
      {
         Console::WriteLine( L"Waiting for a client to connect..." );
         
         // Application blocks while waiting for an incoming connection.
         // Type CNTL-C to terminate the server.
         TcpClient^ client = listener->AcceptTcpClient();
         ProcessClient( client );

      }
   }


   static void ProcessClient( TcpClient^ client )
   {
      
      // A client has connected. Create the 
      // SslStream using the client's network stream.
      SslStream^ sslStream = gcnew SslStream( client->GetStream(),false );
      
      // Authenticate the server but don't require the client to authenticate.
      try
      {
         sslStream->AuthenticateAsServer( serverCertificate, false, true );
         // false == no client cert required; true == check cert revocation.
         
         // Display the properties and settings for the authenticated stream.
         DisplaySecurityLevel( sslStream );
         DisplaySecurityServices( sslStream );
         DisplayCertificateInformation( sslStream );
         DisplayStreamProperties( sslStream );
         
         // Set timeouts for the read and write to 5 seconds.
         sslStream->ReadTimeout = 5000;
         sslStream->WriteTimeout = 5000;
         
         // Read a message from the client.   
         Console::WriteLine( L"Waiting for client message..." );
         String^ messageData = ReadMessage( sslStream );
         Console::WriteLine( L"Received: {0}", messageData );
         
         // Write a message to the client.
         array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the server.<EOF>" );
         Console::WriteLine( L"Sending hello message." );
         sslStream->Write( message );
      }
      catch ( AuthenticationException^ e ) 
      {
         Console::WriteLine( L"Exception: {0}", e->Message );
         if ( e->InnerException != nullptr )
         {
            Console::WriteLine( L"Inner exception: {0}", e->InnerException->Message );
         }
         Console::WriteLine( L"Authentication failed - closing the connection." );
         sslStream->Close();
         client->Close();
         return;
      }
      finally
      {
         
         // The client stream will be closed with the sslStream
         // because we specified this behavior when creating
         // the sslStream.
         sslStream->Close();
         client->Close();
      }

   }


   static String^ ReadMessage( SslStream^ sslStream )
   {
      
      // Read the  message sent by the client.
      // The client signals the end of the message using the
      // "<EOF>" marker.
      array<Byte>^buffer = gcnew array<Byte>(2048);
      StringBuilder^ messageData = gcnew StringBuilder;
      int bytes = -1;
      do
      {
         
         // Read the client's test message.
         bytes = sslStream->Read( buffer, 0, buffer->Length );
         
         // Use Decoder class to convert from bytes to UTF8
         // in case a character spans two buffers.
         Decoder^ decoder = Encoding::UTF8->GetDecoder();
         array<Char>^chars = gcnew array<Char>(decoder->GetCharCount( buffer, 0, bytes ));
         decoder->GetChars( buffer, 0, bytes, chars, 0 );
         messageData->Append( chars );
         
         // Check for EOF or an empty message.
         if ( messageData->ToString()->IndexOf( L"<EOF>" ) != -1 )
         {
            break;
         }
      }
      while ( bytes != 0 );

      return messageData->ToString();
   }


   static void DisplaySecurityLevel( SslStream^ stream )
   {
      Console::WriteLine( L"Cipher: {0} strength {1}", stream->CipherAlgorithm, stream->CipherStrength );
      Console::WriteLine( L"Hash: {0} strength {1}", stream->HashAlgorithm, stream->HashStrength );
      Console::WriteLine( L"Key exchange: {0} strength {1}", stream->KeyExchangeAlgorithm, stream->KeyExchangeStrength );
      Console::WriteLine( L"Protocol: {0}", stream->SslProtocol );
   }


   static void DisplaySecurityServices( SslStream^ stream )
   {
      Console::WriteLine( L"Is authenticated: {0} as server? {1}", stream->IsAuthenticated, stream->IsServer );
      Console::WriteLine( L"IsSigned: {0}", stream->IsSigned );
      Console::WriteLine( L"Is Encrypted: {0}", stream->IsEncrypted );
   }


   static void DisplayStreamProperties( SslStream^ stream )
   {
      Console::WriteLine( L"Can read: {0}, write {1}", stream->CanRead, stream->CanWrite );
      Console::WriteLine( L"Can timeout: {0}", stream->CanTimeout );
   }


   static void DisplayCertificateInformation( SslStream^ stream )
   {
      Console::WriteLine( L"Certificate revocation list checked: {0}", stream->CheckCertRevocationStatus );
      X509Certificate^ localCertificate = stream->LocalCertificate;
      if ( stream->LocalCertificate != nullptr )
      {
         Console::WriteLine( L"Local cert was issued to {0} and is valid from {1} until {2}.", 
             localCertificate->Subject, 
             localCertificate->GetEffectiveDateString(), 
             localCertificate->GetExpirationDateString() );
      }
      else
      {
         Console::WriteLine( L"Local certificate is null." );
      }

      X509Certificate^ remoteCertificate = stream->RemoteCertificate;
      if ( stream->RemoteCertificate != nullptr )
      {
         Console::WriteLine( L"Remote cert was issued to {0} and is valid from {1} until {2}.", 
            remoteCertificate->Subject, 
            remoteCertificate->GetEffectiveDateString(), 
            remoteCertificate->GetExpirationDateString() );
      }
      else
      {
         Console::WriteLine( L"Remote certificate is null." );
      }
   }


private:

   static void DisplayUsage()
   {
      Console::WriteLine( L"To start the server specify:" );
      Console::WriteLine( L"serverSync certificateFile.cer" );
      Environment::Exit( 1 );
   }

public:
   int RunServerASync()
   {
      array<String^>^args = Environment::GetCommandLineArgs();
      String^ certificate = nullptr;
      if ( args == nullptr || args->Length < 2 )
      {
         DisplayUsage();
      }

      certificate = args[ 1 ];
      SslTcpServer::RunServer( certificate );
      return 0;
   }

};

int main(){
    SslTcpServer^ sts = gcnew SslTcpServer();
    sts->RunServerASync();
}
using System;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace Examples.System.Net
{
    public sealed class SslTcpServer
    {
        static X509Certificate serverCertificate = null;
        // The certificate parameter specifies the name of the file
        // containing the machine certificate.
        public static void RunServer(string certificate)
        {
            serverCertificate = X509Certificate.CreateFromCertFile(certificate);
            // Create a TCP/IP (IPv4) socket and listen for incoming connections.
            TcpListener listener = new TcpListener(IPAddress.Any, 8080);
            listener.Start();
            while (true)
            {
                Console.WriteLine("Waiting for a client to connect...");
                // Application blocks while waiting for an incoming connection.
                // Type CNTL-C to terminate the server.
                TcpClient client = listener.AcceptTcpClient();
                ProcessClient(client);
            }
        }
        static void ProcessClient (TcpClient client)
        {
            // A client has connected. Create the
            // SslStream using the client's network stream.
            SslStream sslStream = new SslStream(
                client.GetStream(), false);
            // Authenticate the server but don't require the client to authenticate.
            try
            {
                sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired: false, checkCertificateRevocation: true);

                // Display the properties and settings for the authenticated stream.
                DisplaySecurityLevel(sslStream);
                DisplaySecurityServices(sslStream);
                DisplayCertificateInformation(sslStream);
                DisplayStreamProperties(sslStream);

                // Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000;
                sslStream.WriteTimeout = 5000;
                // Read a message from the client.
                Console.WriteLine("Waiting for client message...");
                string messageData = ReadMessage(sslStream);
                Console.WriteLine("Received: {0}", messageData);

                // Write a message to the client.
                byte[] message = Encoding.UTF8.GetBytes("Hello from the server.<EOF>");
                Console.WriteLine("Sending hello message.");
                sslStream.Write(message);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                sslStream.Close();
                client.Close();
                return;
            }
            finally
            {
                // The client stream will be closed with the sslStream
                // because we specified this behavior when creating
                // the sslStream.
                sslStream.Close();
                client.Close();
            }
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the client.
            // The client signals the end of the message using the
            // "<EOF>" marker.
            byte [] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                // Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars,0);
                messageData.Append (chars);
                // Check for EOF or an empty message.
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes !=0);

            return messageData.ToString();
        }
         static void DisplaySecurityLevel(SslStream stream)
         {
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength);
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength);
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength);
            Console.WriteLine("Protocol: {0}", stream.SslProtocol);
         }
         static void DisplaySecurityServices(SslStream stream)
         {
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer);
            Console.WriteLine("IsSigned: {0}", stream.IsSigned);
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted);
         }
         static void DisplayStreamProperties(SslStream stream)
         {
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite);
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout);
         }
        static void DisplayCertificateInformation(SslStream stream)
        {
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus);

            X509Certificate localCertificate = stream.LocalCertificate;
            if (stream.LocalCertificate != null)
            {
                Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.",
                    localCertificate.Subject,
                    localCertificate.GetEffectiveDateString(),
                    localCertificate.GetExpirationDateString());
             } else
            {
                Console.WriteLine("Local certificate is null.");
            }
            // Display the properties of the client's certificate.
            X509Certificate remoteCertificate = stream.RemoteCertificate;
            if (stream.RemoteCertificate != null)
            {
            Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.",
                remoteCertificate.Subject,
                remoteCertificate.GetEffectiveDateString(),
                remoteCertificate.GetExpirationDateString());
            } else
            {
                Console.WriteLine("Remote certificate is null.");
            }
        }
        private static void DisplayUsage()
        {
            Console.WriteLine("To start the server specify:");
            Console.WriteLine("serverSync certificateFile.cer");
            Environment.Exit(1);
        }
        public static int Main(string[] args)
        {
            string certificate = null;
            if (args == null ||args.Length < 1 )
            {
                DisplayUsage();
            }
            certificate = args[0];
            SslTcpServer.RunServer (certificate);
            return 0;
        }
    }
}
Imports System.Collections
Imports System.Net
Imports System.Net.Sockets
Imports System.Net.Security
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Namespace Examples.System.Net
    Public NotInheritable Class SslTcpServer
        Shared serverCertificate As X509Certificate = Nothing

        ' The certificate parameter specifies the name of the file 
        ' containing the machine certificate.
        Public Shared Sub RunServer(certificate As String)
            serverCertificate = X509Certificate.CreateFromCertFile(certificate)
            ' Create a TCP/IP (IPv4) socket And listen for incoming connections.
            Dim listener = New TcpListener(IPAddress.Any, 8080)
            listener.Start()

            While True
                Console.WriteLine("Waiting for a client to connect...")
                ' Application blocks while waiting for an incoming connection.
                ' Type CNTL-C to terminate the server.
                Dim client As TcpClient = listener.AcceptTcpClient()
                ProcessClient(client)
            End While
        End Sub
        Private Shared Sub ProcessClient(client As TcpClient)
            ' A client has connected. Create the 
            ' SslStream using the client's network stream.
            Dim sslStream = New SslStream(client.GetStream(), False)

            Try

                sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired:=False, checkCertificateRevocation:=True)
                ' Display the properties And settings for the authenticated stream.
                DisplaySecurityLevel(sslStream)
                DisplaySecurityServices(sslStream)
                DisplayCertificateInformation(sslStream)
                DisplayStreamProperties(sslStream)

                ' Set timeouts for the read and write to 5 seconds.
                sslStream.ReadTimeout = 5000
                sslStream.WriteTimeout = 5000

                ' Read a message from the client.   
                Console.WriteLine("Waiting for client message...")
                Dim messageData As String = ReadMessage(sslStream)
                Console.WriteLine("Received: {0}", messageData)

                ' Write a message to the client.
                Dim message As Byte() = Encoding.UTF8.GetBytes("Hello from the server.<EOF>")
                Console.WriteLine("Sending hello message.")
                sslStream.Write(message)
            Catch e As AuthenticationException
                Console.WriteLine("Exception: {0}", e.Message)

                If e.InnerException IsNot Nothing Then
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
                End If

                Console.WriteLine("Authentication failed - closing the connection.")
                sslStream.Close()
                client.Close()
                Return
            Finally
                ' The client stream will be closed with the sslStream
                ' because we specified this behavior when creating
                ' the sslStream.
                sslStream.Close()
                client.Close()
            End Try
        End Sub

        Private Shared Function ReadMessage(sslStream As SslStream) As String

            ' Read the  message sent by the client.
            ' The client signals the end of the message using the
            ' "<EOF>" marker.
            Dim buffer As Byte() = New Byte(2048) {}
            Dim messageData As StringBuilder = New StringBuilder()
            Dim bytes As Integer = -1

            Do
                ' Read the client's test message.
                bytes = sslStream.Read(buffer, 0, buffer.Length)

                ' Use decoder class to convert from bytes to UTF8
                ' in case a character spans two buffers.
                Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
                Dim chars As Char() = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
                decoder.GetChars(buffer, 0, bytes, chars, 0)
                messageData.Append(chars)

                ' Check for EOF or an empty message.
                If messageData.ToString().IndexOf("<EOF>") <> -1 Then
                    Exit Do
                End If
            Loop While bytes <> 0

            Return messageData.ToString()
        End Function

        Private Shared Sub DisplaySecurityLevel(stream As SslStream)
            Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength)
            Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength)
            Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength)
            Console.WriteLine("Protocol: {0}", stream.SslProtocol)
        End Sub

        Private Shared Sub DisplaySecurityServices(stream As SslStream)
            Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer)
            Console.WriteLine("IsSigned: {0}", stream.IsSigned)
            Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted)
        End Sub

        Private Shared Sub DisplayStreamProperties(stream As SslStream)
            Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite)
            Console.WriteLine("Can timeout: {0}", stream.CanTimeout)
        End Sub

        Private Shared Sub DisplayCertificateInformation(stream As SslStream)
            Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus)
            Dim localCertificate As X509Certificate = stream.LocalCertificate

            If stream.LocalCertificate IsNot Nothing Then
                Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.", localCertificate.Subject, localCertificate.GetEffectiveDateString(), localCertificate.GetExpirationDateString())
            Else
                Console.WriteLine("Local certificate is null.")
            End If

            ' Display the properties of the client's certificate.
            Dim remoteCertificate As X509Certificate = stream.RemoteCertificate

            If stream.RemoteCertificate IsNot Nothing Then
                Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.", remoteCertificate.Subject, remoteCertificate.GetEffectiveDateString(), remoteCertificate.GetExpirationDateString())
            Else
                Console.WriteLine("Remote certificate is null.")
            End If
        End Sub

        Private Shared Sub DisplayUsage()
            Console.WriteLine("To start the server specify:")
            Console.WriteLine("serverSync certificateFile.cer")
            Environment.[Exit](1)
        End Sub

        Public Shared Function Main(ByVal args As String()) As Integer
            Dim certificate As String

            If args Is Nothing OrElse args.Length < 1 Then
                DisplayUsage()
            End If

            certificate = args(0)
            RunServer(certificate)
            Return 0
        End Function
    End Class
End Namespace

L’exemple de code suivant montre comment créer un TcpClient qui utilise la SslStream classe pour communiquer avec un serveur.The following code example demonstrates creating a TcpClient that uses the SslStream class to communicate with a server.

#using <System.dll>
#using <System.Security.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Security::Authentication;
using namespace System::Text;
using namespace System::Security::Cryptography::X509Certificates;
using namespace System::IO;

namespace NlsClientSync
{
    public ref class SslTcpClient
    {
    private:
        static Hashtable^ certificateErrors = gcnew Hashtable;
        // Load a table of errors that might cause 
        // the certificate authentication to fail.
        static void InitializeCertificateErrors()
        {
            certificateErrors->Add(0x800B0101,
                "The certification has expired.");
            certificateErrors->Add(0x800B0104,
                "A path length constraint "
                "in the certification chain has been violated.");
            certificateErrors->Add(0x800B0105,
                "A certificate contains an unknown extension "
                "that is marked critical.");
            certificateErrors->Add(0x800B0107,
                "A parent of a given certificate in fact "
                "did not issue that child certificate.");
            certificateErrors->Add(0x800B0108,
                "A certificate is missing or has an empty value "
                "for a necessary field.");
            certificateErrors->Add(0x800B0109,
                "The certificate root is not trusted.");
            certificateErrors->Add(0x800B010C,
                "The certificate has been revoked.");
            certificateErrors->Add(0x800B010F,
                "The name in the certificate does not not match "
                "the host name requested by the client.");
            certificateErrors->Add(0x800B0111,
                "The certificate was explicitly marked "
                "as untrusted by the user.");
            certificateErrors->Add(0x800B0112,
                "A certification chain processed correctly, "
                "but one of the CA certificates is not trusted.");
            certificateErrors->Add(0x800B0113,
                "The certificate has an invalid policy.");
            certificateErrors->Add(0x800B0114,
                "The certificate name is either not "
                "in the permitted list or is explicitly excluded.");
            certificateErrors->Add(0x80092012,
                "The revocation function was unable to check "
                "revocation for the certificate.");
            certificateErrors->Add(0x80090327,
                "An unknown error occurred while "
                "processing the certificate.");
            certificateErrors->Add(0x80096001,
                "A system-level error occurred "
                "while verifying trust.");
            certificateErrors->Add(0x80096002,
                "The certificate for the signer of the message "
                "is invalid or not found.");
            certificateErrors->Add(0x80096003,
                "One of the counter signatures was invalid.");
            certificateErrors->Add(0x80096004,
                "The signature of the certificate "
                "cannot be verified.");
            certificateErrors->Add(0x80096005,
                "The time stamp signature or certificate "
                "could not be verified or is malformed.");
            certificateErrors->Add(0x80096010,
                "The digital signature of the object "
                "was not verified.");
            certificateErrors->Add(0x80096019,
                "The basic constraint extension of a certificate "
                "has not been observed.");
        }

        static String^ CertificateErrorDescription(UInt32 problem)
        {
            // Initialize the error message dictionary 
            // if it is not yet available.
            if (certificateErrors->Count == 0)
            {
                InitializeCertificateErrors();
            }

            String^ description = safe_cast<String^>(
                certificateErrors[problem]);
            if (description == nullptr)
            {
                description = String::Format(
                    CultureInfo::CurrentCulture,
                    "Unknown certificate error - 0x{0:x8}",
                    problem);
            }

            return description;
        }

    public:
        // The following method is invoked 
        // by the CertificateValidationDelegate.
    static bool ValidateServerCertificate(
            Object^ sender,
            X509Certificate^ certificate,
            X509Chain^ chain,
            SslPolicyErrors sslPolicyErrors)
        {
        
            Console::WriteLine("Validating the server certificate.");
            if (sslPolicyErrors == SslPolicyErrors::None)
                return true;

            Console::WriteLine("Certificate error: {0}", sslPolicyErrors);

            // Do not allow this client to communicate with unauthenticated servers.
            return false;
        }

        static void RunClient(String^ machineName, String^ serverName)
        {
              
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient^ client = gcnew TcpClient(machineName, 8080);
            Console::WriteLine("Client connected.");
              
            // Create an SSL stream that will close 
            // the client's stream.
            SslStream^ sslStream = gcnew SslStream(
                client->GetStream(), false,
                gcnew RemoteCertificateValidationCallback(ValidateServerCertificate),
                nullptr);
              
            // The server name must match the name
            // on the server certificate.
            try
            {
                sslStream->AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException^ ex) 
            {
                Console::WriteLine("Exception: {0}", ex->Message);
                if (ex->InnerException != nullptr)
                {
                    Console::WriteLine("Inner exception: {0}", 
                        ex->InnerException->Message);
                }

                Console::WriteLine("Authentication failed - "
                    "closing the connection.");
                sslStream->Close();
                client->Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            array<Byte>^ messsage = Encoding::UTF8->GetBytes(
                "Hello from the client.<EOF>");
              
            // Send hello message to the server.
            sslStream->Write(messsage);
            sslStream->Flush();
            // Read message from the server.
            String^ serverMessage = ReadMessage(sslStream);
            Console::WriteLine("Server says: {0}", serverMessage);
           
            // Close the client connection.
            sslStream->Close();
            client->Close();
            Console::WriteLine("Client closed.");
        }
    private:
        static String^ ReadMessage(SslStream^ sslStream)
        {
              
            // Read the  message sent by the server.
            // The end of the message is signaled using the
            // "<EOF>" marker.
            array<Byte>^ buffer = gcnew array<Byte>(2048);
            StringBuilder^ messageData = gcnew StringBuilder;
            // Use Decoder class to convert from bytes to UTF8
            // in case a character spans two buffers.
            Encoding^ u8 = Encoding::UTF8;
            Decoder^ decoder = u8->GetDecoder();

            int bytes = -1;
            do
            {
                bytes = sslStream->Read(buffer, 0, buffer->Length);
                 
                array<__wchar_t>^ chars = gcnew array<__wchar_t>(
                    decoder->GetCharCount(buffer, 0, bytes));
                decoder->GetChars(buffer, 0, bytes, chars, 0);
                messageData->Append(chars);
                 
                // Check for EOF.
                if (messageData->ToString()->IndexOf("<EOF>") != -1)
                {
                    break;
                }
            }
            while (bytes != 0);

            return messageData->ToString();
        }
    };
}

int main()
{
    array<String^>^ args = Environment::GetCommandLineArgs();
    String^ serverCertificateName = nullptr;
    String^ machineName = nullptr;
    if (args == nullptr || args->Length < 2)
    {
        Console::WriteLine("To start the client specify:");
        Console::WriteLine("clientSync machineName [serverName]");
        return 1;
    }
        
    // User can specify the machine name and server name.
    // Server name must match the name on 
    // the server's certificate.
    machineName = args[1];
    if (args->Length < 3)
    {
        serverCertificateName = machineName;
    }
    else
    {
        serverCertificateName = args[2];
    };

    NlsClientSync::SslTcpClient::RunClient(machineName,
        serverCertificateName);

    return 0;
}

using System;
using System.Collections;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace Examples.System.Net
{
    public class SslTcpClient
    {
        private static Hashtable certificateErrors = new Hashtable();

        // The following method is invoked by the RemoteCertificateValidationDelegate.
        public static bool ValidateServerCertificate(
              object sender,
              X509Certificate certificate,
              X509Chain chain,
              SslPolicyErrors sslPolicyErrors)
        {
           if (sslPolicyErrors == SslPolicyErrors.None)
                return true;

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors);

            // Do not allow this client to communicate with unauthenticated servers.
            return false;
        }
        public static void RunClient(string machineName, string serverName)
        {
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient client = new TcpClient(machineName,443);
            Console.WriteLine("Client connected.");
            // Create an SSL stream that will close the client's stream.
            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback (ValidateServerCertificate),
                null
                );
            // The server name must match the name on the server certificate.
            try
            {
                sslStream.AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                client.Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            byte[] messsage = Encoding.UTF8.GetBytes("Hello from the client.<EOF>");
            // Send hello message to the server.
            sslStream.Write(messsage);
            sslStream.Flush();
            // Read message from the server.
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage);
            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
        }
        static string ReadMessage(SslStream sslStream)
        {
            // Read the  message sent by the server.
            // The end of the message is signaled using the
            // "<EOF>" marker.
            byte [] buffer = new byte[2048];
            StringBuilder messageData = new StringBuilder();
            int bytes = -1;
            do
            {
                bytes = sslStream.Read(buffer, 0, buffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                Decoder decoder = Encoding.UTF8.GetDecoder();
                char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
                decoder.GetChars(buffer, 0, bytes, chars,0);
                messageData.Append (chars);
                // Check for EOF.
                if (messageData.ToString().IndexOf("<EOF>") != -1)
                {
                    break;
                }
            } while (bytes != 0);

            return messageData.ToString();
        }
        private static void DisplayUsage()
        {
            Console.WriteLine("To start the client specify:");
            Console.WriteLine("clientSync machineName [serverName]");
            Environment.Exit(1);
        }
        public static int Main(string[] args)
        {
            string serverCertificateName = null;
            string machineName = null;
            if (args == null ||args.Length <1 )
            {
                DisplayUsage();
            }
            // User can specify the machine name and server name.
            // Server name must match the name on the server's certificate.
            machineName = args[0];
            if (args.Length <2 )
            {
                serverCertificateName = machineName;
            }
            else
            {
                serverCertificateName = args[1];
            }
            SslTcpClient.RunClient (machineName, serverCertificateName);
            return 0;
        }
    }
}

Imports System.Collections
Imports System.Net
Imports System.Net.Security
Imports System.Net.Sockets
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Namespace Examples.System.Net

    Public Class SslTcpClient
        
        ' The following method is invoked by the RemoteCertificateValidationDelegate.
        Public Shared Function ValidateServerCertificate(
            sender As Object, 
            certificate As X509Certificate, 
            chain As X509Chain, 
            sslPolicyErrors As SslPolicyErrors) As Boolean
            
            If sslPolicyErrors = SslPolicyErrors.None Then Return True

            Console.WriteLine("Certificate error: {0}", sslPolicyErrors)

            ' Do not allow this client to communicate with unauthenticated servers.
            Return False
        End Function
        Public Shared Sub RunClient(machineName As String, serverName As String)

            ' Create a TCP/IP client socket.
            ' machineName is the host running the server application.
            Dim client = New TcpClient(machineName, 443)
            Console.WriteLine("Client connected.")

            ' Create an SSL stream that will close the client's stream.
            Dim sslStream = New SslStream(
                client.GetStream(), False, 
                New RemoteCertificateValidationCallback(AddressOf ValidateServerCertificate), Nothing)

            ' The server name must match the name on the server certificate.
            Try
                sslStream.AuthenticateAsClient(serverName)
            Catch e As AuthenticationException
                Console.WriteLine("Exception: {0}", e.Message)

                If e.InnerException IsNot Nothing Then
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
                End If

                Console.WriteLine("Authentication failed - closing the connection.")
                client.Close()
                Return
            End Try
            
            ' Encode a test message into a byte array.
            ' Signal the end of the message using the "<EOF>".
            Dim messsage As Byte() = Encoding.UTF8.GetBytes("Hello from the client.<EOF>")
            
            ' Send hello message to the server.
            sslStream.Write(messsage)
            sslStream.Flush()
            ' Read message from the server.
            Dim serverMessage = ReadMessage(sslStream)
            Console.WriteLine("Server says: {0}", serverMessage)

            ' Close the client connection
            client.Close()
            Console.WriteLine("Client closed.")
        End Sub
        
        Private Shared Function ReadMessage(sslStream As SslStream) As String

            ' Read the  message sent by the server.
            ' The end of the message is signaled using the "<EOF>" marker.
            Dim buffer = New Byte(2048) {}
            Dim messageData = New StringBuilder()
            Dim bytes As Integer

            Do
                bytes = sslStream.Read(buffer, 0, buffer.Length)

                ' Use Decoder class to convert from bytes to UTF8
                ' in case a character spans two buffers.        
                Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
                Dim chars = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
                decoder.GetChars(buffer, 0, bytes, chars, 0)
                messageData.Append(chars)

                ' Check for EOF.
                If messageData.ToString().IndexOf("<EOF>") <> -1 Then Exit Do
                
            Loop While bytes <> 0

            Return messageData.ToString()

        End Function

        Private Shared Sub DisplayUsage()

            Console.WriteLine("To start the client specify:")
            Console.WriteLine("clientSync machineName [serverName]")
            Environment.[Exit](1)

        End Sub

        Public Shared Function Main(args As String()) As Integer

            Dim serverCertificateName As String
            Dim machineName As String

            If args Is Nothing OrElse args.Length < 1 Then
                DisplayUsage()
            End If

            ' User can specify the machine name and server name.
            ' Server name must match the name on the server's certificate. 
            machineName = args(0)

            If args.Length < 2 Then
                serverCertificateName = machineName
            Else
                serverCertificateName = args(1)
            End If

            SslTcpClient.RunClient(machineName, serverCertificateName)

            Return 0

        End Function

    End Class

End Namespace

Remarques

Les protocoles SSL permettent de fournir une vérification de la confidentialité et de l’intégrité des messages transmis à l’aide d’un SslStream .SSL protocols help to provide confidentiality and integrity checking for messages transmitted using an SslStream. Une connexion SSL, telle que celle fournie par SslStream , doit être utilisée lors de la communication d’informations sensibles entre un client et un serveur.An SSL connection, such as that provided by SslStream, should be used when communicating sensitive information between a client and a server. L’utilisation d’un SslStream aide à empêcher quiconque de lire et de falsifier les informations pendant qu’elles sont en transit sur le réseau.Using an SslStream helps to prevent anyone from reading and tampering with information while it is in transit on the network.

Une SslStream instance transmet des données à l’aide d’un flux que vous fournissez lors de la création du SslStream .An SslStream instance transmits data using a stream that you supply when creating the SslStream. Lorsque vous fournissez ce flux sous-jacent, vous avez la possibilité de spécifier si la fermeture de SslStream ferme également le flux sous-jacent.When you supply this underlying stream, you have the option to specify whether closing the SslStream also closes the underlying stream. En général, la SslStream classe est utilisée avec TcpClient les TcpListener classes et.Typically, the SslStream class is used with the TcpClient and TcpListener classes. La GetStream méthode fournit un NetworkStream approprié pour une utilisation avec la SslStream classe.The GetStream method provides a NetworkStream suitable for use with the SslStream class.

Après la création d’un SslStream , le serveur et, le cas échéant, le client doit être authentifié.After creating an SslStream, the server and optionally, the client must be authenticated. Le serveur doit fournir un certificat x509 qui établit la preuve de son identité et peut demander que le client le fasse également.The server must provide an X509 certificate that establishes proof of its identity and can request that the client also do so. L’authentification doit être effectuée avant de transmettre des informations à l’aide d’un SslStream .Authentication must be performed before transmitting information using an SslStream. Les clients initialisent l’authentification à l’aide des méthodes synchrones AuthenticateAsClient , qui sont bloquées jusqu’à la fin de l’authentification, ou les méthodes asynchrones BeginAuthenticateAsClient , qui ne bloquent pas l’attente de la fin de l’authentification.Clients initiate authentication using the synchronous AuthenticateAsClient methods, which block until the authentication completes, or the asynchronous BeginAuthenticateAsClient methods, which do not block waiting for the authentication to complete. Les serveurs initialisent l’authentification à l’aide des méthodes synchrones AuthenticateAsServer ou asynchrones BeginAuthenticateAsServer .Servers initiate authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. Le client et le serveur doivent initier l’authentification.Both client and server must initiate the authentication.

L’authentification est gérée par le fournisseur de canaux SSPI (Security Support Provider).The authentication is handled by the Security Support Provider (SSPI) channel provider. Le client a la possibilité de contrôler la validation du certificat du serveur en spécifiant un RemoteCertificateValidationCallback délégué lors de la création d’un SslStream .The client is given an opportunity to control validation of the server's certificate by specifying a RemoteCertificateValidationCallback delegate when creating an SslStream. Le serveur peut également contrôler la validation en fournissant un RemoteCertificateValidationCallback délégué.The server can also control validation by supplying a RemoteCertificateValidationCallback delegate. La méthode référencée par le délégué comprend le certificat du tiers distant et les erreurs qui se sont produites lors de la validation du certificat.The method referenced by the delegate includes the remote party's certificate and any errors SSPI encountered while validating the certificate. Notez que si le serveur spécifie un délégué, la méthode du délégué est appelée, que le serveur ait demandé l’authentification du client ou non.Note that if the server specifies a delegate, the delegate's method is invoked regardless of whether the server requested client authentication. Si le serveur n’a pas demandé l’authentification du client, la méthode déléguée du serveur reçoit un certificat NULL et un tableau vide d’erreurs de certificat.If the server did not request client authentication, the server's delegate method receives a null certificate and an empty array of certificate errors.

Si le serveur requiert l’authentification du client, le client doit spécifier un ou plusieurs certificats pour l’authentification.If the server requires client authentication, the client must specify one or more certificates for authentication. Si le client possède plusieurs certificats, le client peut fournir un LocalCertificateSelectionCallback délégué pour sélectionner le certificat approprié pour le serveur.If the client has more than one certificate, the client can provide a LocalCertificateSelectionCallback delegate to select the correct certificate for the server. Les certificats du client doivent se trouver dans le magasin de certificats « My » de l’utilisateur actuel.The client's certificates must be located in the current user's "My" certificate store. L’authentification du client via des certificats n’est pas prise en charge pour le Ssl2 protocole (SSL version 2).Client authentication via certificates is not supported for the Ssl2 (SSL version 2) protocol.

Si l’authentification échoue, vous recevez un AuthenticationException et SslStream n’est plus utilisable.If the authentication fails, you receive a AuthenticationException, and the SslStream is no longer useable. Vous devez fermer cet objet et supprimer toutes les références à ce dernier afin qu’il puisse être collecté par le garbage collector.You should close this object and remove all references to it so that it can be collected by the garbage collector.

Lorsque le processus d’authentification, également appelé négociation SSL, s’effectue correctement, l’identité du serveur (et éventuellement le client) est établie et le SslStream peut être utilisé par le client et le serveur pour échanger des messages.When the authentication process, also known as the SSL handshake, succeeds, the identity of the server (and optionally, the client) is established and the SslStream can be used by the client and server to exchange messages. Avant d’envoyer ou de recevoir des informations, le client et le serveur doivent vérifier les services de sécurité et les niveaux fournis par le SslStream pour déterminer si le protocole, les algorithmes et les forces sélectionnées répondent à leurs exigences en matière d’intégrité et de confidentialité.Before sending or receiving information, the client and server should check the security services and levels provided by the SslStream to determine whether the protocol, algorithms, and strengths selected meet their requirements for integrity and confidentiality. Si les paramètres actuels ne sont pas suffisants, le flux doit être fermé.If the current settings are not sufficient, the stream should be closed. Vous pouvez vérifier les services de sécurité fournis par SslStream à l’aide des IsEncrypted IsSigned Propriétés et.You can check the security services provided by the SslStream using the IsEncrypted and IsSigned properties. Le tableau suivant présente les éléments qui signalent les paramètres de chiffrement utilisés pour l’authentification, le chiffrement et la signature des données.The following table shows the elements that report the cryptographic settings used for authentication, encryption and data signing.

ÉlémentElement MembresMembers
Protocole de sécurité utilisé pour authentifier le serveur et, éventuellement, le client.The security protocol used to authenticate the server and, optionally, the client. La SslProtocol propriété et l' SslProtocols énumération associée.The SslProtocol property and the associated SslProtocols enumeration.
Algorithme d’échange de clés.The key exchange algorithm. La KeyExchangeAlgorithm propriété et l' ExchangeAlgorithmType énumération associée.The KeyExchangeAlgorithm property and the associated ExchangeAlgorithmType enumeration.
Algorithme d’intégrité des messages.The message integrity algorithm. La HashAlgorithm propriété et l' HashAlgorithmType énumération associée.The HashAlgorithm property and the associated HashAlgorithmType enumeration.
Algorithme de confidentialité des messages.The message confidentiality algorithm. La CipherAlgorithm propriété et l' CipherAlgorithmType énumération associée.The CipherAlgorithm property and the associated CipherAlgorithmType enumeration.
Points forts des algorithmes sélectionnés.The strengths of the selected algorithms. KeyExchangeStrengthPropriétés, HashStrength et CipherStrength .The KeyExchangeStrength, HashStrength, and CipherStrength properties.

Après une authentification réussie, vous pouvez envoyer des données à l’aide des méthodes synchrones Write ou asynchrones BeginWrite .After a successful authentication, you can send data using the synchronous Write or asynchronous BeginWrite methods. Vous pouvez recevoir des données à l’aide des méthodes synchrones Read ou asynchrones BeginRead .You can receive data using the synchronous Read or asynchronous BeginRead methods.

Si vous avez spécifié au SslStream que le flux sous-jacent doit être laissé ouvert, vous êtes chargé de fermer ce flux de travail lorsque vous avez fini de l’utiliser.If you specified to the SslStream that the underlying stream should be left open, you are responsible for closing that stream when you are done using it.

Notes

Si l’application qui crée l' SslStream objet s’exécute avec les informations d’identification d’un utilisateur normal, l’application ne sera pas en mesure d’accéder aux certificats installés dans le magasin de l’ordinateur local, sauf si l’autorisation a été explicitement accordée à l’utilisateur.If the application that creates the SslStream object runs with the credentials of a Normal user, the application will not be able to access certificates installed in the local machine store unless permission has been explicitly given to the user to do so.

SslStream suppose qu’un délai d’expiration ainsi que tout autre IOException moment où une exception est levée à partir du flux interne sont traités comme étant irrécupérables par son appelant.SslStream assumes that a timeout along with any other IOException when one is thrown from the inner stream will be treated as fatal by its caller. La réutilisation d’une SslStream instance après un délai d’attente renverra un garbage.Reusing a SslStream instance after a timeout will return garbage. Une application doit Close SslStream , et lever une exception dans ces cas.An application should Close the SslStream and throw an exception in these cases.

La .NET Framework 4,6 comprend une nouvelle fonctionnalité de sécurité qui bloque les algorithmes de hachage et de chiffrement non sécurisés pour les connexions.The .NET Framework 4.6 includes a new security feature that blocks insecure cipher and hashing algorithms for connections. Les applications utilisant TLS/SSL via des API telles que HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream, etc. et ciblant .NET Framework 4,6 obtiennent le comportement plus sécurisé par défaut.Applications using TLS/SSL through APIs such as HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream, etc. and targeting .NET Framework 4.6 get the more-secure behavior by default.

Les développeurs peuvent souhaiter désactiver ce comportement afin de maintenir l’interopérabilité avec leurs services SSL3 ou les services TLS w/RC4 existants.Developers may want to opt out of this behavior in order to maintain interoperability with their existing SSL3 services OR TLS w/ RC4 services. Cet article explique comment modifier votre code afin que le nouveau comportement soit désactivé.This article explains how to modify your code so that the new behavior is disabled.

La .NET Framework 4,7 ajoute de nouvelles surcharges pour les méthodes qui authentifient des SslStreams qui ne spécifient pas de version TLS, mais utilisent à la place la version TLS définie en tant que valeur système par défaut dans Schannel.The .NET Framework 4.7 adds new overloads for the methods that authenticate SslStreams that do not specify a TLS version, but instead use the TLS version defined as the system default in SCHANNEL. Utilisez ces méthodes dans votre application pour pouvoir modifier ultérieurement les valeurs par défaut, car les meilleures pratiques de la version TLS changent au fil du temps, sans qu’il soit nécessaire de régénérer et redéployer votre application.Use these methods in your app as a way to be able to later modify the defaults as TLS version best practice changes over time, without the need to rebuild and redeploy your app.

Consultez également meilleures pratiques de TLS (Transport Layer Security) avec le .NET Framework.Also see Transport Layer Security (TLS) best practices with the .NET Framework.

Constructeurs

SslStream(Stream)

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

SslStream(Stream, Boolean)

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

SslStream(Stream, Boolean, RemoteCertificateValidationCallback)

Initialise une nouvelle instance de la classe SslStream en utilisant Stream, le comportement de clôture de flux et le délégué de validation de certificat spécifiés.Initializes a new instance of the SslStream class using the specified Stream, stream closure behavior and certificate validation delegate.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)

Initialise une nouvelle instance de la classe SslStream en utilisant Stream, le comportement de clôture de flux, le délégué de validation de certificat et le délégué de sélection de certificat spécifiés.Initializes a new instance of the SslStream class using the specified Stream, stream closure behavior, certificate validation delegate and certificate selection delegate.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)

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

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.

CheckCertRevocationStatus

Obtient une valeur Boolean qui indique si la liste de révocation de certificats est vérifiée au cours du processus de validation des certificats.Gets a Boolean value that indicates whether the certificate revocation list is checked during the certificate validation process.

CipherAlgorithm

Obtient une valeur qui identifie l'algorithme de chiffrement en bloc utilisé par ce SslStream.Gets a value that identifies the bulk encryption algorithm used by this SslStream.

CipherStrength

Obtient une valeur qui identifie la puissance de l'algorithme de chiffrement utilisé par ce SslStream.Gets a value that identifies the strength of the cipher algorithm used by this SslStream.

HashAlgorithm

Obtient l'algorithme utilisé pour générer des codes d'authentification de messages (MAC).Gets the algorithm used for generating message authentication codes (MACs).

HashStrength

Obtient une valeur qui identifie la puissance de l'algorithme de hachage utilisé par cette instance.Gets a value that identifies the strength of the hash algorithm used by this instance.

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 SslStream utilise le chiffrement de données.Gets a Boolean value that indicates whether this SslStream 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 server and client have been authenticated.

IsServer

Obtient une valeur Boolean qui indique si le côté local de la connexion utilisée par ce SslStream a été authentifié comme serveur.Gets a Boolean value that indicates whether the local side of the connection used by this SslStream 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.

KeyExchangeAlgorithm

Obtient l'algorithme d'échange de clé utilisé par ce SslStream.Gets the key exchange algorithm used by this SslStream.

KeyExchangeStrength

Obtient une valeur qui identifie la puissance de l'algorithme d'échange de clé utilisé par cette instance.Gets a value that identifies the strength of the key exchange algorithm used by this instance.

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.

LocalCertificate

Obtient le certificat utilisé pour authentifier le point de terminaison local.Gets the certificate used to authenticate the local endpoint.

NegotiatedApplicationProtocol

Protocole d’application négocié dans le protocole de transfert TLS.The negotiated application protocol in TLS handshake.

NegotiatedCipherSuite

Obtient la suite de chiffrement qui a été négociée pour cette connexion.Gets the cipher suite which was negotiated for this connection.

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, exprimée en millisecondes, pendant laquelle une opération de lecture reste bloquée en attendant des données.Gets or sets the amount of time, expressed in milliseconds, a read operation blocks waiting for data.

RemoteCertificate

Obtient le certificat utilisé pour authentifier le point de terminaison distant.Gets the certificate used to authenticate the remote endpoint.

SslProtocol

Obtient une valeur qui indique le protocole de sécurité utilisé pour authentifier cette connexion.Gets a value that indicates the security protocol used to authenticate this connection.

TargetHostName

Obtient le nom du serveur auquel le client tente de se connecter.Gets the name of the server the client is trying to connect to. Ce nom est utilisé pour la validation du certificat de serveur.That name is used for server certificate validation. Il peut s’agir d’un nom DNS ou d’une adresse IP.It can be a DNS name or an IP address.

TransportContext

Obtient le TransportContext utilisé pour l'authentification à l'aide de la protection étendue.Gets the TransportContext used for authentication using extended protection.

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(SslClientAuthenticationOptions)

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

AuthenticateAsClient(String)

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

AuthenticateAsClient(String, X509CertificateCollection, Boolean)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur.Called by clients to authenticate the server and optionally the client in a client-server connection. Le processus d’authentification utilise la collection de certificats spécifiée et le protocole SSL par défaut du système.The authentication process uses the specified certificate collection, and the system default SSL protocol.

AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur.Called by clients to authenticate the server and optionally the client in a client-server connection. Le processus d'authentification utilise la collection de certificats spécifiée et le protocole SSL.The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Le processus d’authentification utilise les informations spécifiées dans le conteneur de propriétés sslClientAuthenticationOptions.The authentication process uses information specified in the sslClientAuthenticationOptions property bag.

AuthenticateAsClientAsync(String)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Le processus d’authentification utilise la collection de certificats spécifiée et le protocole SSL par défaut du système.The authentication process uses the specified certificate collection and the system default SSL protocol.

AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)

Appelé par les clients pour authentifier le serveur et éventuellement le client dans une connexion client-serveur en tant qu’opération asynchrone.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Le processus d'authentification utilise la collection de certificats spécifiée et le protocole SSL.The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsServer(SslServerAuthenticationOptions)

Appelé par les serveurs pour authentifier le serveur, et éventuellement le client, dans une connexion client-serveur à l'aide du certificat spécifié.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate.

AuthenticateAsServer(X509Certificate)

Appelé par les serveurs pour authentifier le serveur, et éventuellement le client, dans une connexion client-serveur à l'aide du certificat spécifié.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate.

AuthenticateAsServer(X509Certificate, Boolean, Boolean)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide des certificats spécifiés, de la configuration requise et avec le protocole de sécurité par défaut du système.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates and requirements, and using the system default security protocol.

AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide des certificats spécifiés, de la configuration requise et du protocole de sécurité.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol.

AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken)

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

AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)

Appelé par les serveurs pour authentifier le serveur, et éventuellement le client, dans une connexion client-serveur sous forme d'opération asynchrone.Called by servers to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Le processus d’authentification utilise les informations spécifiées dans le conteneur de propriétés sslClientAuthenticationOptions.The authentication process uses information specified in the sslClientAuthenticationOptions property bag.

AuthenticateAsServerAsync(X509Certificate)

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

AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide des certificats spécifiés, de la configuration requise et du protocole de sécurité au cours d’une opération asynchrone.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol as an asynchronous operation.

AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean)

Appelé par les serveurs pour authentifier le serveur et éventuellement le client dans une connexion client-serveur à l’aide des certificats spécifiés, de la configuration requise et du protocole de sécurité au cours d’une opération asynchrone.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificates, requirements and security protocol as an asynchronous operation.

BeginAuthenticateAsClient(String, AsyncCallback, Object)

Appelé par les clients pour commencer une opération asynchrone pour authentifier le serveur et, éventuellement, le client.Called by clients to begin an asynchronous operation to authenticate the server and optionally the client.

BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object)

Appelé par les clients pour lancer une opération asynchrone d’authentification du serveur et éventuellement du client à l’aide des certificats spécifiés et du protocole de sécurité par défaut du système.Called by clients to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and the system default security protocol.

BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)

Appelé par les clients pour commencer une opération asynchrone pour authentifier le serveur et éventuellement le client à l'aide des certificats spécifiés et du protocole de sécurité.Called by clients to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and security protocol.

BeginAuthenticateAsServer(X509Certificate, 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.

BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object)

Appelé par les serveurs pour lancer une opération asynchrone d’authentification du serveur et éventuellement du client à l’aide des certificats spécifiés, de la configuration requise et du protocole de sécurité par défaut du système.Called by servers to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates and requirements, and the system default security protocol.

BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)

Appelé par les serveurs pour lancer une opération asynchrone d’authentification du serveur et éventuellement du client à l’aide des certificats spécifiés, de la configuration requise et du protocole de sécurité.Called by servers to begin an asynchronous operation to authenticate the server and optionally the client using the specified certificates, requirements and security protocol.

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.

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

Débute une opération de lecture asynchrone.Begins an asynchronous read operation. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
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.

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

Débute une opération d'écriture asynchrone.Begins an asynchronous write operation. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Hérité de 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()
Obsolète.

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 SslStream et libère éventuellement les ressources managées.Releases the unmanaged resources used by the SslStream and optionally releases the managed resources.

Dispose(Boolean)

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

(Hérité de AuthenticatedStream)
DisposeAsync()

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

DisposeAsync()

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

(Hérité de AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)

Termine une opération d'authentification du serveur asynchrone en attente, démarrée avec un appel précédent à BeginAuthenticateAsClient.Ends a pending asynchronous server authentication operation started with a previous call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Termine une opération d'authentification du client asynchrone en attente, démarrée avec un appel précédent à BeginAuthenticateAsClient.Ends a pending asynchronous client authentication operation started with a previous call to BeginAuthenticateAsClient.

EndRead(IAsyncResult)

Termine une opération de lecture asynchrone démarrée avec un appel précédent à BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).Ends an asynchronous read operation started with a previous call to BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndRead(IAsyncResult)

Attend que la requête asynchrone en attente se termine.Waits for the pending asynchronous read to complete. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone démarrée avec un appel précédent à BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).Ends an asynchronous write operation started with a previous call to BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone.Ends an asynchronous write operation. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
Equals(Object)

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

(Hérité de Object)
Finalize()

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

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)

Écrit de manière asynchrone des données mises en mémoire tampon sur l’appareil sous-jacent.Asynchronously writes any buffered data to the underlying device.

FlushAsync(CancellationToken)

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

(Hérité de Stream)
GetHashCode()

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

(Hérité de Object)
GetLifetimeService()
Obsolète.

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()
Obsolète.

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 du 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()
Obsolète.

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 les données de ce flux et les stocke dans la plage spécifiée d’un tableau d’octets.Asynchronously reads data from this stream and stores it in the specified range of a byte array.

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 les données de ce flux et les stocke dans la plage de mémoire spécifiée.Asynchronously reads data from this stream and stores it in the specified memory range.

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 dans SslStream 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 SslStream and advances the position within the stream by one byte, or returns -1 if at the end of the 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 un NotSupportedException.Throws a NotSupportedException.

SetLength(Int64)

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

ShutdownAsync()

Arrête ce SslStream.Shuts down this SslStream.

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[])

Écrit les données spécifiées dans ce flux.Writes the specified data to this stream.

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 les données dans le flux sous-jacent à partir de la plage spécifiée d’un tableau d’octets.Asynchronously writes data to the underlying stream from the specified range of a byte array.

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 des données dans le flux sous-jacent à partir d’une plage de mémoire d’octets en lecture seule.Asynchronously writes data to the underlying stream from a read-only byte memory range.

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)

Méthodes d’extension

ConfigureAwait(IAsyncDisposable, Boolean)

Configure la façon dont les attentes sur les tâches retournées à partir d’un élément supprimable asynchrone sont effectuées.Configures how awaits on the tasks returned from an async disposable are performed.

S’applique à

Voir aussi