C#網絡編程(同步傳輸字符串) - Part.2
服務端客戶端通信
在與服務端的連接建立以后，我們就可以通過此連接來發(fā)送和接收數(shù)據(jù)。端口與端口之間以流（Stream）的形式傳輸數(shù)據(jù)，因為幾乎任何對象都可以保存到流中，所以實際上可以在客戶端與服務端之間傳輸任何類型的數(shù)據(jù)。對客戶端來說，往流中寫入數(shù)據(jù)，即為向服務器傳送數(shù)據(jù)；從流中讀取數(shù)據(jù)，即為從服務端接收數(shù)據(jù)。對服務端來說，往流中寫入數(shù)據(jù)，即為向客戶端發(fā)送數(shù)據(jù)；從流中讀取數(shù)據(jù)，即為從客戶端接收數(shù)據(jù)。
同步傳輸字符串
我們現(xiàn)在考慮這樣一個任務：客戶端打印一串字符串，然后發(fā)往服務端，服務端先輸出它，然后將它改為大寫，再回發(fā)到客戶端，客戶端接收到以后，最后再次打印一遍它。我們將它分為兩部分：1、客戶端發(fā)送，服務端接收并輸出；2、服務端回發(fā)，客戶端接收并輸出。
1.客戶端發(fā)送，服務端接收并輸出
1.1服務端程序
我們可以在TcpClient上調用GetStream()方法來獲得連接到遠程計算機的流。注意這里我用了遠程這個詞，當在客戶端調用時，它得到連接服務端的流；當在服務端調用時，它獲得連接客戶端的流。接下來我們來看一下代碼，我們先看服務端（注意這里沒有使用do/while循環(huán)）：
class Server {
static void
const int BufferSize = 8192; // 緩存大小，8192字節(jié)
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("
// 獲得請求的字符串
string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
Console.WriteLine("Received: {0}", msg);
// 按Q退出
}
}
這段程序的上半部分已經很熟悉了，我就不再解釋。remoteClient.GetStream()方法獲取到了連接至客戶端的流，然后從流中讀出數(shù)據(jù)并保存在了buffer緩存中，隨后使用Encoding.Unicode.GetString()方法，從緩存中獲取到了實際的字符串。最后將字符串打印在了控制臺上。這段代碼有個地方需要注意：在能夠讀取的字符串的總字節(jié)數(shù)大于BufferSize的時候會出現(xiàn)字符串截斷現(xiàn)象，因為緩存中的數(shù)目總是有限的，而對于大對象，比如說圖片或者其它文件來說，則必須采用“分次讀取然后轉存”這種方式，比如這樣：
// 獲取字符串
byte[] buffer = new byte[BufferSize];
int bytesRead; // 讀取的字節(jié)數(shù)
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);
這里我沒有使用這種方法，一個是因為不想關注在太多的細節(jié)上面，一個是因為對于字符串來說，8192字節(jié)已經很多了，我們通常不會傳遞這么多的文本。當使用Unicode編碼時，8192字節(jié)可以保存4096個漢字和英文字符。使用不同的編碼方式，占用的字節(jié)數(shù)有很大的差異，在本文最后面，有一段小程序，可以用來測試Unicode、UTF8、ASCII三種常用編碼方式對字符串編碼時，占用的字節(jié)數(shù)大小。
現(xiàn)在對客戶端不做任何修改，然后運行先運行服務端，再運行客戶端。結果我們會發(fā)現(xiàn)這樣一件事：服務端再打印完“Client Connected！127.0.0.1:8500 <-- 127.0.0.1:xxxxx”之后，再次被阻塞了，而沒有輸出“Reading data, {0} bytes ...”?？梢姡?strong>與AcceptTcpClient()方法類似，這個Read()方法也是同步的，只有當客戶端發(fā)送數(shù)據(jù)的時候，服務端才會讀取數(shù)據(jù)、運行此方法，否則它便會一直等待。
1.2 客戶端程序
接下來我們編寫客戶端向服務器發(fā)送字符串的代碼，與服務端類似，它先獲取連接服務器端的流，將字符串保存到buffer緩存中，再將緩存寫入流，寫入流這一過程，相當于將消息發(fā)往服務端。
class Client {
static void
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); // 發(fā)往服務器
Console.WriteLine("Sent: {0}", msg);
// 按Q退出
}
}
現(xiàn)在再次運行程序，得到的輸出為：
// 服務端
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"鍵退出。
再繼續(xù)進行之前，我們假設客戶端可以發(fā)送多條消息，而服務端要不斷的接收來自客戶端發(fā)送的消息，但是上面的代碼只能接收客戶端發(fā)來的一條消息，因為它已經輸出了“輸入Q鍵退出”，說明程序已經執(zhí)行完畢，無法再進行任何動作。此時如果我們再開啟一個客戶端，那么出現(xiàn)的情況是：客戶端可以與服務器建立連接，也就是netstat-a顯示為ESTABLISHED，這是操作系統(tǒng)所知道的；但是由于服務端的程序已經執(zhí)行到了最后一步，只能輸入Q鍵退出，無法再采取任何的動作。
回想一個上面我們需要一個服務器對應多個客戶端時，對AcceptTcpClient()方法的處理辦法，將它放在了do/while循環(huán)中；類似地，當我們需要一個服務端對同一個客戶端的多次請求服務時，可以將Read()方法放入到do/while循環(huán)中。
現(xiàn)在，我們大致可以得出這樣幾個結論：
- 如果不使用do/while循環(huán)，服務端只有一個listener.AcceptTcpClient()方法和一個TcpClient.GetStream().Read()方法，則服務端只能處理到同一客戶端的一條請求。
- 如果使用一個do/while循環(huán)，并將listener.AcceptTcpClient()方法和TcpClient.GetStream().Read()方法都放在這個循環(huán)以內，那么服務端將可以處理多個客戶端的一條請求。
- 如果使用一個do/while循環(huán)，并將listener.AcceptTcpClient()方法放在循環(huán)之外，將TcpClient.GetStream().Read()方法放在循環(huán)以內，那么服務端可以處理一個客戶端的多條請求。
- 如果使用兩個do/while循環(huán)，對它們進行分別嵌套，那么結果是什么呢？結果并不是可以處理多個客戶端的多條請求。因為里層的do/while循環(huán)總是在為一個客戶端服務，因為它會中斷在TcpClient.GetStream().Read()方法的位置，而無法執(zhí)行完畢。即使可以通過某種方式讓里層循環(huán)退出，比如客戶端往服務端發(fā)去“exit”字符串時，服務端也只能挨個對客戶端提供服務。如果服務端想執(zhí)行多個客戶端的多個請求，那么服務端就需要采用多線程。主線程，也就是執(zhí)行外層do/while循環(huán)的線程，在收到一個TcpClient之后，必須將里層的do/while循環(huán)交給新線程去執(zhí)行，然后主線程快速地重新回到listener.AcceptTcpClient()的位置，以響應其它的客戶端。
對于第四種情況，實際上是構建一個服務端更為通常的情況，所以需要專門開辟一個章節(jié)討論，這里暫且放過。而我們上面所做的，即是列出的第一種情況，接下來我們再分別看一下第二種和第三種情況。
對于第二種情況，我們按照上面的敘述先對服務端進行一下改動：
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("
// 獲得請求的字符串
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("
// 獲得請求的字符串
string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
Console.WriteLine("Received: {0}", msg);
} while (true);
然后我們再改動一下客戶端，讓它發(fā)送多個請求。當我們按下S的時候，可以輸入一行字符串，然后將這行字符串發(fā)送到服務端；當我們輸入X的時候則退出循環(huán)：
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); // 發(fā)往服務器
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
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()方法會持續(xù)地返回0，但是不拋出異常，所以會產生一個無限循環(huán)；而如果直接關閉掉客戶端，或者客戶端執(zhí)行完畢但沒有調用stream.Dispose()或者TcpClient.Close()，如果服務器端此時仍阻塞在Read()方法處，則會在服務器端拋出異常：“遠程主機強制關閉了一個現(xiàn)有連接”。因此，我們將服務端的streamToClient.Read()方法需要寫在一個try/catch中。同理，如果在服務端已經連接到客戶端之后，服務端調用remoteClient.Close()，則客戶端會得到異常“無法將數(shù)據(jù)寫入傳輸連接: 您的主機中的軟件放棄了一個已建立的連接。”；而如果服務端直接關閉程序的話，則客戶端會得到異常“無法將數(shù)據(jù)寫入傳輸連接: 遠程主機強迫關閉了一個現(xiàn)有的連接。”。因此，它們的讀寫操作必須都放入到try/catch塊中。
2.服務端回發(fā)，客戶端接收并輸出
2.2服務端程序
我們接著再進行進一步處理，服務端將收到的字符串改為大寫，然后回發(fā)，客戶端接收后打印。此時它們的角色和上面完全進行了一下對調：對于服務端來說，就好像剛才的客戶端一樣，將字符串寫入到流中；而客戶端則同服務端一樣，接收并打印。除此以外，我們最好對流的讀寫操作加上lock，現(xiàn)在我們直接看代碼，首先看服務端：
class Server {
static void
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字節(jié)");
Console.WriteLine("
// 獲得請求的字符串
string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
Console.WriteLine("Received: {0}", msg);
// 轉換成大寫并發(fā)送
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
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); // 發(fā)往服務器
}
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、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
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個字節(jié)，與ASCII編碼方式和長度相同；Unicode在對ASCII字符編碼時，占用2個字節(jié)，且第2個字節(jié)補零。
- UTF8在對中文編碼時需要占用3個字節(jié)；Unicode對中文編碼則只需要2個字節(jié)。
