C#網絡程式設計(同步傳輸字元串) - Part.2

服務端用戶端通信

在與服務端的連接配接建立以後，我們就可以通過此連接配接來發送和接收資料。端口與端口之間以流（Stream）的形式傳輸資料，因為幾乎任何對象都可以儲存到流中，是以實際上可以在用戶端與服務端之間傳輸任何類型的資料。對用戶端來說，往流中寫入資料，即為向伺服器傳送資料；從流中讀取資料，即為從服務端接收資料。對服務端來說，往流中寫入資料，即為向用戶端發送資料；從流中讀取資料，即為從用戶端接收資料。

同步傳輸字元串

我們現在考慮這樣一個任務：用戶端列印一串字元串，然後發往服務端，服務端先輸出它，然後将它改為大寫，再回發到用戶端，用戶端接收到以後，最後再次列印一遍它。我們将它分為兩部分：1、用戶端發送，服務端接收并輸出；2、服務端回發，用戶端接收并輸出。

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、UTF8、ASCII三種常用編碼方式對字元串編碼時，占用的位元組數大小。

現在對用戶端不做任何修改，然後運作先運作服務端，再運作用戶端。結果我們會發現這樣一件事：服務端再列印完“Client Connected！127.0.0.1:8500 <-- 127.0.0.1:xxxxx”之後，再次被阻塞了，而沒有輸出“Reading data, {0} bytes ...”。可見，

與AcceptTcpClient()方法類似，這個Read()方法也是同步的，隻有當用戶端發送資料的時候，服務端才會讀取資料、運作此方法，否則它便會一直等待。

1.2 用戶端程式

接下來我們編寫用戶端向伺服器發送字元串的代碼，與服務端類似，它先擷取連接配接伺服器端的流，将字元串儲存到buffer緩存中，再将緩存寫入流，寫入流這一過程，相當于将消息發往服務端。

class Client {

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

現在再次運作程式，得到的輸出為：

// 服務端

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鍵退出”，說明程式已經執行完畢，無法再進行任何動作。此時如果我們再開啟一個用戶端，那麼出現的情況是：用戶端可以與伺服器建立連接配接，也就是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()的位置，以響應其它的用戶端。

對于第四種情況，實際上是建構一個服務端更為通常的情況，是以需要專門開辟一個章節讨論，這裡暫且放過。而我們上面所做的，即是列出的第一種情況，接下來我們再分别看一下第二種和第三種情況。

對于第二種情況，我們按照上面的叙述先對服務端進行一下改動：

// 擷取一個連接配接，中斷方法

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

然後啟動

多個

用戶端，在服務端應該可以看到下面的輸出（用戶端沒有變化）：

Client Connected！127.0.0.1:8500 <-- 127.0.0.1:8196

Client Connected！127.0.0.1:8500 <-- 127.0.0.1:8199

由第2種情況改為第3種情況，隻需要将do向下挪動幾行就可以了：

// 擷取一個連接配接，中斷方法

TcpClient remoteClient = listener.AcceptTcpClient();

// 列印連接配接到的用戶端資訊

Console.WriteLine("Client Connected！{0} <-- {1}",

remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);

// 獲得流，并寫入buffer中

NetworkStream streamToClient = remoteClient.GetStream();

然後我們再改動一下用戶端，讓它發送多個請求。當我們按下S的時候，可以輸入一行字元串，然後将這行字元串發送到服務端；當我們輸入X的時候則退出循環：

NetworkStream streamToServer = client.GetStream();

ConsoleKey key;

Console.WriteLine("Menu: S - Send, X - Exit");

key = Console.ReadKey(true).Key;

if (key == ConsoleKey.S) {

// 擷取輸入的字元串

Console.Write("Input the message: ");

string msg = Console.ReadLine();

} while (key != ConsoleKey.X);

接下來我們先運作服務端，然後再運作用戶端，輸入一些字元串，來進行測試，應該能夠看到下面的輸出結果：

Client Connected！127.0.0.1:8500 <-- 127.0.0.1:11004

Reading data, 44 bytes ...

Received: 歡迎通路我的部落格：TraceFact.Net

Reading data, 14 bytes ...

Received: 我們一起進步！

//用戶端

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，現在我們直接看代碼，首先看服務端：

const int BufferSize = 8192; // 緩存大小，8192Bytes

ConsoleKey key;

// 擷取一個連接配接，同步方法，在此處中斷

// 獲得流

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

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\"鍵退出。");

key = Console.ReadKey(true).Key;

} while (key != ConsoleKey.Q);

接下來是用戶端：

const int BufferSize = 8192;

NetworkStream streamToServer = client.GetStream();

Console.WriteLine("Menu: S - Send, X - Exit");

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

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

最後我們運作程式，然後輸入一串英文字元串，然後看一下輸出：

Client is running ...

Server Connected！127.0.0.1:12662 --> 127.0.0.1:8500

Input the message: Hello, I'm jimmy zhang.

Sent: Hello, I'm jimmy zhang.

Received: HELLO, I'M JIMMY ZHANG.

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、UTF8、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

Mode: Unicode, String: b, Buffer.Length: 2

Buffer: 98 0

Mode: ASCII, String: abcd, Buffer.Length: 4

Buffer: 97 98 99 100

Retrived: abcd

Mode: UTF8, String: abcd, Buffer.Length: 4

Mode: Unicode, String: abcd, Buffer.Length: 8

Buffer: 97 0 98 0 99 0 100 0

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

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

大體上可以得出這麼幾個結論：

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

C#網絡程式設計(同步傳輸字元串) - Part.2C#網絡程式設計(同步傳輸字元串) - Part.2

C#網絡程式設計(同步傳輸字元串) - Part.2

服務端用戶端通信

同步傳輸字元串

1.用戶端發送，服務端接收并輸出

1.1服務端程式

1.2 用戶端程式

2.服務端回發，用戶端接收并輸出

2.2服務端程式

附錄：ASCII、UTF8、Uncicode編碼下的中英文字元大小

繼續閱讀

Unity遊戲開發背景知識

vs編譯完提示不支援嘗試的執行操作

【C# MySQL】第一次使用C#對MySQL進行操作的心得

C#基礎——與C#的第一次邂逅聲明：IDE：第一個C#果實：Console淺析：總結：

英文月日年日期格式的實作

K-近鄰算法以及圖像分類應用

C# 位元組數組 byte[] 快速比較算法

C# 位元組數組、字元串轉化位元組數組轉字元串字元串轉位元組數組位元組數組轉整數整數轉位元組數組字元串轉位元組字元串轉數值數值轉字元串

C#用Zlib壓縮或解壓縮位元組數組

C# 比較兩個位元組數組是否相等

對于VS中scanf報錯永久解決，建立源檔案自動添加#define _CRT_SECURE_NO_WARNINGS 1

《C#進階程式設計》讀書筆記 -索引

CQ V1.0分詞bates(基于雙數組tire樹)—應該是目前最快的中文分詞算法

C#多線程——前台線程和背景線程

C#+ArcEngine代碼檢測ArcEngine Runtime是否安裝以及是否授權

七牛雲-C#SDK-上傳-前期準備