服務端客戶端通信
在與服務端的連接建立以後，我們就可以通過此連接來發送和接收數據。端口與端口之間以流 （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 {
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、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個字節，與ASCII編碼方式和長度相同 ；Unicode在對ASCII字符編碼時，占用2個字節，且第2個字節補零。
UTF8在對中文編碼時需要占用3個字節；Unicode對中文編碼則只需要2個字節。
