SslStream Klasa

Definicja

Zapewnia strumień używany do komunikacji klient-serwer, który używa protokołu zabezpieczeń Secure Socket Layer (SSL) do uwierzytelniania serwera i opcjonalnie klienta.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
Dziedziczenie
Dziedziczenie
Implementuje

Przykłady

Poniższy przykład kodu demonstruje tworzenie TcpListener , które używa SslStream klasy do komunikowania się z klientami.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

Poniższy przykład kodu demonstruje tworzenie TcpClient , które używa SslStream klasy do komunikowania się z serwerem.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

Uwagi

Protokoły SSL pomagają zapewnić poufność i sprawdzanie integralności komunikatów przesyłanych przy użyciu SslStream .SSL protocols help to provide confidentiality and integrity checking for messages transmitted using an SslStream. Połączenie SSL, takie jak dostarczone przez SslStream , powinno być używane podczas komunikowania poufnych informacji między klientem a serwerem.An SSL connection, such as that provided by SslStream, should be used when communicating sensitive information between a client and a server. Korzystanie z SslStream pomaga zapobiegać odczytywaniu i manipulowaniu informacjami podczas przesyłania ich w sieci.Using an SslStream helps to prevent anyone from reading and tampering with information while it is in transit on the network.

SslStreamWystąpienie przesyła dane przy użyciu strumienia dostarczanego podczas tworzenia SslStream .An SslStream instance transmits data using a stream that you supply when creating the SslStream. Po dostarczeniu tego strumienia bazowego można określić, czy zamknięcie tego SslStream strumienia spowoduje również zamknięcie źródłowego.When you supply this underlying stream, you have the option to specify whether closing the SslStream also closes the underlying stream. Zazwyczaj SslStream Klasa jest używana z TcpClient TcpListener klasami i.Typically, the SslStream class is used with the TcpClient and TcpListener classes. GetStreamMetoda zapewnia NetworkStream odpowiednie do użycia z SslStream klasą.The GetStream method provides a NetworkStream suitable for use with the SslStream class.

Po utworzeniu SslStream serwera, serwerze i opcjonalnie należy uwierzytelnić klienta.After creating an SslStream, the server and optionally, the client must be authenticated. Serwer musi dostarczyć certyfikat x509, który ustanowi potwierdzenie tożsamości i może zażądać tego klienta.The server must provide an X509 certificate that establishes proof of its identity and can request that the client also do so. Przed przesłaniem informacji przy użyciu usługi należy przeprowadzić uwierzytelnianie SslStream .Authentication must be performed before transmitting information using an SslStream. Klienci inicjują uwierzytelnianie przy użyciu AuthenticateAsClient metod synchronicznych, które blokują do momentu zakończenia uwierzytelniania lub metod asynchronicznych BeginAuthenticateAsClient , które nie blokują oczekiwania na ukończenie uwierzytelniania.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. Serwery inicjują uwierzytelnianie przy użyciu AuthenticateAsServer metod synchronicznych lub asynchronicznych BeginAuthenticateAsServer .Servers initiate authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. Zarówno klient, jak i serwer muszą inicjować uwierzytelnianie.Both client and server must initiate the authentication.

Uwierzytelnianie jest obsługiwane przez dostawcę kanału obsługi zabezpieczeń (SSPI).The authentication is handled by the Security Support Provider (SSPI) channel provider. Klient uzyskuje możliwość kontroli poprawności certyfikatu serwera przez określenie RemoteCertificateValidationCallback delegata podczas tworzenia SslStream .The client is given an opportunity to control validation of the server's certificate by specifying a RemoteCertificateValidationCallback delegate when creating an SslStream. Serwer może również kontrolować walidację, dostarczając RemoteCertificateValidationCallback delegata.The server can also control validation by supplying a RemoteCertificateValidationCallback delegate. Metoda, do której odwołuje się delegat, obejmuje certyfikat strony zdalnej oraz wszystkie błędy, które zostały wykryte podczas weryfikacji certyfikatu.The method referenced by the delegate includes the remote party's certificate and any errors SSPI encountered while validating the certificate. Należy pamiętać, że jeśli serwer określa delegata, metoda obiektu delegowanego jest wywoływana niezależnie od tego, czy serwer zażądał uwierzytelnienia klienta.Note that if the server specifies a delegate, the delegate's method is invoked regardless of whether the server requested client authentication. Jeśli serwer nie zażądał uwierzytelnienia klienta, Metoda delegowania serwera odbiera certyfikat o wartości null i pustą tablicę błędów certyfikatów.If the server did not request client authentication, the server's delegate method receives a null certificate and an empty array of certificate errors.

Jeśli serwer wymaga uwierzytelniania klienta, klient musi określić co najmniej jeden certyfikat do uwierzytelnienia.If the server requires client authentication, the client must specify one or more certificates for authentication. Jeśli klient ma więcej niż jeden certyfikat, klient może dostarczyć LocalCertificateSelectionCallback delegata, aby wybrać poprawny certyfikat dla serwera.If the client has more than one certificate, the client can provide a LocalCertificateSelectionCallback delegate to select the correct certificate for the server. Certyfikaty klienta muszą znajdować się w magazynie certyfikatów bieżącego użytkownika.The client's certificates must be located in the current user's "My" certificate store. Uwierzytelnianie klienta za pośrednictwem certyfikatów nie jest obsługiwane w przypadku Ssl2 protokołu SSL w wersji 2.Client authentication via certificates is not supported for the Ssl2 (SSL version 2) protocol.

Jeśli uwierzytelnianie nie powiedzie się, otrzymasz komunikat AuthenticationException i SslStream nie jest już użyteczny.If the authentication fails, you receive a AuthenticationException, and the SslStream is no longer useable. Należy zamknąć ten obiekt i usunąć z niego wszystkie odwołania, aby można było go zebrać przez moduł wyrzucania elementów bezużytecznych.You should close this object and remove all references to it so that it can be collected by the garbage collector.

Gdy proces uwierzytelniania, znany również jako uzgadnianie SSL, powiedzie się, tożsamość serwera (i opcjonalnie klient) jest ustanawiana i SslStream może być używana przez klienta i serwer do wymiany komunikatów.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. Przed wysłaniem lub odebraniem informacji, klient i serwer powinny sprawdzić usługi zabezpieczeń i poziomy udostępnione przez SslStream program, aby określić, czy wybrany protokół, algorytmy i siły spełniają wymagania dotyczące integralności i poufności.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. Jeśli bieżące ustawienia nie są wystarczające, strumień powinien zostać zamknięty.If the current settings are not sufficient, the stream should be closed. Możesz sprawdzić usługi zabezpieczeń podane przez SslStream IsEncrypted IsSigned właściwości i.You can check the security services provided by the SslStream using the IsEncrypted and IsSigned properties. W poniższej tabeli przedstawiono elementy, które raportują ustawienia kryptograficzne używane do uwierzytelniania, szyfrowania i podpisywania danych.The following table shows the elements that report the cryptographic settings used for authentication, encryption and data signing.

ElementElement Elementy członkowskieMembers
Protokół zabezpieczeń używany do uwierzytelniania serwera i, opcjonalnie, klienta.The security protocol used to authenticate the server and, optionally, the client. SslProtocolWłaściwość i skojarzone SslProtocols Wyliczenie.The SslProtocol property and the associated SslProtocols enumeration.
Algorytm wymiany kluczy.The key exchange algorithm. KeyExchangeAlgorithmWłaściwość i skojarzone ExchangeAlgorithmType Wyliczenie.The KeyExchangeAlgorithm property and the associated ExchangeAlgorithmType enumeration.
Algorytm integralności komunikatów.The message integrity algorithm. HashAlgorithmWłaściwość i skojarzone HashAlgorithmType Wyliczenie.The HashAlgorithm property and the associated HashAlgorithmType enumeration.
Algorytm poufności komunikatów.The message confidentiality algorithm. CipherAlgorithmWłaściwość i skojarzone CipherAlgorithmType Wyliczenie.The CipherAlgorithm property and the associated CipherAlgorithmType enumeration.
Siły wybranych algorytmów.The strengths of the selected algorithms. KeyExchangeStrengthWłaściwości, HashStrength i CipherStrength .The KeyExchangeStrength, HashStrength, and CipherStrength properties.

Po pomyślnym uwierzytelnieniu można wysyłać dane przy użyciu metod synchronicznych Write lub asynchronicznych BeginWrite .After a successful authentication, you can send data using the synchronous Write or asynchronous BeginWrite methods. Dane można odbierać przy użyciu metod synchronicznych Read lub asynchronicznych BeginRead .You can receive data using the synchronous Read or asynchronous BeginRead methods.

Jeśli określisz, SslStream że źródłowy strumień powinien pozostać otwarty, użytkownik jest odpowiedzialny za zamknięcie tego strumienia po zakończeniu korzystania z niego.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.

Uwaga

Jeśli aplikacja, która tworzy SslStream obiekt, jest uruchamiana z poświadczeniami normalnego użytkownika, aplikacja nie będzie mogła uzyskać dostępu do certyfikatów zainstalowanych w lokalnym magazynie komputerowym, chyba że uprawnienie zostało jawnie przekazane Użytkownikowi.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 przyjęto założenie, że przekroczenie limitu czasu wraz z innymi, IOException gdy jeden z nich zostanie wygenerowany ze strumienia wewnętrznego będzie traktowany jako krytyczny przez jego obiekt wywołujący.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. Ponownie użycie SslStream wystąpienia po upływie limitu czasu spowoduje zwrócenie elementów bezużytecznych.Reusing a SslStream instance after a timeout will return garbage. Close SslStream W takich przypadkach aplikacja powinna być i zgłosić wyjątek.An application should Close the SslStream and throw an exception in these cases.

.NET Framework 4,6 obejmuje nową funkcję zabezpieczeń, która blokuje niebezpieczne algorytmy szyfrowania i wyznaczania wartości skrótu dla połączeń.The .NET Framework 4.6 includes a new security feature that blocks insecure cipher and hashing algorithms for connections. Aplikacje korzystające z protokołu TLS/SSL za pośrednictwem interfejsów API, takich jak HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream itp. i przeznaczonych dla .NET Framework 4,6, domyślnie uzyskają bezpieczniejsze zachowanie.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.

Deweloperzy mogą chcieć zrezygnować z tego zachowania, aby zachować współdziałanie z istniejącymi usługami SSL3 Services lub TLS/RC4.Developers may want to opt out of this behavior in order to maintain interoperability with their existing SSL3 services OR TLS w/ RC4 services. W tym artykule wyjaśniono, jak zmodyfikować kod w taki sposób, aby nowe zachowanie zostało wyłączone.This article explains how to modify your code so that the new behavior is disabled.

.NET Framework 4,7 dodaje nowe przeciążenia dla metod, które uwierzytelniają SslStreams, które nie określają wersji protokołu TLS, ale zamiast tego używają wersji protokołu TLS zdefiniowanej jako domyślny system w 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. Użyj tych metod w aplikacji jako sposobu, aby można było później zmodyfikować wartości domyślne jako najlepszych rozwiązań w zakresie protokołu TLS z upływem czasu, bez konieczności ponownego kompilowania i wdrażania aplikacji.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.

Zobacz również najlepsze rozwiązania Transport Layer Security (TLS) z .NET Framework.Also see Transport Layer Security (TLS) best practices with the .NET Framework.

Konstruktory

SslStream(Stream)

Inicjuje nowe wystąpienie SslStream klasy przy użyciu określonego elementu Stream .Initializes a new instance of the SslStream class using the specified Stream.

SslStream(Stream, Boolean)

Inicjuje nowe wystąpienie SslStream klasy przy użyciu określonego Stream i zamknięcia strumienia.Initializes a new instance of the SslStream class using the specified Stream and stream closure behavior.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback)

Inicjuje nowe wystąpienie SslStream klasy przy użyciu określonego Stream zachowania zamknięcia strumienia i delegata walidacji certyfikatu.Initializes a new instance of the SslStream class using the specified Stream, stream closure behavior and certificate validation delegate.

SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)

Inicjuje nowe wystąpienie SslStream klasy przy użyciu określonego Stream zachowania zamykania strumienia, delegata walidacji certyfikatu i delegata wyboru certyfikatu.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)

Inicjuje nowe wystąpienie SslStream klasy przy użyciu określonego StreamInitializes a new instance of the SslStream class using the specified Stream

Właściwości

CanRead

Pobiera Boolean wartość wskazującą, czy źródłowy strumień jest możliwy do odczytu.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

Pobiera Boolean wartość wskazującą, czy źródłowy strumień jest możliwy do przeszukania.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

Pobiera Boolean wartość wskazującą, czy źródłowy strumień obsługuje limity czasu.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

Pobiera Boolean wartość wskazującą, czy źródłowy strumień jest zapisywalny.Gets a Boolean value that indicates whether the underlying stream is writable.

CheckCertRevocationStatus

Pobiera Boolean wartość wskazującą, czy lista odwołania certyfikatów jest sprawdzana podczas procesu walidacji certyfikatu.Gets a Boolean value that indicates whether the certificate revocation list is checked during the certificate validation process.

CipherAlgorithm

Pobiera wartość, która identyfikuje algorytm szyfrowania zbiorczego używany przez ten element SslStream .Gets a value that identifies the bulk encryption algorithm used by this SslStream.

CipherStrength

Pobiera wartość, która identyfikuje siłę algorytmu szyfrowania używanego przez ten element SslStream .Gets a value that identifies the strength of the cipher algorithm used by this SslStream.

HashAlgorithm

Pobiera algorytm używany do generowania kodów uwierzytelniania wiadomości (Mac).Gets the algorithm used for generating message authentication codes (MACs).

HashStrength

Pobiera wartość, która identyfikuje siłę algorytmu wyznaczania wartości skrótu używanego przez to wystąpienie.Gets a value that identifies the strength of the hash algorithm used by this instance.

InnerStream

Pobiera strumień używany przez ten program AuthenticatedStream do wysyłania i otrzymywania danych.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Odziedziczone po AuthenticatedStream)
IsAuthenticated

Pobiera Boolean wartość wskazującą, czy uwierzytelnianie zakończyło się pomyślnie.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

Pobiera Boolean wartość wskazującą, czy jest SslStream używane szyfrowanie danych.Gets a Boolean value that indicates whether this SslStream uses data encryption.

IsMutuallyAuthenticated

Pobiera Boolean wartość wskazującą, czy zarówno serwer, jak i klient został uwierzytelniony.Gets a Boolean value that indicates whether both server and client have been authenticated.

IsServer

Pobiera Boolean wartość wskazującą, czy lokalna strona połączenia używana przez ten program SslStream została uwierzytelniona jako serwer.Gets a Boolean value that indicates whether the local side of the connection used by this SslStream was authenticated as the server.

IsSigned

Pobiera Boolean wartość wskazującą, czy dane wysyłane przy użyciu tego strumienia są podpisane.Gets a Boolean value that indicates whether the data sent using this stream is signed.

KeyExchangeAlgorithm

Pobiera algorytm wymiany kluczy używany przez ten program SslStream .Gets the key exchange algorithm used by this SslStream.

KeyExchangeStrength

Pobiera wartość określającą siłę algorytmu wymiany kluczy używanego przez to wystąpienie.Gets a value that identifies the strength of the key exchange algorithm used by this instance.

LeaveInnerStreamOpen

Pobiera informację o tym, czy strumień używany przez ten program AuthenticatedStream do wysyłania i otrzymywania danych został pozostawiony jako otwarty.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Odziedziczone po AuthenticatedStream)
Length

Pobiera długość źródłowego strumienia.Gets the length of the underlying stream.

LocalCertificate

Pobiera certyfikat używany do uwierzytelniania lokalnego punktu końcowego.Gets the certificate used to authenticate the local endpoint.

NegotiatedApplicationProtocol

Negocjowany protokół aplikacji w uzgadnianiu protokołu TLS.The negotiated application protocol in TLS handshake.

NegotiatedCipherSuite

Pobiera pakiet szyfrowania, który został wynegocjowany dla tego połączenia.Gets the cipher suite which was negotiated for this connection.

Position

Pobiera lub ustawia bieżącą pozycję w źródłowym strumieniu.Gets or sets the current position in the underlying stream.

ReadTimeout

Pobiera lub ustawia ilość czasu wyrażoną w milisekundach bloki operacji odczytu czekające na dane.Gets or sets the amount of time, expressed in milliseconds, a read operation blocks waiting for data.

RemoteCertificate

Pobiera certyfikat używany do uwierzytelniania zdalnego punktu końcowego.Gets the certificate used to authenticate the remote endpoint.

SslProtocol

Pobiera wartość wskazującą protokół zabezpieczeń używany do uwierzytelniania tego połączenia.Gets a value that indicates the security protocol used to authenticate this connection.

TargetHostName

Pobiera nazwę serwera, z którym klient próbuje nawiązać połączenie.Gets the name of the server the client is trying to connect to. Ta nazwa jest używana do walidacji certyfikatu serwera.That name is used for server certificate validation. Może to być nazwa DNS lub adres IP.It can be a DNS name or an IP address.

TransportContext

Pobiera TransportContext używany do uwierzytelniania przy użyciu ochrony rozszerzonej.Gets the TransportContext used for authentication using extended protection.

WriteTimeout

Pobiera lub ustawia ilość czasu, w którym bloki operacji zapisu oczekują na dane.Gets or sets the amount of time a write operation blocks waiting for data.

Metody

AuthenticateAsClient(SslClientAuthenticationOptions)

Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniach klienta z serwerem.Called by clients to authenticate the server and optionally the client in a client-server connection.

AuthenticateAsClient(String)

Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniach klienta z serwerem.Called by clients to authenticate the server and optionally the client in a client-server connection.

AuthenticateAsClient(String, X509CertificateCollection, Boolean)

Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniach klienta z serwerem.Called by clients to authenticate the server and optionally the client in a client-server connection. Proces uwierzytelniania używa określonej kolekcji certyfikatów i domyślnego protokołu SSL systemu.The authentication process uses the specified certificate collection, and the system default SSL protocol.

AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)

Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniach klienta z serwerem.Called by clients to authenticate the server and optionally the client in a client-server connection. Proces uwierzytelniania używa określonej kolekcji certyfikatów i protokołu SSL.The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken)

Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniach klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa informacji określonych w sslClientAuthenticationOptions zbiorze właściwości.The authentication process uses information specified in the sslClientAuthenticationOptions property bag.

AuthenticateAsClientAsync(String)

Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniach klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean)

Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniach klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonej kolekcji certyfikatów i domyślnego protokołu SSL systemu.The authentication process uses the specified certificate collection and the system default SSL protocol.

AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean)

Wywoływane przez klientów w celu uwierzytelnienia serwera i opcjonalnie klienta w połączeniach klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonej kolekcji certyfikatów i protokołu SSL.The authentication process uses the specified certificate collection and SSL protocol.

AuthenticateAsServer(SslServerAuthenticationOptions)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem przy użyciu podanego certyfikatu.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate.

AuthenticateAsServer(X509Certificate)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem przy użyciu podanego certyfikatu.Called by servers to authenticate the server and optionally the client in a client-server connection using the specified certificate.

AuthenticateAsServer(X509Certificate, Boolean, Boolean)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem przy użyciu określonych certyfikatów i wymagań oraz przy użyciu domyślnego protokołu zabezpieczeń systemu.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)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem przy użyciu określonych certyfikatów, wymagań i protokołu zabezpieczeń.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)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem jako operacji asynchronicznej.Called by servers to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa informacji zwracanych przez optionsCallback .The authentication process uses information returned by optionsCallback.

AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem jako operacji asynchronicznej.Called by servers to authenticate the server and optionally the client in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa informacji określonych w sslClientAuthenticationOptions zbiorze właściwości.The authentication process uses information specified in the sslClientAuthenticationOptions property bag.

AuthenticateAsServerAsync(X509Certificate)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem przy użyciu określonego certyfikatu jako operacji asynchronicznej.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)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem przy użyciu określonych certyfikatów, wymagań i protokołu zabezpieczeń jako operacji asynchronicznej.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)

Wywoływane przez serwery do uwierzytelniania serwera i opcjonalnie klienta w połączeniach klienta z serwerem przy użyciu określonych certyfikatów, wymagań i protokołu zabezpieczeń jako operacji asynchronicznej.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)

Wywoływane przez klientów, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia serwera i opcjonalnie klienta.Called by clients to begin an asynchronous operation to authenticate the server and optionally the client.

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

Wywoływane przez klientów, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia serwera i opcjonalnie klienta przy użyciu określonych certyfikatów i domyślnego protokołu zabezpieczeń systemu.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)

Wywoływane przez klientów, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia serwera i opcjonalnie klienta przy użyciu określonych certyfikatów i protokołu zabezpieczeń.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)

Wywoływane przez serwery, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.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)

Wywoływane przez serwery, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia serwera i opcjonalnie klienta przy użyciu określonych certyfikatów i wymagań oraz domyślnego protokołu zabezpieczeń systemu.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)

Wywoływane przez serwery, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia serwera i opcjonalnie klienta przy użyciu określonych certyfikatów, wymagań i protokołu zabezpieczeń.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)

Rozpoczyna asynchroniczne operacje odczytu, które odczytuje dane ze strumienia i zapisuje je w określonej tablicy.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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

Rozpoczęcie asynchronicznej operacji odczytu.Begins an asynchronous read operation. (Rozważ użycie ReadAsync(Byte[], Int32, Int32) zamiast niego).(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Odziedziczone po Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Rozpoczyna asynchroniczne operacje zapisu, które zapisują Byte elementy s z określonego buforu do strumienia.Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

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

Rozpoczyna asynchroniczne operacje zapisu.Begins an asynchronous write operation. (Rozważ użycie WriteAsync(Byte[], Int32, Int32) zamiast niego).(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Odziedziczone po Stream)
Close()

Zamyka bieżący strumień i zwalnia wszystkie zasoby (takie jak gniazda i uchwyty plików) skojarzone z bieżącym strumieniem.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Zamiast wywołania tej metody upewnij się, że strumień jest prawidłowo usunięty.Instead of calling this method, ensure that the stream is properly disposed.

(Odziedziczone po Stream)
CopyTo(Stream)

Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu.Reads the bytes from the current stream and writes them to another stream.

(Odziedziczone po Stream)
CopyTo(Stream, Int32)

Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Odziedziczone po Stream)
CopyToAsync(Stream)

Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Odziedziczone po Stream)
CopyToAsync(Stream, CancellationToken)

Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego tokenu anulowania.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Odziedziczone po Stream)
CopyToAsync(Stream, Int32)

Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Odziedziczone po Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu i tokenu anulowania.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Odziedziczone po Stream)
CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
CreateWaitHandle()
Nieaktualne.

Przydziela WaitHandle obiekt.Allocates a WaitHandle object.

(Odziedziczone po Stream)
Dispose()

Zwalnia wszelkie zasoby używane przez element Stream.Releases all resources used by the Stream.

(Odziedziczone po Stream)
Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element SslStream i opcjonalnie zwalnia zasoby zarządzane.Releases the unmanaged resources used by the SslStream and optionally releases the managed resources.

Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element AuthenticatedStream i opcjonalnie zwalnia zasoby zarządzane.Releases the unmanaged resources used by the AuthenticatedStream and optionally releases the managed resources.

(Odziedziczone po AuthenticatedStream)
DisposeAsync()

Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez SslStream .Asynchronously releases the unmanaged and managed resources used by the SslStream.

DisposeAsync()

Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez AuthenticatedStream .Asynchronously releases the unmanaged and managed resources used by the AuthenticatedStream.

(Odziedziczone po AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)

Zakończenie oczekującej operacji asynchronicznego uwierzytelniania serwera rozpoczętej z poprzednim wywołaniem do BeginAuthenticateAsClient .Ends a pending asynchronous server authentication operation started with a previous call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Zakończenie oczekującej asynchronicznej operacji uwierzytelniania klienta rozpoczętej z poprzednim wywołaniem do BeginAuthenticateAsClient .Ends a pending asynchronous client authentication operation started with a previous call to BeginAuthenticateAsClient.

EndRead(IAsyncResult)

Zakończenie asynchronicznej operacji odczytu rozpoczętej z poprzednim wywołaniem do 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)

Czeka na zakończenie oczekujących asynchronicznych operacji odczytu.Waits for the pending asynchronous read to complete. (Rozważ użycie ReadAsync(Byte[], Int32, Int32) zamiast niego).(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Odziedziczone po Stream)
EndWrite(IAsyncResult)

Zakończenie asynchronicznej operacji zapisu rozpoczętej z poprzednim wywołaniem do 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)

Zamyka asynchroniczne operacje zapisu.Ends an asynchronous write operation. (Rozważ użycie WriteAsync(Byte[], Int32, Int32) zamiast niego).(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Odziedziczone po Stream)
Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
Finalize()

Zwalnia wszelkie zasoby używane przez element SslStream.Releases all resources used by the SslStream.

Flush()

Powoduje, że wszystkie buforowane dane są zapisywane na podstawowym urządzeniu.Causes any buffered data to be written to the underlying device.

FlushAsync()

Asynchronicznie czyści wszystkie bufory dla tego strumienia i powoduje, że wszystkie buforowane dane są zapisywane na podstawowym urządzeniu.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Odziedziczone po Stream)
FlushAsync(CancellationToken)

Asynchronicznie zapisuje wszystkie dane buforowane na podstawowym urządzeniu.Asynchronously writes any buffered data to the underlying device.

FlushAsync(CancellationToken)

Asynchronicznie czyści wszystkie bufory dla tego strumienia, powoduje, że wszystkie buforowane dane są zapisywane na podstawowym urządzeniu i monitoruje żądania anulowania.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

(Odziedziczone po Stream)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
ObjectInvariant()
Nieaktualne.

Zapewnia pomoc techniczną dla programu Contract .Provides support for a Contract.

(Odziedziczone po Stream)
Read(Byte[], Int32, Int32)

Odczytuje dane z tego strumienia i zapisuje je w określonej tablicy.Reads data from this stream and stores it in the specified array.

Read(Span<Byte>)

Gdy jest zastępowany w klasie pochodnej, odczytuje sekwencję bajtów z bieżącego strumienia i przesuwa pozycję w strumieniu o liczbę odczytanych bajtów.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.

(Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32)

Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia i przesuwa pozycję w strumieniu o liczbę odczytanych bajtów.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Asynchronicznie odczytuje dane z tego strumienia i zapisuje je w określonym zakresie tablicy bajtów.Asynchronously reads data from this stream and stores it in the specified range of a byte array.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia, przesuwa pozycję w strumieniu o liczbę odczytanych bajtów i monitoruje żądania anulowania.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.

(Odziedziczone po Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Asynchronicznie odczytuje dane z tego strumienia i zapisuje je w określonym zakresie pamięci.Asynchronously reads data from this stream and stores it in the specified memory range.

ReadAsync(Memory<Byte>, CancellationToken)

Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia, przesuwa pozycję w strumieniu o liczbę odczytanych bajtów i monitoruje żądania anulowania.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.

(Odziedziczone po Stream)
ReadByte()

Odczytuje bajt z SslStream i przesuwa pozycję w strumieniu o jeden bajt lub zwraca-1, jeśli na końcu strumienia.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()

Odczytuje bajt ze strumienia i przesuwa pozycję w strumieniu o jeden bajt lub zwraca wartość-1, jeśli na końcu strumienia.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.

(Odziedziczone po Stream)
Seek(Int64, SeekOrigin)

Zgłasza NotSupportedException .Throws a NotSupportedException.

SetLength(Int64)

Ustawia długość źródłowego strumienia.Sets the length of the underlying stream.

ShutdownAsync()

Zamyka ten SslStream.Shuts down this SslStream.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
Write(Byte[])

Zapisuje określone dane w tym strumieniu.Writes the specified data to this stream.

Write(Byte[], Int32, Int32)

Napisz określoną liczbę Byte s do źródłowego strumienia przy użyciu określonego buforu i przesunięcia.Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>)

Gdy jest zastępowany w klasie pochodnej, zapisuje sekwencję bajtów do bieżącego strumienia i zwiększa bieżącą pozycję w tym strumieniu o liczbę zapisanych bajtów.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.

(Odziedziczone po Stream)
WriteAsync(Byte[], Int32, Int32)

Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia i przesuwa bieżącą pozycję w tym strumieniu o liczbę zapisanych bajtów.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Odziedziczone po Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Asynchronicznie zapisuje dane do strumienia źródłowego z określonego zakresu tablicy bajtów.Asynchronously writes data to the underlying stream from the specified range of a byte array.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia, przesuwa bieżącą pozycję w tym strumieniu o liczbę zapisanych bajtów i monitoruje żądania anulowania.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.

(Odziedziczone po Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Asynchronicznie zapisuje dane do strumienia źródłowego z zakresu pamięci bajtów tylko do odczytu.Asynchronously writes data to the underlying stream from a read-only byte memory range.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia, przesuwa bieżącą pozycję w tym strumieniu o liczbę zapisanych bajtów i monitoruje żądania anulowania.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.

(Odziedziczone po Stream)
WriteByte(Byte)

Zapisuje bajty w bieżącym położeniu w strumieniu i przesuwa pozycję w strumieniu o jeden bajt.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Odziedziczone po Stream)

Jawne implementacje interfejsu

IDisposable.Dispose()

Zwalnia wszelkie zasoby używane przez element Stream.Releases all resources used by the Stream.

(Odziedziczone po Stream)

Metody rozszerzania

ConfigureAwait(IAsyncDisposable, Boolean)

Określa, jak oczekują oczekiwania na zadania zwracane z asynchronicznej operacji tworzenia.Configures how awaits on the tasks returned from an async disposable are performed.

Dotyczy

Zobacz też