若要檢視英文版的文章,請選取 [原文] 核取方塊。您也可以將滑鼠指標移到文字上,即可在快顯視窗顯示英文原文。
譯文
原文
本文件已封存並已停止維護。

SslStream 類別

提供資料流,用於使用 Secure Socket Layer (SSL) 安全性通訊協定來驗證伺服器及 (選擇性地驗證) 用戶端之用戶端與伺服器之間的通訊。

命名空間:  System.Net.Security
組件:  System (在 System.dll 中)

public class SslStream : AuthenticatedStream

SslStream 型別會公開下列成員。

  名稱說明
公用方法SslStream(Stream)使用指定的 Stream 來初始化 SslStream 類別的新執行個體。
公用方法SslStream(Stream, Boolean)使用指定的 Stream 和資料流結束行為,初始化 SslStream 類別的新執行個體。
公用方法SslStream(Stream, Boolean, RemoteCertificateValidationCallback)使用指定的 Stream、資料流結束行為以及憑證驗證委派,初始化 SslStream 類別的新執行個體。
公用方法SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback)使用指定的 Stream、資料流結束行為、憑證驗證委派及憑證選取委派,初始化 SslStream 類別的新執行個體。
公用方法SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy)使用指定的 Stream 來初始化 SslStream 類別的新執行個體。
回頁首

  名稱說明
公用屬性CanRead取得 Boolean 值,指示基礎資料流是否可讀取。 (覆寫 Stream.CanRead。)
公用屬性CanSeek取得 Boolean 值,指示基礎資料流是否可搜尋。 (覆寫 Stream.CanSeek。)
公用屬性CanTimeout取得 Boolean 值,指示基礎資料流是否支援逾時。 (覆寫 Stream.CanTimeout。)
公用屬性CanWrite取得 Boolean 值,指示基礎資料流是否可寫入。 (覆寫 Stream.CanWrite。)
公用屬性CheckCertRevocationStatus取得 Boolean 值,指出在憑證驗證處理期間是否檢查憑證撤銷清單。
公用屬性CipherAlgorithm取得值,識別這個 SslStream 所用的大量加密演算法。
公用屬性CipherStrength取得值,識別這個 SslStream 所用之加密演算法的強度。
公用屬性HashAlgorithm取得用於產生訊息驗證碼 (MAC) 的演算法。
公用屬性HashStrength取得值,識別這個執行個體所用之雜湊演算法的強度。
受保護的屬性InnerStream取得這個 AuthenticatedStream 用來傳送和接收資料的資料流。 (繼承自 AuthenticatedStream)。
公用屬性IsAuthenticated取得 Boolean 值,指示驗證是否成功。 (覆寫 AuthenticatedStream.IsAuthenticated。)
公用屬性IsEncrypted取得 Boolean 值,指示這個 SslStream 是否使用資料加密。 (覆寫 AuthenticatedStream.IsEncrypted。)
公用屬性IsMutuallyAuthenticated取得 Boolean 值,指示伺服器和用戶端是否都已驗證。 (覆寫 AuthenticatedStream.IsMutuallyAuthenticated。)
公用屬性IsServer取得 Boolean 值,指示這個 SslStream 所使用之連接的本機端是否以伺服器身分驗證。 (覆寫 AuthenticatedStream.IsServer。)
公用屬性IsSigned取得 Boolean 值,指示使用此資料流傳送的資料是否簽章。 (覆寫 AuthenticatedStream.IsSigned。)
公用屬性KeyExchangeAlgorithm取得這個 SslStream 所用的金鑰交換演算法。
公用屬性KeyExchangeStrength取得值,識別這個執行個體所用之金鑰交換演算法的強度。
公用屬性LeaveInnerStreamOpen取得這個 AuthenticatedStream 用來傳送和接收資料的資料流是否保持開啟狀態。 (繼承自 AuthenticatedStream)。
公用屬性Length取得基礎資料流的長度。 (覆寫 Stream.Length。)
公用屬性LocalCertificate取得用於驗證本機端點的憑證。
公用屬性Position取得或設定基礎資料流中目前的位置。 (覆寫 Stream.Position。)
公用屬性ReadTimeout取得或設定讀取作業封鎖等待資料的時間長度。 (覆寫 Stream.ReadTimeout。)
公用屬性RemoteCertificate取得用於驗證遠端端點的憑證。
公用屬性SslProtocol取得值,指示用於驗證此連接的安全性通訊協定。
公用屬性TransportContext取得在使用延伸保護時用來驗證的 TransportContext
公用屬性WriteTimeout取得或設定寫入作業封鎖等待資料的時間長度。 (覆寫 Stream.WriteTimeout。)
回頁首

  名稱說明
公用方法AuthenticateAsClient(String)由用戶端呼叫以驗證用戶端與伺服器連接中的伺服器及 (選擇性地驗證) 用戶端。
公用方法AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean)由用戶端呼叫以驗證用戶端與伺服器連接中的伺服器及 (選擇性地驗證) 用戶端。 驗證處理序使用指定的憑證集合和 SSL 通訊協定。
公用方法AuthenticateAsServer(X509Certificate)由伺服器呼叫,以使用指定的憑證來驗證用戶端與伺服器連接中的伺服器及 (選擇性地驗證) 用戶端。
公用方法AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean)由伺服器呼叫以開始非同步作業,使用指定的憑證、要求及安全性通訊協定來驗證伺服器及 (選擇性地驗證) 用戶端。
公用方法BeginAuthenticateAsClient(String, AsyncCallback, Object)由用戶端呼叫以開始非同步作業,驗證伺服器及 (選擇性地驗證) 用戶端。
公用方法BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object)由用戶端呼叫以開始非同步作業,使用指定的憑證和安全性通訊協定來驗證伺服器及 (選擇性地驗證) 用戶端。
公用方法BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object)由伺服器呼叫以開始非同步作業,驗證用戶端與伺服器連接中的用戶端及 (選擇性地驗證) 伺服器。
公用方法BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object)由伺服器呼叫以開始非同步作業,使用指定的憑證、要求及安全性通訊協定來驗證伺服器及 (選擇性地驗證) 用戶端。
公用方法BeginRead開始非同步讀取作業,這個作業會從資料流中讀取資料並將其儲存於指定的陣列中。 (覆寫 Stream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)。)
公用方法BeginWrite開始非同步寫入作業,此作業會從指定的緩衝區寫入 Byte 至資料流。 (覆寫 Stream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)。)
公用方法Close關閉目前資料流和釋放與目前資料流相關聯的任何資源 (例如通訊端和檔案控制代碼)。 (繼承自 Stream)。
公用方法CopyTo(Stream)從目前資料流讀取位元組,並將其寫入目的資料流中。 (繼承自 Stream)。
公用方法CopyTo(Stream, Int32)使用指定緩衝區大小,從目前資料流讀取所有位元組,並將其寫入目的資料流中。 (繼承自 Stream)。
公用方法CreateObjRef建立包含所有相關資訊的物件,這些資訊是產生用來與遠端物件通訊的所需 Proxy。 (繼承自 MarshalByRefObject)。
受保護的方法CreateWaitHandle 已過時。配置 WaitHandle 物件。 (繼承自 Stream)。
公用方法Dispose()釋放 Stream 所使用的所有資源。 (繼承自 Stream)。
受保護的方法Dispose(Boolean)釋放 SslStream 使用的 Unmanaged 資源,並選擇性地釋放 Managed 資源。 (覆寫 AuthenticatedStream.Dispose(Boolean)。)
公用方法EndAuthenticateAsClient結束由先前呼叫 BeginAuthenticateAsServer 所開始的暫止非同步伺服器驗證作業。
公用方法EndAuthenticateAsServer結束由先前呼叫 BeginAuthenticateAsClient 所開始的暫止非同步用戶端驗證作業。
公用方法EndRead結束由先前呼叫 BeginRead 所開始的非同步讀取作業。 (覆寫 Stream.EndRead(IAsyncResult)。)
公用方法EndWrite結束由先前呼叫 BeginWrite 所開始的非同步寫入作業。 (覆寫 Stream.EndWrite(IAsyncResult)。)
公用方法Equals(Object)判斷指定的 Object 和目前的 Object 是否相等。 (繼承自 Object)。
受保護的方法Finalize允許物件在記憶體回收進行回收之前,嘗試釋放資源並執行其他清除作業。 (繼承自 Object)。
公用方法Flush造成任何緩衝資料都將寫入基礎裝置。 (覆寫 Stream.Flush()。)
公用方法GetHashCode做為特定型別的雜湊函式。 (繼承自 Object)。
公用方法GetLifetimeService擷取控制這個執行個體存留期 (Lifetime) 原則的目前存留期服務物件。 (繼承自 MarshalByRefObject)。
公用方法GetType取得目前執行個體的 Type (繼承自 Object)。
公用方法InitializeLifetimeService取得存留期服務物件來控制這個執行個體的存留期原則。 (繼承自 MarshalByRefObject)。
受保護的方法MemberwiseClone()建立目前 Object 的淺層複本 (Shallow Copy)。 (繼承自 Object)。
受保護的方法MemberwiseClone(Boolean)建立目前 MarshalByRefObject 物件的淺層複本。 (繼承自 MarshalByRefObject)。
受保護的方法ObjectInvariant基礎架構。提供 Contract 的支援。 (繼承自 Stream)。
公用方法Read從這個資料流中讀取資料並將其儲存於指定的陣列中。 (覆寫 Stream.Read(Byte[], Int32, Int32)。)
公用方法ReadByte從資料流讀取一個位元組,並將資料流的位置推進一個位元組;如果在資料流末端,則傳回 -1。 (繼承自 Stream)。
公用方法Seek基礎架構。擲回 NotSupportedException (覆寫 Stream.Seek(Int64, SeekOrigin)。)
公用方法SetLength設定基礎資料流的長度。 (覆寫 Stream.SetLength(Int64)。)
公用方法ToString傳回表示目前物件的字串。 (繼承自 Object)。
公用方法Write(Byte[])寫入指定的資料至此資料流。
公用方法Write(Byte[], Int32, Int32)使用指定的緩衝區和位移,將指定數目的 Byte 寫入至基礎資料流。 (覆寫 Stream.Write(Byte[], Int32, Int32)。)
公用方法WriteByte寫入一個位元組至資料流的目前位置,並將資料流位置推進一個位元組。 (繼承自 Stream)。
回頁首

SSL 通訊協定協助為使用 SslStream 傳輸的訊息提供機密性和完整性檢查。 當在用戶端和伺服器之間進行敏感資訊通訊時,應當使用 SSL 連接,例如由 SslStream 提供的連接。 使用 SslStream 可以協助防止任何人對在網路上傳輸的資訊進行讀取或竄改。

SslStream 執行個體會使用在您建立 SslStream 時所提供的資料流傳輸資料。 當您提供此基礎資料流時,可以選擇指定關閉 SslStream 是否也會關閉基礎資料流。 通常,SslStream 類別是和 TcpClientTcpListener 類別一起使用。 GetStream 方法提供適合與 SslStream 類別搭配使用的 NetworkStream

建立 SslStream 後,必須驗證伺服器及 (選擇性地驗證)用戶端。 伺服器必須提供 X509 憑證,此憑證會建立其識別的證明,並可以要求用戶端也如此。 使用 SslStream 傳輸資訊前必須執行驗證 (Authentication)。 用戶端初始化驗證,使用同步 AuthenticateAsClient 方法,此方法會持續封鎖直到驗證完成為止,或使用非同步 BeginAuthenticateAsClient 方法,此方法在等待驗證完成期間不會封鎖。 伺服器會使用同步 AuthenticateAsServer 或非同步 BeginAuthenticateAsServer 方法初始化驗證。 用戶端和伺服器都必須初始化驗證。

驗證由安全性支援提供者 (Security Support Provider,SSPI) 通道提供者處理。 用戶端會得到機會,透過在建立 SslStream 時指定 RemoteCertificateValidationCallback 委派來控制伺服器憑證的驗證。 伺服器也可以透過提供 RemoteCertificateValidationCallback 委派來控制驗證。 委派參考的方法包含遠端群體的憑證以及 SSPI 在驗證憑證時遇到的任何錯誤。 請注意,如果伺服器指定了委派,則會叫用該委派的方法,不論伺服器是否要求用戶端驗證。 如果伺服器沒有要求用戶端驗證,則伺服器的委派方法會接收到 null 憑證以及空的憑證錯誤陣列。

如果伺服器要求用戶端驗證,則用戶端必須指定一個或多個憑證執行驗證。 如果用戶端具有一個或多個憑證,則用戶端可以提供 LocalCertificateSelectionCallback 委派,為伺服器選取正確的憑證。 用戶端的憑證必須位於目前使用者的 "My" 憑證存放區。 Ssl2 (SSL 2 版) 通訊協定並不支援透過憑證的用戶端驗證。

如果驗證失敗,則您會接到 AuthenticationException,而 SslStream 就無法再使用。 您應該關閉這個物件並移除這個物件的所有參考,讓記憶體回收行程能夠回收物件。

當驗證處理序 (也稱為 SSL 信號交換) 成功時,會建立伺服器的識別 (可以選擇性地建立用戶端的識別),而且用戶端和伺服器可以使用 SslStream 來交換訊息。 傳送或接收資訊前,用戶端和伺服器應檢查 SslStream 提供的安全性服務及等級,以判斷選取的通訊協定、演算法和強度是否符合它們的完整性及機密性需求。 如果目前的設定不足,則資料流應關閉。 您可以藉由使用 IsEncryptedIsSigned 屬性來檢查 SslStream 提供的安全性服務。 下表顯示報告用於驗證、加密和資料簽章之密碼編譯設定的項目。

項目

成員

用於驗證伺服器及 (選擇性地驗證) 用戶端的安全性通訊協定。

SslProtocol 屬性,以及關聯的 SslProtocols 列舉型別。

金鑰 (Key) 交換演算法。

KeyExchangeAlgorithm 屬性,以及關聯的 ExchangeAlgorithmType 列舉型別。

訊息完整性演算法。

HashAlgorithm 屬性,以及關聯的 HashAlgorithmType 列舉型別。

訊息機密性演算法。

CipherAlgorithm 屬性,以及關聯的 CipherAlgorithmType 列舉型別。

選取之演算法的強度。

KeyExchangeStrength HashStrengthCipherStrength 屬性。

驗證成功後,您可以使用同步 Write 或非同步 BeginWrite 方法傳送資料。 您可以使用同步 Read 或非同步 BeginRead 方法接收資料。

如果您指定為基礎資料流應保持開啟狀態的 SslStream,則當您使用完畢後,應負責關閉該資料流。

注意事項注意事項

如果建立 SslStream 物件的應用程式以一般使用者的認證執行,則必須明確授與相關使用權限給使用者,否則應用程式將無法存取本機電腦存放區中所安裝的憑證。

SslStream 假設在內部資料流擲回例外狀況時,其呼叫端會將逾時和任何其他 IOException 視為嚴重錯誤。 在逾時後重複使用 SslStream 執行個體會傳回垃圾。 應用程式應以 Close 關閉 SslStream,並在這些情況下擲回例外狀況。

下列程式碼範例示範了建立使用 SslStream 類別與用戶端通訊的 TcpListener


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, 
                    false, SslProtocols.Tls, 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;
        } 
    }
}


在下列程式碼範例中,示範了建立使用 SslStream 類別來與伺服器通訊的 TcpClient


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;
        }
    }
}
    


.NET Framework

支援版本:4、3.5、3.0、2.0

.NET Framework Client Profile

支援版本:4、3.5 SP1

Windows 7, Windows Vista SP1 (含) 以後版本, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (不支援伺服器核心), Windows Server 2008 R2 (SP1 (含) 以後版本支援伺服器核心), Windows Server 2003 SP2

.NET Framework 並不支援各種平台的所有版本。如需支援的版本的清單,請參閱.NET Framework 系統需求

這個型別的任何 Public static (在 Visual Basic 中為 Shared) 成員都具備執行緒安全。並非所有的執行個體成員都是安全執行緒。
顯示: