C#网络编程:4订立协议和发送文件

前面两篇文章所使用的范例都是传输字符串，有的时候我们可能会想在服务端和客户端之间传递文件。比如，考虑这样一种情况，假如客户端显示了一个菜单，当我们输入S1、S2或S3（S为Send缩写）时，分别向服务端发送文件Client01.jpg、Client02.jpg、Client03.jpg；当我们输入R1、R2或R3时（R为Receive缩写），则分别从服务端接收文件Server01.jpg、Server02.jpg、Server03.jpg。那么，我们该如何完成这件事呢？此时可能有这样两种做法：

类似于FTP协议，服务端开辟两个端口，并持续对这两个端口侦听：一个用于接收字符串，类似于FTP的控制端口，它接收各种命令（接收或发送文件）；一个用于传输数据，也就是发送和接收文件。

服务端只开辟一个端口，用于接收字符串，我们称之为控制端口。当接到请求之后，根据请求内容在客户端开辟一个端口专用于文件传输，并在传输结束后关闭端口。

现在我们只关注于上面的数据端口，回忆一下在第二篇中我们所总结的，可以得出：当我们使用上面的方法一时，服务端的数据端口可以为多个客户端的多次请求服务；当我们使用方法二时，服务端只为一个客户端的一次请求服务，但是因为每次请求都会重新开辟端口，所以实际上还是相当于可以为多个客户端的多次请求服务。同时，因为它只为一次请求服务，所以我们在数据端口上传输文件时无需采用异步传输方式。但在控制端口我们仍然需要使用异步方式。

从上面看出，第一种方式要好得多，但是我们将采用第二种方式。至于原因，你可以回顾一下Part.1（基本概念和操作）中关于聊天程序模式的讲述，因为接下来一篇文章我们将创建一个聊天程序，而这个聊天程序采用第三种模式，所以本文的练习实际是对下一篇的一个铺垫。

1.订立协议

1.1发送文件

我们先看一下发送文件的情况，如果我们想将文件client01.jpg由客户端发往客户端，那么流程是什么：

客户端开辟数据端口用于侦听，并获取端口号，假设为8005。

假设客户端输入了S1，则发送下面的控制字符串到服务端：[file=Client01.jpg, mode=send, port=8005]。

服务端收到以后，根据客户端ip和端口号与该客户端建立连接。

客户端侦听到服务端的连接，开始发送文件。

传送完毕后客户端、服务端分别关闭连接。

此时，我们订立的发送文件协议为：[file=Client01.jpg, mode=send, port=8005]。但是，由于它是一个普通的字符串，在上一篇中，我们采用了正则表达式来获取其中的有效值，但这显然不是一种好办法。因此，在本文及下一篇文章中，我们采用一种新的方式来编写协议：XML。对于上面的语句，我们可以写成这样的XML：

1. <protocol><file name="client01.jpg" mode="send" port="8005" /></protocol>

这样我们在服务端就会好处理得多，接下来我们来看一下接收文件的流程及其协议。

NOTE：这里说发送、接收文件是站在客户端的立场说的，当客户端发送文件时，对于服务器来收，则是接收文件。

1.2接收文件

接收文件与发送文件实际上完全类似，区别只是由客户端向网络流写入数据，还是由服务端向网络流写入数据。

客户端开辟数据端口用于侦听，假设为8006。

假设客户端输入了R1，则发送控制字符串：<protocol><file name="Server01.jpg" mode="receive" port="8006" /></protocol>到服务端。

服务端收到以后，根据客户端ip和端口号与该客户端建立连接。

客户端建立起与服务端的连接，服务端开始网络流中写入数据。

传送完毕后服务端、客户端分别关闭连接。

2.协议处理类的实现

和上面一章一样，在开始编写实际的服务端客户端代码之前，我们首先要编写处理协议的类，它需要提供这样两个功能：1、方便地帮我们获取完整的协议信息，因为前面我们说过，服务端可能将客户端的多次独立请求拆分或合并。比如，客户端连续发送了两条控制信息到服务端，而服务端将它们合并了，那么则需要先拆开再分别处理。2、方便地获取我们所想要的属性信息，因为协议是XML格式，所以还需要一个类专门对XML进行处理，获得字符串的属性值。

2.1 ProtocalHandler辅助类

我们先看下ProtocalHandler，它与上一篇中的RequestHandler作用相同。需要注意的是必须将它声明为实例的，而非静态的，这是因为每个TcpClient都需要对应一个ProtocalHandler，因为它内部维护的patialProtocal不能共享，在协议发送不完整的情况下，这个变量用于临时保存被截断的字符串。

1. public class ProtocolHandler { 
3. private string partialProtocal; // 保存不完整的协议
7. public ProtocolHandler() { 
9.         partialProtocal = "";      
11.     } 
13. public string[] GetProtocol(string input) { 
15. return GetProtocol(input, null); 
17.     } 
21. // 获得协议
23. private string[] GetProtocol(string input, List<string> outputList) { 
25. if (outputList == null) 
27.             outputList = new List<string>(); 
29. if (String.IsNullOrEmpty(input)) 
31. return outputList.ToArray(); 
33. if (!String.IsNullOrEmpty(partialProtocal)) 
35.             input = partialProtocal + input; 
37. string pattern = "(^<protocol>.*?</protocol>)"; 
39. // 如果有匹配，说明已经找到了，是完整的协议
41. if (Regex.IsMatch(input, pattern)) { 
43. // 获取匹配的值
45. string match = Regex.Match(input, pattern).Groups[0].Value; 
47.             outputList.Add(match); 
49.             partialProtocal = ""; 
51. // 缩短input的长度
53.             input = input.Substring(match.Length); 
55. // 递归调用
57.             GetProtocol(input, outputList); 
59.         } else { 
61. // 如果不匹配，说明协议的长度不够，
63. // 那么先缓存，然后等待下一次请求
65.             partialProtocal = input; 
67.         } 
69. return outputList.ToArray(); 
71.     } 
73. } 

因为现在它已经不是本文的重点了，所以我就不演示对于它的测试了，本文所附带的代码中含有它的测试代码（我在ProtocolHandler中添加了一个静态类Test()）。

2.2 FileRequestType枚举和FileProtocol结构

因为XML是以字符串的形式在进行传输，为了方便使用，我们最好构建一个强类型来对它们进行操作，这样会方便很多。我们首先可以定义FileRequestMode枚举，它代表是发送还是接收文件：

1. public enum FileRequestMode { 
3.     Send = 0, 
5.     Receive 
7. } 

接下来我们再定义一个FileProtocol结构，用来为整个协议字符串提供强类型的访问，注意这里覆盖了基类的ToString()方法，这样在客户端我们就不需要再手工去编写XML，只要在结构值上调用ToString()就OK了，会方便很多。

1. public struct FileProtocol { 
3. private readonly FileRequestMode mode; 
5. private readonly int port; 
7. private readonly string fileName; 
9. public FileProtocol 
11.         (FileRequestMode mode, int port, string fileName) { 
13. this.mode = mode; 
15. this.port = port; 
17. this.fileName = fileName; 
19.     } 
21. public FileRequestMode Mode { 
23. get { return mode; } 
25.     } 
27. public int Port { 
29. get { return port; } 
31.     } 
33. public string FileName { 
35. get { return fileName; } 
37.     } 
39. public override string ToString() { 
41. return String.Format("<protocol><file name=\"{0}\" mode=\"{1}\" port=\"{2}\" /></protocol>", fileName, mode, port); 
43.     } 
45. } 

2.3 ProtocolHelper辅助类

这个类专用于将XML格式的协议映射为我们上面定义的强类型对象，这里我没有加入try/catch异常处理，因为协议对用户来说是不可见的，而且客户端应该总是发送正确的协议，我觉得这样可以让代码更加清晰：

1. public class ProtocolHelper { 
3. private XmlNode fileNode; 
5. private XmlNode root; 
9. public ProtocolHelper(string protocol) { 
11.         XmlDocument doc = new XmlDocument(); 
13.         doc.LoadXml(protocol); 
15.         root = doc.DocumentElement; 
17.         fileNode = root.SelectSingleNode("file"); 
19.     } 
21. // 此时的protocal一定为单条完整protocal
23. private FileRequestMode GetFileMode() { 
25. string mode = fileNode.Attributes["mode"].Value; 
27.         mode = mode.ToLower(); 
29. if (mode == "send") 
31. return FileRequestMode.Send; 
33. else
35. return FileRequestMode.Receive; 
37.     } 
39. // 获取单条协议包含的信息
41. public FileProtocol GetProtocol() { 
43.         FileRequestMode mode = GetFileMode(); 
45. string fileName = ""; 
47. int port = 0; 
49.         fileName = fileNode.Attributes["name"].Value; 
51.         port = Convert.ToInt32(fileNode.Attributes["port"].Value); 
53. return new FileProtocol(mode, port, fileName); 
55.     } 
57. } 

OK，我们又耽误了点时间，下面就让我们进入正题吧。

3.客户端发送数据

3.1 服务端的实现

我们还是将一个问题分成两部分来处理，先是发送数据，然后是接收数据。我们先看发送数据部分的服务端。如果你从第一篇文章看到了现在，那么我觉得更多的不是技术上的问题而是思路，所以我们不再将重点放到代码上，这些应该很容易就看懂了。

1. class Server { 
3. static void Main(string[] args) { 
5.         Console.WriteLine("Server is running ... "); 
7.         IPAddress ip = IPAddress.Parse("127.0.0.1"); 
9.         TcpListener listener = new TcpListener(ip, 8500); 
11.         listener.Start();           // 开启对控制端口 8500 的侦听
13.         Console.WriteLine("Start Listening ..."); 
15. while (true) { 
17. // 获取一个连接，同步方法，在此处中断
19.             TcpClient client = listener.AcceptTcpClient();             
21.             RemoteClient wapper = new RemoteClient(client); 
23.             wapper.BeginRead(); 
25.         } 
27.     } 
29. } 
31. public class RemoteClient { 
33. private TcpClient client; 
35. private NetworkStream streamToClient; 
37. private const int BufferSize = 8192; 
39. private byte[] buffer; 
41. private ProtocolHandler handler; 
45. public RemoteClient(TcpClient client) { 
47. this.client = client; 
49. // 打印连接到的客户端信息
51.         Console.WriteLine("\nClient Connected！{0} <-- {1}", 
53.             client.Client.LocalEndPoint, client.Client.RemoteEndPoint); 
55. // 获得流
57.         streamToClient = client.GetStream(); 
59.         buffer = new byte[BufferSize]; 
61.         handler = new ProtocolHandler(); 
63.     } 
65. // 开始进行读取
67. public void BeginRead() {      
69.         AsyncCallback callBack = new AsyncCallback(OnReadComplete); 
71.         streamToClient.BeginRead(buffer, 0, BufferSize, callBack, null); 
73.     } 
75. // 再读取完成时进行回调
77. private void OnReadComplete(IAsyncResult ar) { 
79. int bytesRead = 0; 
81. try { 
83. lock (streamToClient) { 
85.                 bytesRead = streamToClient.EndRead(ar); 
87.                 Console.WriteLine("Reading data, {0} bytes ...", bytesRead); 
89.             } 
91. if (bytesRead == 0) throw new Exception("读取到0字节"); 
93. string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead); 
95.             Array.Clear(buffer,0,buffer.Length);        // 清空缓存，避免脏读
97. // 获取protocol数组
99. string[] protocolArray = handler.GetProtocol(msg); 
101. foreach (string pro in protocolArray) { 
103. // 这里异步调用，不然这里可能会比较耗时
105.                 ParameterizedThreadStart start = 
107. new ParameterizedThreadStart(handleProtocol); 
109.                 start.BeginInvoke(pro, null, null); 
111.             } 
113. // 再次调用BeginRead()，完成时调用自身，形成无限循环
115. lock (streamToClient) { 
117.                 AsyncCallback callBack = new AsyncCallback(OnReadComplete); 
119.                 streamToClient.BeginRead(buffer, 0, BufferSize, callBack, null); 
121.             } 
123.         } catch(Exception ex) { 
125. if(streamToClient!=null) 
127.                 streamToClient.Dispose(); 
129.             client.Close(); 
131.             Console.WriteLine(ex.Message);      // 捕获异常时退出程序
133.         } 
135.     } 
137. // 处理protocol
139. private void handleProtocol(object obj) { 
141. string pro = obj as string; 
143.         ProtocolHelper helper = new ProtocolHelper(pro); 
145.         FileProtocol protocol = helper.GetProtocol(); 
147. if (protocol.Mode == FileRequestMode.Send) { 
149. // 客户端发送文件，对服务端来说则是接收文件
151.             receiveFile(protocol); 
153.         } else if (protocol.Mode == FileRequestMode.Receive) { 
155. // 客户端接收文件，对服务端来说则是发送文件
157. // sendFile(protocol);
159.         } 
161.     } 
163. private void receiveFile(FileProtocol protocol) { 
165. // 获取远程客户端的位置
167.         IPEndPoint endpoint = client.Client.RemoteEndPoint as IPEndPoint; 
169.         IPAddress ip = endpoint.Address; 
173. // 使用新端口号，获得远程用于接收文件的端口
175.         endpoint = new IPEndPoint(ip, protocol.Port); 
177. // 连接到远程客户端
179.         TcpClient localClient; 
181. try { 
183.             localClient = new TcpClient(); 
185.             localClient.Connect(endpoint); 
187.         } catch { 
189.             Console.WriteLine("无法连接到客户端 --> {0}", endpoint); 
191. return; 
193.         } 
195. // 获取发送文件的流
197.         NetworkStream streamToClient = localClient.GetStream(); 
199. // 随机生成一个在当前目录下的文件名称
201. string path = 
203.             Environment.CurrentDirectory + "/" + generateFileName(protocol.FileName); 
205. byte[] fileBuffer = new byte[1024]; // 每次收1KB
207.         FileStream fs = new FileStream(path, FileMode.CreateNew, FileAccess.Write); 
209. // 从缓存buffer中读入到文件流中
211. int bytesRead; 
213. int totalBytes = 0; 
215. do { 
217.             bytesRead = streamToClient.Read(buffer, 0, BufferSize);            
219.             fs.Write(buffer, 0, bytesRead); 
221.             totalBytes += bytesRead; 
223.             Console.WriteLine("Receiving {0} bytes ...", totalBytes); 
225.         } while (bytesRead > 0); 
227.         Console.WriteLine("Total {0} bytes received, Done!", totalBytes); 
229.         streamToClient.Dispose(); 
231.         fs.Dispose(); 
233.         localClient.Close(); 
235.     } 
237. // 随机获取一个图片名称
239. private string generateFileName(string fileName) { 
241.         DateTime now = DateTime.Now; 
243. return String.Format( 
245. "{0}_{1}_{2}_{3}", now.Minute, now.Second, now.Millisecond, fileName 
247.         ); 
249.     } 
251. } 

这里应该没有什么新知识，需要注意的地方有这么几个：

在OnReadComplete()回调方法中的foreach循环，我们使用委托异步调用了handleProtocol()方法，这是因为handleProtocol即将执行的是一个读取或接收文件的操作，也就是一个相对耗时的操作。

在handleProtocol()方法中，我们深切体会了定义ProtocolHelper类和FileProtocol结构的好处。如果没有定义它们，这里将是不堪入目的处理XML以及类型转换的代码。

handleProtocol()方法中进行了一个条件判断，注意sendFile()方法我屏蔽掉了，这个还没有实现，但是我想你已经猜到它将是后面要实现的内容。

receiveFile()方法是实际接收客户端发来文件的方法，这里没有什么特别之处。需要注意的是文件存储的路径，它保存在了当前程序执行的目录下，文件的名称我使用generateFileName()生成了一个与时间有关的随机名称。

3.2客户端的实现

我们现在先不着急实现客户端S1、R1等用户菜单，首先完成发送文件这一功能，实际上，就是为上一节SendMessage()加一个姐妹方法SendFile()。

1. class Client { 
3. static void Main(string[] args) { 
5.         ConsoleKey key; 
7.         ServerClient client = new ServerClient(); 
9. string filePath = Environment.CurrentDirectory + "/" + "Client01.jpg"; 
11. if(File.Exists(filePath)) 
13.             client.BeginSendFile(filePath); 
17.         Console.WriteLine("\n\n输入\"Q\"键退出。"); 
19. do { 
21.             key = Console.ReadKey(true).Key; 
23.         } while (key != ConsoleKey.Q); 
25.     } 
27. } 
29. public class ServerClient { 
31. private const int BufferSize = 8192; 
33. private byte[] buffer; 
35. private TcpClient client; 
37. private NetworkStream streamToServer; 
39. public ServerClient() { 
41. try { 
43.             client = new TcpClient(); 
45.             client.Connect("localhost", 8500);      // 与服务器连接
47.         } catch (Exception ex) { 
49.             Console.WriteLine(ex.Message); 
51. return; 
53.         } 
55.         buffer = new byte[BufferSize]; 
57. // 打印连接到的服务端信息
59.         Console.WriteLine("Server Connected！{0} --> {1}", 
61.             client.Client.LocalEndPoint, client.Client.RemoteEndPoint); 
63.         streamToServer = client.GetStream(); 
65.     } 
67. // 发送消息到服务端
69. public void SendMessage(string msg) { 
71. byte[] temp = Encoding.Unicode.GetBytes(msg);   // 获得缓存
73. try { 
75. lock (streamToServer) { 
77.                 streamToServer.Write(temp, 0, temp.Length); // 发往服务器
79.             } 
81.             Console.WriteLine("Sent: {0}", msg); 
83.         } catch (Exception ex) { 
85.             Console.WriteLine(ex.Message); 
87. return; 
89.         } 
91.     } 
93. // 发送文件 - 异步方法
95. public void BeginSendFile(string filePath) { 
97.         ParameterizedThreadStart start = 
99. new ParameterizedThreadStart(BeginSendFile); 
101.         start.BeginInvoke(filePath, null, null); 
103.     } 
105. private void BeginSendFile(object obj) { 
107. string filePath = obj as string; 
109.         SendFile(filePath); 
111.     } 
113. // 发送文件 -- 同步方法
115. public void SendFile(string filePath) { 
117.         IPAddress ip = IPAddress.Parse("127.0.0.1"); 
119.         TcpListener listener = new TcpListener(ip, 0); 
121.         listener.Start(); 
123. // 获取本地侦听的端口号
125.         IPEndPoint endPoint = listener.LocalEndpoint as IPEndPoint; 
127. int listeningPort = endPoint.Port; 
129. // 获取发送的协议字符串
131. string fileName = Path.GetFileName(filePath); 
133.         FileProtocol protocol = 
135. new FileProtocol(FileRequestMode.Send, listeningPort, fileName); 
137. string pro = protocol.ToString(); 
139.         SendMessage(pro);       // 发送协议到服务端
141. // 中断，等待远程连接
143.         TcpClient localClient = listener.AcceptTcpClient(); 
145.         Console.WriteLine("Start sending file..."); 
147.         NetworkStream stream = localClient.GetStream(); 
149. // 创建文件流
151.         FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);          
153. byte[] fileBuffer = new byte[1024];     // 每次传1KB
155. int bytesRead; 
157. int totalBytes = 0; 
159. // 创建获取文件发送状态的类
161.         SendStatus status = new SendStatus(filePath); 
163. // 将文件流转写入网络流
165. try { 
167. do { 
169.                 Thread.Sleep(10);           // 为了更好的视觉效果，暂停10毫秒:-)
171.                 bytesRead = fs.Read(fileBuffer, 0, fileBuffer.Length);                 
173.                 stream.Write(fileBuffer, 0, bytesRead); 
175.                 totalBytes += bytesRead;            // 发送了的字节数
177.                 status.PrintStatus(totalBytes); // 打印发送状态
179.             } while (bytesRead > 0); 
181.             Console.WriteLine("Total {0} bytes sent, Done!", totalBytes); 
183.         } catch { 
185.             Console.WriteLine("Server has lost..."); 
187.         } 
191.         stream.Dispose(); 
193.         fs.Dispose(); 
195.         localClient.Close(); 
197.         listener.Stop(); 
199.     } 
201. } 

接下来我们来看下这段代码，有这么两点需要注意一下：

•    在Main()方法中可以看到，图片的位置为应用程序所在的目录，如果你跟我一样处于调试模式，那么就在解决方案的Bin目录下的Debug目录中放置三张图片Client01.jpg、Client02.jpg、Client03.jpg，用来发往服务端。

•    我在客户端提供了两个SendFile()方法，和一个BeginSendFile()方法，分别用于同步和异步传输，其中私有的SendFile()方法只是一个辅助方法。实际上对于发送文件这样的操作我们几乎总是需要使用异步操作。

•    SendMessage()方法中给streamToServer加锁很重要，因为SendFile()方法是多线程访问的，而在SendFile()方法中又调用了SendMessage()方法。

•    我另外编写了一个SendStatus类，它用来记录和打印发送完成的状态，已经发送了多少字节，完成度是百分之多少，等等。本来这个类的内容我是直接写入在Client类中的，后来我觉得它执行的工作已经不属于Client本身所应该执行的领域之内了，我记得这样一句话：当你觉得类中的方法与类的名称不符的时候，那么就应该考虑重新创建一个类。我觉得用在这里非常恰当。

下面是SendStatus的内容：

1. // 即时计算发送文件的状态
3. public class SendStatus { 
5. private FileInfo info; 
7. private long fileBytes; 
9. public SendStatus(string filePath) { 
11.         info = new FileInfo(filePath); 
13.         fileBytes = info.Length; 
15.     } 
17. public void PrintStatus(int sent) { 
19. string percent = GetPercent(sent); 
21.         Console.WriteLine("Sending {0} bytes, {1}% ...", sent, percent); 
23.     } 
25. // 获得文件发送的百分比
27. public string GetPercent(int sent){    
29. decimal allBytes = Convert.ToDecimal(fileBytes); 
31. decimal currentSent = Convert.ToDecimal(sent); 
33. decimal percent = (currentSent / allBytes) * 100; 
35.         percent = Math.Round(percent, 1);   //保留一位小数
39. if (percent.ToString() == "100.0") 
41. return "100"; 
43. else
45. return percent.ToString(); 
47.     } 
49. } 

3.3程序测试

接下里我们运行一下程序，来检查一下输出，首先看下服务端：

接着是客户端，我们能够看到发送的字节数和进度，可以想到如果是图形界面，那么我们可以通过扩展SendStatus类来创建一个进度条：

最后我们看下服务端的Bin\Debug目录，应该可以看到接收到的图片：

本来我想这篇文章就可以完成发送和接收，不过现在看来没法实现了，因为如果继续下去这篇文章就太长了，我正尝试着尽量将文章控制在15页以内。那么我们将在下篇文章中再完成接收文件这一部分。