C#網絡編程(同步傳輸字符串) - Part.2

時間 2020-09-20

標籤 c# 網絡編程同步傳輸字符串 part.2 欄目 C# 简体版

原文原文鏈接

服務端客戶端通訊

在與服務端的鏈接創建之後，咱們就能夠經過此鏈接來發送和接收數據。端口與端口之間以流（Stream）的形式傳輸數據，由於幾乎任何對象均可以保存到流中，因此實際上能夠在客戶端與服務端之間傳輸任何類型的數據。對客戶端來講，往流中寫入數據，即爲向服務器傳送數據；從流中讀取數據，即爲從服務端接收數據。對服務端來講，往流中寫入數據，即爲向客戶端發送數據；從流中讀取數據，即爲從客戶端接收數據。html

同步傳輸字符串

咱們如今考慮這樣一個任務：客戶端打印一串字符串，而後發往服務端，服務端先輸出它，而後將它改成大寫，再回發到客戶端，客戶端接收到之後，最後再次打印一遍它。咱們將它分爲兩部分：一、客戶端發送，服務端接收並輸出；二、服務端回發，客戶端接收並輸出。編程

1.客戶端發送，服務端接收並輸出

1.1服務端程序

咱們能夠在TcpClient上調用GetStream()方法來得到鏈接到遠程計算機的流。注意這裏我用了遠程這個詞，當在客戶端調用時，它獲得鏈接服務端的流；當在服務端調用時，它得到鏈接客戶端的流。接下來咱們來看一下代碼，咱們先看服務端（注意這裏沒有使用do/while循環）：小程序

class Server {
    static void Main(string[] args) {
        const int BufferSize = 8192;    // 緩存大小，8192字節

        Console.WriteLine("Server is running ... ");
        IPAddress ip = new IPAddress(new byte[] { 127, 0, 0, 1 });
        TcpListener listener = new TcpListener(ip, 8500);

        listener.Start();           // 開始偵聽
        Console.WriteLine("Start Listening ...");

        // 獲取一個鏈接，中斷方法
        TcpClient remoteClient = listener.AcceptTcpClient();
        // 打印鏈接到的客戶端信息
        Console.WriteLine("Client Connected！{0} <-- {1}",
            remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);

        // 得到流，並寫入buffer中
        NetworkStream streamToClient = remoteClient.GetStream();
        byte[] buffer = new byte[BufferSize];
        int bytesRead = streamToClient.Read(buffer, 0, BufferSize);
        Console.WriteLine("Reading data, {0} bytes ...", bytesRead);

        // 得到請求的字符串
        string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
        Console.WriteLine("Received: {0}", msg);

        // 按Q退出
    }
}緩存

這段程序的上半部分已經很熟悉了，我就再也不解釋。remoteClient.GetStream()方法獲取到了鏈接至客戶端的流，而後從流中讀出數據並保存在了buffer緩存中，隨後使用Encoding.Unicode.GetString()方法，從緩存中獲取到了實際的字符串。最後將字符串打印在了控制檯上。這段代碼有個地方須要注意：在可以讀取的字符串的總字節數大於BufferSize的時候會出現字符串截斷現象，由於緩存中的數目老是有限的，而對於大對象，好比說圖片或者其它文件來講，則必須採用「分次讀取而後轉存」這種方式，好比這樣：服務器

// 獲取字符串
byte[] buffer = new byte[BufferSize];
int bytesRead;          // 讀取的字節數
MemoryStream msStream = new MemoryStream();
do {
    bytesRead = streamToClient.Read(buffer, 0, BufferSize);
    msStream.Write(buffer, 0, bytesRead);
} while (bytesRead > 0);

buffer = msStream.GetBuffer();
string msg = Encoding.Unicode.GetString(buffer);網絡

這裏我沒有使用這種方法，一個是由於不想關注在太多的細節上面，一個是由於對於字符串來講，8192字節已經不少了，咱們一般不會傳遞這麼多的文本。當使用Unicode編碼時，8192字節能夠保存4096個漢字和英文字符。使用不一樣的編碼方式，佔用的字節數有很大的差別，在本文最後面，有一段小程序，能夠用來測試Unicode、UTF八、ASCII三種經常使用編碼方式對字符串編碼時，佔用的字節數大小。多線程

如今對客戶端不作任何修改，而後運行先運行服務端，再運行客戶端。結果咱們會發現這樣一件事：服務端再打印完「Client Connected！127.0.0.1:8500 <-- 127.0.0.1:xxxxx」以後，再次被阻塞了，而沒有輸出「Reading data, {0} bytes ...」。可見，與AcceptTcpClient()方法相似，這個Read()方法也是同步的，只有當客戶端發送數據的時候，服務端纔會讀取數據、運行此方法，不然它便會一直等待。併發

1.2 客戶端程序

接下來咱們編寫客戶端向服務器發送字符串的代碼，與服務端相似，它先獲取鏈接服務器端的流，將字符串保存到buffer緩存中，再將緩存寫入流，寫入流這一過程，至關於將消息發往服務端。異步

class Client {
    static void Main(string[] args) {
        Console.WriteLine("Client Running ...");
        TcpClient client;

        try {
            client = new TcpClient();
            client.Connect("localhost", 8500);      // 與服務器鏈接
        } catch (Exception ex) {
            Console.WriteLine(ex.Message);
            return;
        }
        // 打印鏈接到的服務端信息
        Console.WriteLine("Server Connected！{0} --> {1}",
            client.Client.LocalEndPoint, client.Client.RemoteEndPoint);

        string msg = "\"Welcome To TraceFact.Net\"";
        NetworkStream streamToServer = client.GetStream();

        byte[] buffer = Encoding.Unicode.GetBytes(msg);     // 得到緩存
        streamToServer.Write(buffer, 0, buffer.Length);     // 發往服務器
        Console.WriteLine("Sent: {0}", msg);

        // 按Q退出
    }
}測試

如今再次運行程序，獲得的輸出爲：

// 服務端
Server is running ...
Start Listening ...
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:7847
Reading data, 52 bytes ...
Received: "Welcome To TraceFact.Net"
輸入"Q"鍵退出。
// 客戶端
Client Running ...
Server Connected！127.0.0.1:7847 --> 127.0.0.1:8500
Sent: "Welcome To TraceFact.Net"
輸入"Q"鍵退出。

再繼續進行以前，咱們假設客戶端能夠發送多條消息，而服務端要不斷的接收來自客戶端發送的消息，可是上面的代碼只能接收客戶端發來的一條消息，由於它已經輸出了「輸入Q鍵退出」，說明程序已經執行完畢，沒法再進行任何動做。此時若是咱們再開啓一個客戶端，那麼出現的狀況是：客戶端能夠與服務器創建鏈接，也就是netstat-a顯示爲ESTABLISHED，這是操做系統所知道的；可是因爲服務端的程序已經執行到了最後一步，只能輸入Q鍵退出，沒法再採起任何的動做。

回想一個上面咱們須要一個服務器對應多個客戶端時，對AcceptTcpClient()方法的處理辦法，將它放在了do/while循環中；相似地，當咱們須要一個服務端對同一個客戶端的屢次請求服務時，能夠將Read()方法放入到do/while循環中。

如今，咱們大體能夠得出這樣幾個結論：

若是不使用do/while循環，服務端只有一個listener.AcceptTcpClient()方法和一個TcpClient.GetStream().Read()方法，則服務端只能處理到同一客戶端的一條請求。
若是使用一個do/while循環，並將listener.AcceptTcpClient()方法和TcpClient.GetStream().Read()方法都放在這個循環之內，那麼服務端將能夠處理多個客戶端的一條請求。
若是使用一個do/while循環，並將listener.AcceptTcpClient()方法放在循環以外，將TcpClient.GetStream().Read()方法放在循環之內，那麼服務端能夠處理一個客戶端的多條請求。
若是使用兩個do/while循環，對它們進行分別嵌套，那麼結果是什麼呢？結果並非能夠處理多個客戶端的多條請求。由於裏層的do/while循環老是在爲一個客戶端服務，由於它會中斷在TcpClient.GetStream().Read()方法的位置，而沒法執行完畢。即便能夠經過某種方式讓裏層循環退出，好比客戶端往服務端發去「exit」字符串時，服務端也只能挨個對客戶端提供服務。若是服務端想執行多個客戶端的多個請求，那麼服務端就須要採用多線程。主線程，也就是執行外層do/while循環的線程，在收到一個TcpClient以後，必須將裏層的do/while循環交給新線程去執行，而後主線程快速地從新回到listener.AcceptTcpClient()的位置，以響應其它的客戶端。

對於第四種狀況，其實是構建一個服務端更爲一般的狀況，因此須要專門開闢一個章節討論，這裏暫且放過。而咱們上面所作的，便是列出的第一種狀況，接下來咱們再分別看一下第二種和第三種狀況。

對於第二種狀況，咱們按照上面的敘述先對服務端進行一下改動：

do {
    // 獲取一個鏈接，中斷方法
    TcpClient remoteClient = listener.AcceptTcpClient();
    // 打印鏈接到的客戶端信息
    Console.WriteLine("Client Connected！{0} <-- {1}",
        remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);

    // 得到流，並寫入buffer中
    NetworkStream streamToClient = remoteClient.GetStream();
    byte[] buffer = new byte[BufferSize];
    int bytesRead = streamToClient.Read(buffer, 0, BufferSize);
    Console.WriteLine("Reading data, {0} bytes ...", bytesRead);

    // 得到請求的字符串
    string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
    Console.WriteLine("Received: {0}", msg);
} while (true);

而後啓動多個客戶端，在服務端應該能夠看到下面的輸出（客戶端沒有變化）：

Server is running ...
Start Listening ...
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:8196
Reading data, 52 bytes ...
Received: "Welcome To TraceFact.Net"
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:8199
Reading data, 52 bytes ...
Received: "Welcome To TraceFact.Net"

由第2種狀況改成第3種狀況，只須要將do向下挪動幾行就能夠了：

// 獲取一個鏈接，中斷方法
TcpClient remoteClient = listener.AcceptTcpClient();
// 打印鏈接到的客戶端信息
Console.WriteLine("Client Connected！{0} <-- {1}",
    remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);
// 得到流，並寫入buffer中
NetworkStream streamToClient = remoteClient.GetStream();

do {
    byte[] buffer = new byte[BufferSize];
    int bytesRead = streamToClient.Read(buffer, 0, BufferSize);
    Console.WriteLine("Reading data, {0} bytes ...", bytesRead);

    // 得到請求的字符串
    string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
    Console.WriteLine("Received: {0}", msg);
} while (true);

而後咱們再改動一下客戶端，讓它發送多個請求。當咱們按下S的時候，能夠輸入一行字符串，而後將這行字符串發送到服務端；當咱們輸入X的時候則退出循環：

NetworkStream streamToServer = client.GetStream();
ConsoleKey key;
Console.WriteLine("Menu: S - Send, X - Exit");
do {
    key = Console.ReadKey(true).Key;

    if (key == ConsoleKey.S) {
        // 獲取輸入的字符串
        Console.Write("Input the message: ");
        string msg = Console.ReadLine();

        byte[] buffer = Encoding.Unicode.GetBytes(msg);     // 得到緩存
        streamToServer.Write(buffer, 0, buffer.Length);     // 發往服務器
        Console.WriteLine("Sent: {0}", msg);
    }
} while (key != ConsoleKey.X);

接下來咱們先運行服務端，而後再運行客戶端，輸入一些字符串，來進行測試，應該可以看到下面的輸出結果：

// 服務端
Server is running ...
Start Listening ...
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:11004
Reading data, 44 bytes ...
Received: 歡迎訪問個人博客：TraceFact.Net
Reading data, 14 bytes ...
Received: 咱們一塊兒進步！
//客戶端
Client Running ...
Server Connected！127.0.0.1:11004 --> 127.0.0.1:8500
Menu: S - Send, X - Exit
Input the message: 歡迎訪問個人博客：TraceFact.Net
Sent: 歡迎訪問個人博客：TraceFact.Net
Input the message: 咱們一塊兒進步！
Sent: 咱們一塊兒進步！

這裏還須要注意一點，當客戶端在TcpClient實例上調用Close()方法，或者在流上調用Dispose()方法，服務端的streamToClient.Read()方法會持續地返回0，可是不拋出異常，因此會產生一個無限循環；而若是直接關閉掉客戶端，或者客戶端執行完畢但沒有調用stream.Dispose()或者TcpClient.Close()，若是服務器端此時仍阻塞在Read()方法處，則會在服務器端拋出異常：「遠程主機強制關閉了一個現有鏈接」。所以，咱們將服務端的streamToClient.Read()方法須要寫在一個try/catch中。同理，若是在服務端已經鏈接到客戶端以後，服務端調用remoteClient.Close()，則客戶端會獲得異常「沒法將數據寫入傳輸鏈接: 您的主機中的軟件放棄了一個已創建的鏈接。」；而若是服務端直接關閉程序的話，則客戶端會獲得異常「沒法將數據寫入傳輸鏈接: 遠程主機強迫關閉了一個現有的鏈接。」。所以，它們的讀寫操做必須都放入到try/catch塊中。

2.服務端回發，客戶端接收並輸出

2.2服務端程序

咱們接着再進行進一步處理，服務端將收到的字符串改成大寫，而後回發，客戶端接收後打印。此時它們的角色和上面徹底進行了一下對調：對於服務端來講，就好像剛纔的客戶端同樣，將字符串寫入到流中；而客戶端則同服務端同樣，接收並打印。除此之外，咱們最好對流的讀寫操做加上lock，如今咱們直接看代碼，首先看服務端：

class Server {
    static void Main(string[] args) {
        const int BufferSize = 8192;    // 緩存大小，8192Bytes
        ConsoleKey key;

        Console.WriteLine("Server is running ... ");
        IPAddress ip = new IPAddress(new byte[] { 127, 0, 0, 1 });
        TcpListener listener = new TcpListener(ip, 8500);

        listener.Start();           // 開始偵聽
        Console.WriteLine("Start Listening ...");

        // 獲取一個鏈接，同步方法，在此處中斷
        TcpClient remoteClient = listener.AcceptTcpClient();

        // 打印鏈接到的客戶端信息
        Console.WriteLine("Client Connected！{0} <-- {1}",
            remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);

        // 得到流
        NetworkStream streamToClient = remoteClient.GetStream();

        do {
            // 寫入buffer中
            byte[] buffer = new byte[BufferSize];
            int bytesRead;
            try {
                lock(streamToClient){
                    bytesRead = streamToClient.Read(buffer, 0, BufferSize);
                }
                if (bytesRead == 0) throw new Exception("讀取到0字節");
                Console.WriteLine("Reading data, {0} bytes ...", bytesRead);

                // 得到請求的字符串
                string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                Console.WriteLine("Received: {0}", msg);

                // 轉換成大寫併發送
                msg = msg.ToUpper();
                buffer = Encoding.Unicode.GetBytes(msg);
                lock(streamToClient){
                    streamToClient.Write(buffer, 0, buffer.Length);
                }
                Console.WriteLine("Sent: {0}", msg);
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
                break;
            }
        } while (true);

        streamToClient.Dispose();
        remoteClient.Close();

        Console.WriteLine("\n\n輸入\"Q\"鍵退出。");
        do {
            key = Console.ReadKey(true).Key;
        } while (key != ConsoleKey.Q);
    }
}

接下來是客戶端：

class Client {
    static void Main(string[] args) {
        Console.WriteLine("Client Running ...");
        TcpClient client;
        ConsoleKey key;
        const int BufferSize = 8192;

        try {
            client = new TcpClient();
            client.Connect("localhost", 8500);      // 與服務器鏈接
        } catch (Exception ex) {
            Console.WriteLine(ex.Message);
            return;
        }

        // 打印鏈接到的服務端信息
        Console.WriteLine("Server Connected！{0} --> {1}",
            client.Client.LocalEndPoint, client.Client.RemoteEndPoint);

        NetworkStream streamToServer = client.GetStream();
        Console.WriteLine("Menu: S - Send, X - Exit");

        do {
            key = Console.ReadKey(true).Key;

            if (key == ConsoleKey.S) {
                // 獲取輸入的字符串
                Console.Write("Input the message: ");
                string msg = Console.ReadLine();

                byte[] buffer = Encoding.Unicode.GetBytes(msg);     // 得到緩存
                try {
                    lock(streamToServer){
                        streamToServer.Write(buffer, 0, buffer.Length);     // 發往服務器
                    }
                    Console.WriteLine("Sent: {0}", msg);

                    int bytesRead;
                    buffer = new byte[BufferSize];
                    lock(streamToServer){
                        bytesRead = streamToServer.Read(buffer, 0, BufferSize);
                    }
                    msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                    Console.WriteLine("Received: {0}", msg);

                } catch (Exception ex) {
                    Console.WriteLine(ex.Message);
                    break;
                }
            }
        } while (key != ConsoleKey.X);

        streamToServer.Dispose();
        client.Close();

        Console.WriteLine("\n\n輸入\"Q\"鍵退出。");
        do {
            key = Console.ReadKey(true).Key;
        } while (key != ConsoleKey.Q);
    }
}

最後咱們運行程序，而後輸入一串英文字符串，而後看一下輸出：

// 客戶端
Client is running ...
Server Connected！127.0.0.1:12662 --> 127.0.0.1:8500
Menu: S - Send, X - Exit
Input the message: Hello, I'm jimmy zhang.
Sent: Hello, I'm jimmy zhang.
Received: HELLO, I'M JIMMY ZHANG.

// 服務端
Server is running ...
Start Listening ...
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:12662
Reading data, 46 bytes ...
Received: Hello, I'm jimmy zhang.
Sent: HELLO, I'M JIMMY ZHANG.

看到這裏，我想你應該對使用TcpClient和TcpListener進行C#網絡編程有了一個初步的認識，能夠說是剛剛入門了，後面的路還很長。本章的全部操做都是同步操做，像上面的代碼也只是做爲一個入門的範例，實際當中，一個服務端只能爲一個客戶端提供服務的狀況是不存在的，下面就讓咱們來看看上面所說的第四種狀況，如何進行異步的服務端編程。

附錄：ASCII、UTF八、Uncicode編碼下的中英文字符大小

private static void ShowCode() {
    string[] strArray = { "b", "abcd", "乙", "甲乙丙丁" };
    byte[] buffer;
    string mode, back;

    foreach (string str in strArray) {

        for (int i = 0; i <= 2; i++) {
            if (i == 0) {
                buffer = Encoding.ASCII.GetBytes(str);
                back = Encoding.ASCII.GetString(buffer, 0, buffer.Length);
                mode = "ASCII";
            } else if (i == 1) {
                buffer = Encoding.UTF8.GetBytes(str);
                back = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
                mode = "UTF8";
            } else {
                buffer = Encoding.Unicode.GetBytes(str);
                back = Encoding.Unicode.GetString(buffer, 0, buffer.Length);
                mode = "Unicode";
            }

            Console.WriteLine("Mode: {0}, String: {1}, Buffer.Length: {2}",
                mode, str, buffer.Length);

            Console.WriteLine("Buffer:");
            for (int j = 0; j <= buffer.Length - 1; j++) {
                Console.Write(buffer[j] + " ");
            }

            Console.WriteLine("\nRetrived: {0}\n", back);
        }
    }
}

輸出爲：

Mode: ASCII, String: b, Buffer.Length: 1
Buffer: 98
Retrived: b

Mode: UTF8, String: b, Buffer.Length: 1
Buffer: 98
Retrived: b

Mode: Unicode, String: b, Buffer.Length: 2
Buffer: 98 0
Retrived: b

Mode: ASCII, String: abcd, Buffer.Length: 4
Buffer: 97 98 99 100
Retrived: abcd

Mode: UTF8, String: abcd, Buffer.Length: 4
Buffer: 97 98 99 100
Retrived: abcd

Mode: Unicode, String: abcd, Buffer.Length: 8
Buffer: 97 0 98 0 99 0 100 0
Retrived: abcd

Mode: ASCII, String: 乙, Buffer.Length: 1
Buffer: 63
Retrived: ?

Mode: UTF8, String: 乙, Buffer.Length: 3
Buffer: 228 185 153
Retrived: 乙

Mode: Unicode, String: 乙, Buffer.Length: 2
Buffer: 89 78
Retrived: 乙

Mode: ASCII, String: 甲乙丙丁, Buffer.Length: 4
Buffer: 63 63 63 63
Retrived: ????

Mode: UTF8, String: 甲乙丙丁, Buffer.Length: 12
Buffer: 231 148 178 228 185 153 228 184 153 228 184 129
Retrived: 甲乙丙丁

Mode: Unicode, String: 甲乙丙丁, Buffer.Length: 8
Buffer: 50 117 89 78 25 78 1 78
Retrived: 甲乙丙丁

大致上能夠得出這麼幾個結論：

ASCII不能保存中文(貌似誰都知道=_-`)。
UTF8是變長編碼。在對ASCII字符編碼時，UTF更省空間，只佔1個字節，與ASCII編碼方式和長度相同；Unicode在對ASCII字符編碼時，佔用2個字節，且第2個字節補零。
UTF8在對中文編碼時須要佔用3個字節；Unicode對中文編碼則只須要2個字節。

出處：http://www.cnblogs.com/JimmyZhang/archive/2008/09/07/1286301.html