C#网络编程:5接收文件

这篇文章将完成Part.4中剩余的部分，它们本来是一篇完整的文章，但是因为上一篇比较长，合并起来页数太多，浏览起来可能会比较不方便，我就将它拆为两篇了，本文便是它的后半部分。我们继续进行上一篇没有完成的步骤：客户端接收来自服务端的文件。

4.客户端接收文件

4.1服务端的实现

对于服务端，我们只需要实现上一章遗留的sendFile()方法就可以了，它起初在handleProtocol中是注释掉的。另外，由于创建连接、获取流等操作与receiveFile()是没有区别的，所以我们将它提出来作为一个公共方法getStreamToClient()。下面是服务端的代码，只包含新增改过的代码，对于原有方法我只给出了签名：

1. class Server {
2. static void Main(string[] args) {
3. Console.WriteLine("Server is running ... ");
4. IPAddress ip = IPAddress.Parse("127.0.0.1");
5. TcpListener listener = new TcpListener(ip, 8500);
6. listener.Start(); // 开启对控制端口 8500 的侦听
7. Console.WriteLine("Start Listening ...");
8. while (true) {
9. // 获取一个连接，同步方法，在此处中断
10. TcpClient client = listener.AcceptTcpClient();
11. RemoteClient wapper = new RemoteClient(client);
12. wapper.BeginRead();
13. }
14. }
15. }
16. public class RemoteClient {
17. // 字段 略
18. public RemoteClient(TcpClient client) {}
19. // 开始进行读取
20. public void BeginRead() { }
21. // 再读取完成时进行回调
22. private void OnReadComplete(IAsyncResult ar) { }
23. // 处理protocol
24. private void handleProtocol(object obj) {
25. string pro = obj as string;
26. ProtocolHelper helper = new ProtocolHelper(pro);
27. FileProtocol protocol = helper.GetProtocol();
28. if (protocol.Mode == FileRequestMode.Send) {
29. // 客户端发送文件，对服务端来说则是接收文件
30. receiveFile(protocol);
31. } else if (protocol.Mode == FileRequestMode.Receive) {
32. // 客户端接收文件，对服务端来说则是发送文件
33. sendFile(protocol);
34. }
35. }
36. // 发送文件
37. private void sendFile(FileProtocol protocol) {
38. TcpClient localClient;
39. NetworkStream streamToClient = getStreamToClient(protocol, out localClient);
40. // 获得文件的路径
41. string filePath = Environment.CurrentDirectory + "/" + protocol.FileName;
42. // 创建文件流
43. FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
44. byte[] fileBuffer = new byte[1024]; // 每次传1KB
45. int bytesRead;
46. int totalBytes = 0;
47. // 创建获取文件发送状态的类
48. SendStatus status = new SendStatus(filePath);
49. // 将文件流转写入网络流
50. try {
51. do {
52. Thread.Sleep(10); // 为了更好的视觉效果，暂停10毫秒:-)
53. bytesRead = fs.Read(fileBuffer, 0, fileBuffer.Length);
54. streamToClient.Write(fileBuffer, 0, bytesRead);
55. totalBytes += bytesRead; // 发送了的字节数
56. status.PrintStatus(totalBytes); // 打印发送状态
57. } while (bytesRead > 0);
58. Console.WriteLine("Total {0} bytes sent, Done!", totalBytes);
59. } catch {
60. Console.WriteLine("Server has lost...");
61. }
62. streamToClient.Dispose();
63. fs.Dispose();
64. localClient.Close();
65. }
66. // 接收文件
67. private void receiveFile(FileProtocol protocol) { }
68. // 获取连接到远程的流 -- 公共方法
69. private NetworkStream getStreamToClient(FileProtocol protocol, out TcpClient localClient) {
70. // 获取远程客户端的位置
71. IPEndPoint endpoint = client.Client.RemoteEndPoint as IPEndPoint;
72. IPAddress ip = endpoint.Address;
73. // 使用新端口号，获得远程用于接收文件的端口
74. endpoint = new IPEndPoint(ip, protocol.Port);
75. // 连接到远程客户端
76. try {
77. localClient = new TcpClient();
78. localClient.Connect(endpoint);
79. } catch {
80. Console.WriteLine("无法连接到客户端 --> {0}", endpoint);
81. localClient = null;
82. return null;
83. }
84. // 获取发送文件的流
85. NetworkStream streamToClient = localClient.GetStream();
86. return streamToClient;
87. }
88. // 随机获取一个图片名称
89. private string generateFileName(string fileName) {}
90. }

服务端的sendFile方法和客户端的SendFile()方法完全类似，上面的代码几乎是一次编写成功的。另外注意我将客户端使用的SendStatus类也拷贝到了服务端。接下来我们看下客户端。

4.2客户端的实现

首先要注意的是客户端的SendFile()接收的参数是文件全路径，但是在写入到协议时只获取了路径中的文件名称。这是因为服务端不需要知道文件在客户端的路径，所以协议中只写文件名；而为了使客户端的SendFile()方法更通用，所以它接收本地文件的全路径。

客户端的ReceiveFile()的实现也和服务端的receiveFile()方法类似，同样，由于要保存到本地，为了避免文件名重复，我将服务端的generateFileName()方法复制了过来。

1. public class ServerClient :IDisposable {
2. // 字段略
3. public ServerClient() {}
4. // 发送消息到服务端
5. public void SendMessage(string msg) {}
6. // 发送文件 - 异步方法
7. public void BeginSendFile(string filePath) { }
8. private void SendFile(object obj) { }
9. // 发送文件 -- 同步方法
10. public void SendFile(string filePath) {}
11. // 接收文件 -- 异步方法
12. public void BeginReceiveFile(string fileName) {
13. ParameterizedThreadStart start =
14. new ParameterizedThreadStart(ReceiveFile);
15. start.BeginInvoke(fileName, null, null);
16. }
17. public void ReceiveFile(object obj) {
18. string fileName = obj as string;
19. ReceiveFile(fileName);
20. }
21. // 接收文件 -- 同步方法
22. public void ReceiveFile(string fileName) {
23. IPAddress ip = IPAddress.Parse("127.0.0.1");
24. TcpListener listener = new TcpListener(ip, 0);
25. listener.Start();
26. // 获取本地侦听的端口号
27. IPEndPoint endPoint = listener.LocalEndpoint as IPEndPoint;
28. int listeningPort = endPoint.Port;
29. // 获取发送的协议字符串
30. FileProtocol protocol =
31. new FileProtocol(FileRequestMode.Receive, listeningPort, fileName);
32. string pro = protocol.ToString();
33. SendMessage(pro); // 发送协议到服务端
34. // 中断，等待远程连接
35. TcpClient localClient = listener.AcceptTcpClient();
36. Console.WriteLine("Start sending file...");
37. NetworkStream stream = localClient.GetStream();
38. // 获取文件保存的路劲
39. string filePath =
40. Environment.CurrentDirectory + "/" + generateFileName(fileName);
41. // 创建文件流
42. FileStream fs = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write);
43. byte[] fileBuffer = new byte[1024]; // 每次传1KB
44. int bytesRead;
45. int totalBytes = 0;
46. // 从缓存buffer中读入到文件流中
47. do {
48. bytesRead = stream.Read(buffer, 0, BufferSize);
49. fs.Write(buffer, 0, bytesRead);
50. totalBytes += bytesRead;
51. Console.WriteLine("Receiving {0} bytes ...", totalBytes);
52. } while (bytesRead > 0);
53. Console.WriteLine("Total {0} bytes received, Done!", totalBytes);
54. fs.Dispose();
55. stream.Dispose();
56. localClient.Close();
57. listener.Stop();
58. }
59. // 随机获取一个图片名称
60. private string generateFileName(string fileName) {}
61. public void Dispose() {
62. if (streamToServer != null)
63. streamToServer.Dispose();
64. if (client != null)
65. client.Close();
66. }
67. }

上面关键的一句就是创建协议那句，注意到将mode由Send改为了Receive，同时传去了想要接收的服务端的文件名称。

4.3程序测试

现在我们已经完成了所有收发文件的步骤，可以看到服务端的所有操作都是被动的，接下来我们修改客户端的Main()程序，创建一个菜单，然后根据用户输入发送或者接收文件。

1. class Program {
2. static void Main(string[] args) {
3. ServerClient client = new ServerClient();
4. string input;
5. string path = Environment.CurrentDirectory + "/";
6. do {
7. Console.WriteLine("Send File: S1 - Client01.jpg, S2 - Client02.jpg, S3 - Client03.jpg");
8. Console.WriteLine("Receive File: R1 - Server01.jpg, R1 - Server02.jpg, R3- Server03.jpg");
9. Console.WriteLine("Press 'Q' to exit. \n");
10. Console.Write("Enter your choice: ");
11. input = Console.ReadLine();
12. switch(input.ToUpper()){
13. case "S1":
14. client.BeginSendFile(path + "Client01.jpg");
15. break;
16. case "S2":
17. client.BeginSendFile(path + "Client02.jpg");
18. break;
19. case "S3":
20. client.BeginSendFile(path + "Client02.jpg");
21. break;
22. case "R1":
23. client.BeginReceiveFile("Server01.jpg");
24. break;
25. case "R2":
26. client.BeginReceiveFile("Server01.jpg");
27. break;
28. case "R3":
29. client.BeginReceiveFile("Server01.jpg");
30. break;
31. }
32. } while (input.ToUpper() != "Q");
33. client.Dispose();
34. }
35. }

由于这是一个控制台应用程序，并且采用了异步操作，所以这个菜单的出现顺序有点混乱。我这里描述起来比较困难，你将代码下载下来后运行一下就知道了:-)

程序的运行结果和上一节类似，这里我就不再贴图了。接下来是本系列的最后一篇，将发送字符串与传输文件的功能结合起来，创建一个可以发送消息并能收发文件的聊天程序，至于语音聊天嘛...等我学习了再告诉你 >_<、

posted @ 2010-07-24 13:31 大漠银狐 阅读(42) | 评论(0) | 编辑

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 {
2. private string partialProtocal; // 保存不完整的协议
3. public ProtocolHandler() {
4. partialProtocal = "";
5. }
6. public string[] GetProtocol(string input) {
7. return GetProtocol(input, null);
8. }
9. // 获得协议
10. private string[] GetProtocol(string input, List<string> outputList) {
11. if (outputList == null)
12. outputList = new List<string>();
13. if (String.IsNullOrEmpty(input))
14. return outputList.ToArray();
15. if (!String.IsNullOrEmpty(partialProtocal))
16. input = partialProtocal + input;
17. string pattern = "(^<protocol>.*?</protocol>)";
18. // 如果有匹配，说明已经找到了，是完整的协议
19. if (Regex.IsMatch(input, pattern)) {
20. // 获取匹配的值
21. string match = Regex.Match(input, pattern).Groups[0].Value;
22. outputList.Add(match);
23. partialProtocal = "";
24. // 缩短input的长度
25. input = input.Substring(match.Length);
26. // 递归调用
27. GetProtocol(input, outputList);
28. } else {
29. // 如果不匹配，说明协议的长度不够，
30. // 那么先缓存，然后等待下一次请求
31. partialProtocal = input;
32. }
33. return outputList.ToArray();
34. }
35. }

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

2.2 FileRequestType枚举和FileProtocol结构

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

1. public enum FileRequestMode {
2. Send = 0,
3. Receive
4. }

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

1. public struct FileProtocol {
2. private readonly FileRequestMode mode;
3. private readonly int port;
4. private readonly string fileName;
5. public FileProtocol
6. (FileRequestMode mode, int port, string fileName) {
7. this.mode = mode;
8. this.port = port;
9. this.fileName = fileName;
10. }
11. public FileRequestMode Mode {
12. get { return mode; }
13. }
14. public int Port {
15. get { return port; }
16. }
17. public string FileName {
18. get { return fileName; }
19. }
20. public override string ToString() {
21. return String.Format("<protocol><file name=\"{0}\" mode=\"{1}\" port=\"{2}\" /></protocol>", fileName, mode, port);
22. }
23. }

2.3 ProtocolHelper辅助类

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

1. public class ProtocolHelper {
2. private XmlNode fileNode;
3. private XmlNode root;
4. public ProtocolHelper(string protocol) {
5. XmlDocument doc = new XmlDocument();
6. doc.LoadXml(protocol);
7. root = doc.DocumentElement;
8. fileNode = root.SelectSingleNode("file");
9. }
10. // 此时的protocal一定为单条完整protocal
11. private FileRequestMode GetFileMode() {
12. string mode = fileNode.Attributes["mode"].Value;
13. mode = mode.ToLower();
14. if (mode == "send")
15. return FileRequestMode.Send;
16. else
17. return FileRequestMode.Receive;
18. }
19. // 获取单条协议包含的信息
20. public FileProtocol GetProtocol() {
21. FileRequestMode mode = GetFileMode();
22. string fileName = "";
23. int port = 0;
24. fileName = fileNode.Attributes["name"].Value;
25. port = Convert.ToInt32(fileNode.Attributes["port"].Value);
26. return new FileProtocol(mode, port, fileName);
27. }
28. }

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

3.客户端发送数据

3.1 服务端的实现

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

1. class Server {
2. static void Main(string[] args) {
3. Console.WriteLine("Server is running ... ");
4. IPAddress ip = IPAddress.Parse("127.0.0.1");
5. TcpListener listener = new TcpListener(ip, 8500);
6. listener.Start(); // 开启对控制端口 8500 的侦听
7. Console.WriteLine("Start Listening ...");
8. while (true) {
9. // 获取一个连接，同步方法，在此处中断
10. TcpClient client = listener.AcceptTcpClient();
11. RemoteClient wapper = new RemoteClient(client);
12. wapper.BeginRead();
13. }
14. }
15. }
16. public class RemoteClient {
17. private TcpClient client;
18. private NetworkStream streamToClient;
19. private const int BufferSize = 8192;
20. private byte[] buffer;
21. private ProtocolHandler handler;
22. public RemoteClient(TcpClient client) {
23. this.client = client;
24. // 打印连接到的客户端信息
25. Console.WriteLine("\nClient Connected！{0} <-- {1}",
26. client.Client.LocalEndPoint, client.Client.RemoteEndPoint);
27. // 获得流
28. streamToClient = client.GetStream();
29. buffer = new byte[BufferSize];
30. handler = new ProtocolHandler();
31. }
32. // 开始进行读取
33. public void BeginRead() {
34. AsyncCallback callBack = new AsyncCallback(OnReadComplete);
35. streamToClient.BeginRead(buffer, 0, BufferSize, callBack, null);
36. }
37. // 再读取完成时进行回调
38. private void OnReadComplete(IAsyncResult ar) {
39. int bytesRead = 0;
40. try {
41. lock (streamToClient) {
42. bytesRead = streamToClient.EndRead(ar);
43. Console.WriteLine("Reading data, {0} bytes ...", bytesRead);
44. }
45. if (bytesRead == 0) throw new Exception("读取到0字节");
46. string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
47. Array.Clear(buffer,0,buffer.Length); // 清空缓存，避免脏读
48. // 获取protocol数组
49. string[] protocolArray = handler.GetProtocol(msg);
50. foreach (string pro in protocolArray) {
51. // 这里异步调用，不然这里可能会比较耗时
52. ParameterizedThreadStart start =
53. new ParameterizedThreadStart(handleProtocol);
54. start.BeginInvoke(pro, null, null);
55. }
56. // 再次调用BeginRead()，完成时调用自身，形成无限循环
57. lock (streamToClient) {
58. AsyncCallback callBack = new AsyncCallback(OnReadComplete);
59. streamToClient.BeginRead(buffer, 0, BufferSize, callBack, null);
60. }
61. } catch(Exception ex) {
62. if(streamToClient!=null)
63. streamToClient.Dispose();
64. client.Close();
65. Console.WriteLine(ex.Message); // 捕获异常时退出程序
66. }
67. }
68. // 处理protocol
69. private void handleProtocol(object obj) {
70. string pro = obj as string;
71. ProtocolHelper helper = new ProtocolHelper(pro);
72. FileProtocol protocol = helper.GetProtocol();
73. if (protocol.Mode == FileRequestMode.Send) {
74. // 客户端发送文件，对服务端来说则是接收文件
75. receiveFile(protocol);
76. } else if (protocol.Mode == FileRequestMode.Receive) {
77. // 客户端接收文件，对服务端来说则是发送文件
78. // sendFile(protocol);
79. }
80. }
81. private void receiveFile(FileProtocol protocol) {
82. // 获取远程客户端的位置
83. IPEndPoint endpoint = client.Client.RemoteEndPoint as IPEndPoint;
84. IPAddress ip = endpoint.Address;
85. // 使用新端口号，获得远程用于接收文件的端口
86. endpoint = new IPEndPoint(ip, protocol.Port);
87. // 连接到远程客户端
88. TcpClient localClient;
89. try {
90. localClient = new TcpClient();
91. localClient.Connect(endpoint);
92. } catch {
93. Console.WriteLine("无法连接到客户端 --> {0}", endpoint);
94. return;
95. }
96. // 获取发送文件的流
97. NetworkStream streamToClient = localClient.GetStream();
98. // 随机生成一个在当前目录下的文件名称
99. string path =
100. Environment.CurrentDirectory + "/" + generateFileName(protocol.FileName);
101. byte[] fileBuffer = new byte[1024]; // 每次收1KB
102. FileStream fs = new FileStream(path, FileMode.CreateNew, FileAccess.Write);
103. // 从缓存buffer中读入到文件流中
104. int bytesRead;
105. int totalBytes = 0;
106. do {
107. bytesRead = streamToClient.Read(buffer, 0, BufferSize);
108. fs.Write(buffer, 0, bytesRead);
109. totalBytes += bytesRead;
110. Console.WriteLine("Receiving {0} bytes ...", totalBytes);
111. } while (bytesRead > 0);
112. Console.WriteLine("Total {0} bytes received, Done!", totalBytes);
113. streamToClient.Dispose();
114. fs.Dispose();
115. localClient.Close();
116. }
117. // 随机获取一个图片名称
118. private string generateFileName(string fileName) {
119. DateTime now = DateTime.Now;
120. return String.Format(
121. "{0}_{1}_{2}_{3}", now.Minute, now.Second, now.Millisecond, fileName
122. );
123. }
124. }

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

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

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

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

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

3.2客户端的实现

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

1. class Client {
2. static void Main(string[] args) {
3. ConsoleKey key;
4. ServerClient client = new ServerClient();
5. string filePath = Environment.CurrentDirectory + "/" + "Client01.jpg";
6. if(File.Exists(filePath))
7. client.BeginSendFile(filePath);
8. Console.WriteLine("\n\n输入\"Q\"键退出。");
9. do {
10. key = Console.ReadKey(true).Key;
11. } while (key != ConsoleKey.Q);
12. }
13. }
14. public class ServerClient {
15. private const int BufferSize = 8192;
16. private byte[] buffer;
17. private TcpClient client;
18. private NetworkStream streamToServer;
19. public ServerClient() {
20. try {
21. client = new TcpClient();
22. client.Connect("localhost", 8500); // 与服务器连接
23. } catch (Exception ex) {
24. Console.WriteLine(ex.Message);
25. return;
26. }
27. buffer = new byte[BufferSize];
28. // 打印连接到的服务端信息
29. Console.WriteLine("Server Connected！{0} --> {1}",
30. client.Client.LocalEndPoint, client.Client.RemoteEndPoint);
31. streamToServer = client.GetStream();
32. }
33. // 发送消息到服务端
34. public void SendMessage(string msg) {
35. byte[] temp = Encoding.Unicode.GetBytes(msg); // 获得缓存
36. try {
37. lock (streamToServer) {
38. streamToServer.Write(temp, 0, temp.Length); // 发往服务器
39. }
40. Console.WriteLine("Sent: {0}", msg);
41. } catch (Exception ex) {
42. Console.WriteLine(ex.Message);
43. return;
44. }
45. }
46. // 发送文件 - 异步方法
47. public void BeginSendFile(string filePath) {
48. ParameterizedThreadStart start =
49. new ParameterizedThreadStart(BeginSendFile);
50. start.BeginInvoke(filePath, null, null);
51. }
52. private void BeginSendFile(object obj) {
53. string filePath = obj as string;
54. SendFile(filePath);
55. }
56. // 发送文件 -- 同步方法
57. public void SendFile(string filePath) {
58. IPAddress ip = IPAddress.Parse("127.0.0.1");
59. TcpListener listener = new TcpListener(ip, 0);
60. listener.Start();
61. // 获取本地侦听的端口号
62. IPEndPoint endPoint = listener.LocalEndpoint as IPEndPoint;
63. int listeningPort = endPoint.Port;
64. // 获取发送的协议字符串
65. string fileName = Path.GetFileName(filePath);
66. FileProtocol protocol =
67. new FileProtocol(FileRequestMode.Send, listeningPort, fileName);
68. string pro = protocol.ToString();
69. SendMessage(pro); // 发送协议到服务端
70. // 中断，等待远程连接
71. TcpClient localClient = listener.AcceptTcpClient();
72. Console.WriteLine("Start sending file...");
73. NetworkStream stream = localClient.GetStream();
74. // 创建文件流
75. FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
76. byte[] fileBuffer = new byte[1024]; // 每次传1KB
77. int bytesRead;
78. int totalBytes = 0;
79. // 创建获取文件发送状态的类
80. SendStatus status = new SendStatus(filePath);
81. // 将文件流转写入网络流
82. try {
83. do {
84. Thread.Sleep(10); // 为了更好的视觉效果，暂停10毫秒:-)
85. bytesRead = fs.Read(fileBuffer, 0, fileBuffer.Length);
86. stream.Write(fileBuffer, 0, bytesRead);
87. totalBytes += bytesRead; // 发送了的字节数
88. status.PrintStatus(totalBytes); // 打印发送状态
89. } while (bytesRead > 0);
90. Console.WriteLine("Total {0} bytes sent, Done!", totalBytes);
91. } catch {
92. Console.WriteLine("Server has lost...");
93. }
94. stream.Dispose();
95. fs.Dispose();
96. localClient.Close();
97. listener.Stop();
98. }
99. }

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

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

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

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

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

下面是SendStatus的内容：

1. // 即时计算发送文件的状态
2. public class SendStatus {
3. private FileInfo info;
4. private long fileBytes;
5. public SendStatus(string filePath) {
6. info = new FileInfo(filePath);
7. fileBytes = info.Length;
8. }
9. public void PrintStatus(int sent) {
10. string percent = GetPercent(sent);
11. Console.WriteLine("Sending {0} bytes, {1}% ...", sent, percent);
12. }
13. // 获得文件发送的百分比
14. public string GetPercent(int sent){
15. decimal allBytes = Convert.ToDecimal(fileBytes);
16. decimal currentSent = Convert.ToDecimal(sent);
17. decimal percent = (currentSent / allBytes) * 100;
18. percent = Math.Round(percent, 1); //保留一位小数
19. if (percent.ToString() == "100.0")
20. return "100";
21. else
22. return percent.ToString();
23. }
24. }

3.3程序测试

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

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

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

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

posted @ 2010-07-24 13:29 大漠银狐 阅读(44) | 评论(0) | 编辑

C#网络编程:3异步传输字符串

posted @ 2010-07-24 13:28 大漠银狐 阅读(183) | 评论(0) | 编辑

c#网络编程，如何异步监听指定的端口！并响应客户端

using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Collections;
using System;
using System.Collections.Generic;
namespace SocketLibrary
{
public delegate void BufferNotifyEventHandler(byte[] CaptureData,EndPoint FromIP);
/// <summary>
/// ----名称:UDP通讯类
/// ----建立:niefei
/// ----建立时间:2004-12-6
/// </summary>
/// <remarks>
/// ----使用说明与定义:
/// ----接到字符串 "NeedDownCards" 表示需要调用卡下载功能
/// </remarks>
public class UDPSocket
{
public class ClientEndPoint
{
public ClientEndPoint() { }
public ClientEndPoint(int cID, string remoteIP, int remotePort)
{
CID = cID;
RemoteIP = remoteIP;
RemotePort = remotePort;
}
public int CID;
public string RemoteIP = "192.168.0.255";
public int RemotePort = 9999;
}

public UDPPackage.UdpData PulseData;
#region 内部变量区
private IPEndPoint m_SendToIpEndPoint = null;
/// <summary>
/// 为了不让定义的事件在没有附加接收函数时出错，需要先加载一个空函数
/// </summary>
/// <param name="Msg"></param>
protected void EmptyFunction(string Msg) { }
protected ArrayList m_computers;
/// <summary>
/// 发送命令文本常量
/// </summary>
protected string m_sendText;
/// <summary>
/// 默认发送的字符串
/// </summary>
protected const string m_sendStr = "Hello!Server Is Running!";
/// <summary>
/// Udp对象
/// </summary>
protected UdpClient m_Client;
/// <summary>
/// 本地通讯端口(默认8888)
/// </summary>
protected int m_LocalPort;
/// <summary>
/// 本一IP(默认127.0.0.1)
/// </summary>
protected string m_LocalIP;
/// <summary>
/// 对方IP
/// </summary>
protected string m_SendToIP ="192.168.0.255";
/// <summary>
/// 远程通讯端口(默认8000)
/// </summary>
protected int m_RemotePort=9999;
/// <summary>
/// 当有多台客户机需要与服务器通讯时，这里记录了所有客户机的信息
/// </summary>
protected List<ClientEndPoint> m_ClientList = new List<ClientEndPoint>();
/// <summary>
/// 跟踪是否退出程序
/// </summary>
protected bool m_Done;
/// <summary>
/// 设置是否要发送
/// </summary>
protected bool m_flag;
#endregion

#region 属性区
/// <summary>
/// 定义委托
/// </summary>
public delegate void SOCKETDelegateArrive(string sReceived);
/// <summary>
/// 定义一个消息接收事件
/// </summary>
public SOCKETDelegateArrive SOCKETEventArrive;
/// <summary>
/// 定义一个接受线程
/// </summary>
public Thread recvThread;
/// <summary>
/// 定义一个检测发送线程
/// </summary>
public Thread checkSendThread;
/// <summary>
/// 下载标志
/// </summary>
public bool flag
{
set { this.m_flag = value; }
get { return this.m_flag; }
}
/// <summary>
/// 设置通讯端口
/// </summary>
public int LocalPort
{
set { m_LocalPort = value; }
get { return m_LocalPort; }
}
/// <summary>
/// 设置本地IP
/// </summary>
public string LocalIP
{
set { m_LocalIP = value; }
get{return m_LocalIP;}
}
/// <summary>
/// 设置对方IP地址 ,m_SendToIP
/// </summary>
public string RemoteIP
{
set
{
m_SendToIP = value;
m_SendToIpEndPoint =
new IPEndPoint(IPAddress.Parse(this.m_SendToIP), m_RemotePort);
}
get { return m_SendToIP; }
}
/// <summary>
/// 远程通讯端口
/// </summary>
public int RemotePort
{
set
{
m_RemotePort = value;
m_SendToIpEndPoint =
new IPEndPoint(IPAddress.Parse(this.m_SendToIP), m_RemotePort);
}
get { return m_RemotePort; }
}
/// <summary>
/// 设置多个远程接收端
/// </summary>
public List<ClientEndPoint> ClientList
{
get { return m_ClientList; }
set { m_ClientList = value; }
}
/// <summary>
/// 设置要发送的岗位对象
/// </summary>
public ArrayList computers
{
set { this.m_computers = value; }
get { return this.m_computers; }
}

/// <summary>
/// 收发开关，false为正常工作，true为关闭收发
/// </summary>
public bool Done
{
set { m_Done = value; }
get { return m_Done; }
}
#endregion
/// <summary>
/// 构造函数设置各项默认值
/// </summary>
public UDPSocket()
{
m_sendText = string.Empty;
m_computers = new ArrayList();
m_Done = false;
m_flag = false;
}
/// <summary>
/// 初始化
/// </summary>
public void Init()
{
//初始化UDP对象
try
{
//Dispose();
//SOCKETEventArrive += this.EmptyFunction;
if (m_LocalIP != null && m_LocalIP != "")
{
m_Client = new UdpClient(new IPEndPoint(IPAddress.Parse(m_LocalIP), m_LocalPort)); ;
}
else
{
m_Client = new UdpClient(m_LocalPort);
}

//m_Client = new UdpClient(m_LocalPort);
//SOCKETEventArrive("Initialize succeed by " + m_LocalPort.ToString() + " port");
}
catch
{
//SOCKETEventArrive("Initialize failed by " + m_LocalPort.ToString() + " port");
}
}
/// <summary>
/// 析构函数
/// </summary>
~UDPSocket() { Dispose(); }
/// <summary>
/// 关闭对象
/// </summary>
public void Dispose()
{
DisConnection();
m_computers = null;
}

/// <summary>
/// 关闭UDP对象
/// </summary>
public void DisConnection()
{
try
{
if (m_Client != null)
{
this.Done = true;
if (recvThread != null)
{
this.recvThread.Abort();
}
if (checkSendThread != null)
{
this.checkSendThread.Abort();
}
if (recvThread != null)
{
this.recvThread.Abort();
}
if (checkSendThread != null)
{
this.checkSendThread.Abort();
}
m_Client.Close();
m_Client = null;

}
}
catch
{
this.Done = true;
m_Client.Close();
m_Client = null;
}
finally
{
this.Done = true;
if (m_Client != null)
{
m_Client.Close();
m_Client = null;
}

}
}

#region 接收区
public event BufferNotifyEventHandler BufferNotify;
/// <summary>
/// 侦听线程
/// </summary>
public void StartRecvThreadListener()
{
try
{
// 启动等待连接的线程
recvThread = new Thread(new ThreadStart(Received));
recvThread.Priority = ThreadPriority.Normal;
recvThread.IsBackground = false;
recvThread.Start();
//SOCKETEventArrive("[Received]Thread Start....");
}
catch(Exception exp)
{
//SOCKETEventArrive("[Received]Thread Start failed!"+exp.Message);
}
}
/// <summary>
/// 循环接收，收到数据引发BufferNotifyEventHandler事件
/// </summary>
private void Received()
{
while (!m_Done)
{
//接收数据
try
{
IPEndPoint endpoint = null;
if (m_Client != null && recvThread.IsAlive)
{

m_Client.Client.Blocking = true;
Byte[] CaptureData = m_Client.Receive(ref endpoint);
BufferNotify(CaptureData, m_Client.Client.LocalEndPoint);

}
else if (!recvThread.IsAlive)
{
recvThread.Resume();
}
if (this.checkSendThread != null) //顺便检查发送线程是否工作正常
{
if (this.checkSendThread.ThreadState == ThreadState.Aborted
|| this.checkSendThread.ThreadState == ThreadState.Stopped)
{
checkSendThread.Abort();
checkSendThread = null;
checkSendThread = new Thread(new ThreadStart(ChekSendListener));
checkSendThread.IsBackground = false;
checkSendThread.Start();
}
}
}
catch (Exception exp)
{
//SOCKETEventArrive("ReceiveData:CaptureData. Nullerror"+exp.Message);
}
finally { }
Thread.Sleep(10); //防止系统资源耗尽
}
}
#endregion

#region 发送区
public Queue<byte[]> CaptureDataQueue = new Queue<byte[]>();
/// <summary>
/// 用于接收音频数据的入口
/// </summary>
/// <param name="CaptureData"></param>
public int ReceiveSound(byte[] CaptureData)
{
if (!m_Done)
{
CaptureDataQueue.Enqueue(CaptureData);
}
return CaptureData.Length;
}
/// <summary>
/// 启动检测发送侦听线程
/// </summary>
public void StartCheckSendListenerThread()
{
try
{
checkSendThread = new Thread(new ThreadStart(ChekSendListener));
checkSendThread.Priority = ThreadPriority.Normal;
checkSendThread.IsBackground = false;
checkSendThread.Start();

//SOCKETEventArrive("[ChekSendListener]Thread Start...");
}
catch
{
//SOCKETEventArrive("[ChekSendListener]Thread Start failed!");
}
}
/// <summary>
/// 如果当前发送队列中有数据，就启动发送
/// </summary>
private void ChekSendListener()
{
CaptureDataQueue.Clear();
while (!m_Done)
{
try
{
if (CaptureDataQueue.Count > 0)
{
this.sendData(CaptureDataQueue.Dequeue());
}
if (this.recvThread != null)
{
if (this.recvThread.ThreadState == ThreadState.Aborted
|| this.recvThread.ThreadState == ThreadState.Stopped)
{
recvThread.Abort();
recvThread = null;
recvThread = new Thread(new ThreadStart(Received));
recvThread.IsBackground = false;
recvThread.Start();
}
}
}
catch { }
finally { }
Thread.Sleep(1); //防止系统资源耗尽
}
}

#region 二进制发送区
/// <summary>
/// 发送字节流数据
/// </summary>
/// <param name="CaptureData"></param>
public void sendData(byte[] CaptureData/*UDPPackage.UDPData UdpData*/)
{
try
{
if (m_Client == null)
{
m_Client = new UdpClient(new IPEndPoint(IPAddress.Parse(m_LocalIP), m_LocalPort));
}
//m_Client.Connect(this.m_SendToIP, m_RemotePort);
//byte[] bytReceivedData = UdpData.ToByte();// new byte[CaptureData.Length];
//System.Buffer.BlockCopy(CaptureData, 0, bytReceivedData, 0, CaptureData.Length);
// 连接后传送一个消息给ip主机
//m_Client.Send(bytReceivedData, bytReceivedData.Length);
if (0 != this.m_ClientList.Count)
{
for (int i = 0; i < this.m_ClientList.Count; i++)
{
int m = m_Client.Send(CaptureData, CaptureData.Length,
new IPEndPoint(IPAddress.Parse(this.m_ClientList[i].RemoteIP), this.m_ClientList[i].RemotePort));
}
}
else
{
int i = m_Client.Send(CaptureData, CaptureData.Length, m_SendToIpEndPoint);
}

}
catch
{

}
finally
{
//m_Client.Close();
//m_Client = null;
}
}
#endregion
#endregion

#region 周期信号区
Thread PualseThread;
/// <summary>
/// 向服务器发送脉冲信号
/// </summary>
public void sendPulseSignal()
{
try
{
PualseThread = new Thread(new ThreadStart(PulseSingnal));
PualseThread.Priority = ThreadPriority.Normal;
PualseThread.Start();

//SOCKETEventArrive("[PulseSignal]Thread Start...");
}
catch
{
//SOCKETEventArrive("[PulseSignal]Thread Start failed!");
}
}
private void PulseSingnal()
{
while (true)
{
if (this.PulseData.EXP == 1)
{
this.sendData(UDPPackage.StructToBytes(this.PulseData));
}

Thread.Sleep(5000); //每五秒钟一次脉冲
}
}
#endregion

}
}

posted @ 2010-07-24 13:25 大漠银狐 阅读(284) | 评论(0) | 编辑

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 {
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个字节。

posted @ 2010-07-24 13:21 大漠银狐 阅读(32) | 评论(0) | 编辑

C#网络编程(基本概念和操作) - Part.1

引言

C#网络编程系列文章计划简单地讲述网络编程方面的基础知识，由于本人在这方面功力有限，所以只能提供一些初步的入门知识，希望能对刚开始学习的朋友提供一些帮助。如果想要更加深入的内容，可以参考相关书籍。

本文是该系列第一篇，主要讲述了基于套接字（Socket）进行网络编程的基本概念，其中包括TCP协议、套接字、聊天程序的三种开发模式，以及两个基本操作：侦听端口、连接远程服务端；第二篇讲述了一个简单的范例：从客户端传输字符串到服务端，服务端接收并打印字符串，将字符串改为大写，然后再将字符串回发到客户端，客户端最后打印传回的字符串；第三篇是第二篇的一个强化，讲述了第二篇中没有解决的一个问题，并使用了异步传输的方式来完成和第二篇同样的功能；第四篇则演示了如何在客户端与服务端之间收发文件；第五篇实现了一个能够在线聊天并进行文件传输的聊天程序，实际上是对前面知识的一个综合应用。

与本文相关的还有一篇文章是：C#编写简单的聊天程序，但这个聊天程序不及本系列中的聊天程序功能强大，实现方式也不相同。

网络编程基本概念

1.面向连接的传输协议：TCP

对于TCP协议我不想说太多东西，这属于大学课程，又涉及计算机科学，而我不是“学院派”，对于这部分内容，我觉得作为开发人员，只需要掌握与程序相关的概念就可以了，不需要做太艰深的研究。

我们首先知道TCP是面向连接的，它的意思是说两个远程主机（或者叫进程，因为实际上远程通信是进程之间的通信，而进程则是运行中的程序），必须首先进行一个握手过程，确认连接成功，之后才能传输实际的数据。比如说进程A想将字符串“It's a fine day today”发给进程B，它首先要建立连接。在这一过程中，它首先需要知道进程B的位置（主机地址和端口号）。随后发送一个不包含实际数据的请求报文，我们可以将这个报文称之为“hello”。如果进程B接收到了这个“hello”，就向进程A回复一个“hello”，进程A随后才发送实际的数据“It's a fine day today”。

关于TCP第二个需要了解的，就是它是全双工的。意思是说如果两个主机上的进程（比如进程A、进程B），一旦建立好连接，那么数据就既可以由A流向B，也可以由B流向A。除此以外，它还是点对点的，意思是说一个TCP连接总是两者之间的，在发送中，通过一个连接将数据发给多个接收方是不可能的。TCP还有一个特性，就是称为可靠的数据传输，意思是连接建立后，数据的发送一定能够到达，并且是有序的，就是说发的时候你发了ABC，那么收的一方收到的也一定是ABC，而不会是BCA或者别的什么。

编程中与TCP相关的最重要的一个概念就是套接字。我们应该知道网络七层协议，如果我们将上面的应用程、表示层、会话层笼统地算作一层（有的教材便是如此划分的），那么我们编写的网络应用程序就位于应用层，而大家知道TCP是属于传输层的协议，那么我们在应用层如何使用传输层的服务呢（消息发送或者文件上传下载）？大家知道在应用程序中我们用接口来分离实现，在应用层和传输层之间，则是使用套接字来进行分离。它就像是传输层为应用层开的一个小口，应用程序通过这个小口向远程发送数据，或者接收远程发来的数据；而这个小口以内，也就是数据进入这个口之后，或者数据从这个口出来之前，我们是不知道也不需要知道的，我们也不会关心它如何传输，这属于网络其它层次的工作。

举个例子，如果你想写封邮件发给远方的朋友，那么你如何写信、将信打包，属于应用层，信怎么写，怎么打包完全由我们做主；而当我们将信投入邮筒时，邮筒的那个口就是套接字，在进入套接字之后，就是传输层、网络层等（邮局、公路交管或者航线等）其它层次的工作了。我们从来不会去关心信是如何从西安发往北京的，我们只知道写好了投入邮筒就OK了。可以用下面这两幅图来表示它：

注意在上面图中，两个主机是对等的，但是按照约定，我们将发起请求的一方称为客户端，将另一端称为服务端。可以看出两个程序之间的对话是通过套接字这个出入口来完成的，实际上套接字包含的最重要的也就是两个信息：连接至远程的本地的端口信息(本机地址和端口号)，连接到的远程的端口信息(远程地址和端口号)。注意上面词语的微妙变化，一个是本地地址，一个是远程地址。

这里又出现了了一个名词端口。一般来说我们的计算机上运行着非常多的应用程序，它们可能都需要同远程主机打交道，所以远程主机就需要有一个ID来标识它想与本地机器上的哪个应用程序打交道，这里的ID就是端口。将端口分配给一个应用程序，那么来自这个端口的数据则总是针对这个应用程序的。有这样一个很好的例子：可以将主机地址想象为电话号码，而将端口号想象为分机号。

在.NET中，尽管我们可以直接对套接字编程，但是.NET提供了两个类将对套接字的编程进行了一个封装，使我们的使用能够更加方便，这两个类是TcpClient和TcpListener，它与套接字的关系如下：

从上面图中可以看出TcpClient和TcpListener对套接字进行了封装。从中也可以看出，TcpListener位于接收流的位置，TcpClient位于输出流的位置（实际上TcpListener在收到一个请求后，就创建了TcpClient，而它本身则持续处于侦听状态，收发数据都可以由TcpClient完成。这个图有点不够准确，而我暂时没有想到更好的画法，后面看到代码时会更加清楚一些）。

我们考虑这样一种情况：两台主机，主机A和主机B，起初它们谁也不知道谁在哪儿，当它们想要进行对话时，总是需要有一方发起连接，而另一方则需要对本机的某一端口进行侦听。而在侦听方收到连接请求、并建立起连接以后，它们之间进行收发数据时，发起连接的一方并不需要再进行侦听。因为连接是全双工的，它可以使用现有的连接进行收发数据。而我们前面已经做了定义：将发起连接的一方称为客户端，另一段称为服务端，则现在可以得出：总是服务端在使用TcpListener类，因为它需要建立起一个初始的连接。

2.网络聊天程序的三种模式

实现一个网络聊天程序本应是最后一篇文章的内容，也是本系列最后的一个程序，来作为一个终结。但是我想后面更多的是编码，讲述的内容应该不会太多，所以还是把讲述的东西都放到这里吧。

当采用这种模式时，即是所谓的完全点对点模式，此时每台计算机本身也是服务器，因为它需要进行端口的侦听。实现这个模式的难点是：各个主机（或终端）之间如何知道其它主机的存在？此时通常的做法是当某一主机上线时，使用UDP协议进行一个广播（Broadcast），通过这种方式来“告知”其它主机自己已经在线并说明位置，收到广播的主机发回一个应答，此时主机便知道其他主机的存在。这种方式我个人并不喜欢，但在C#编写简单的聊天程序 这篇文章中，我使用了这种模式，可惜的是我没有实现广播，所以还很不完善。

第二种方式较好的解决了上面的问题，它引入了服务器，由这个服务器来专门进行广播。服务器持续保持对端口的侦听状态，每当有主机上线时，首先连接至服务器，服务器收到连接后，将该主机的位置（地址和端口号）发往其他在线主机（绿色箭头标识）。这样其他主机便知道该主机已上线，并知道其所在位置，从而可以进行连接和对话。在服务器进行了广播之后，因为各个主机已经知道了其他主机的位置，因此主机之间的对话就不再通过服务器（黑色箭头表示），而是直接进行连接。因此，使用这种模式时，各个主机依然需要保持对端口的侦听。在某台主机离线时，与登录时的模式类似，服务器会收到通知，然后转告给其他的主机。

第三种模式是我觉得最简单也最实用的一种，主机的登录与离线与第二种模式相同。注意到每台主机在上线时首先就与服务器建立了连接，那么从主机A发往主机B发送消息，就可以通过这样一条路径，主机A --> 服务器 --> 主机B，通过这种方式，各个主机不需要在对端口进行侦听，而只需要服务器进行侦听就可以了，大大地简化了开发。

而对于一些较大的文件，比如说图片或者文件，如果想由主机A发往主机B，如果通过服务器进行传输效率会比较低，此时可以临时搭建一个主机A至主机B之间的连接，用于传输大文件。当文件传输结束之后再关闭连接（桔红色箭头标识）。

除此以外，由于消息都经过服务器，所以服务器还可以缓存主机间的对话，即是说当主机A发往主机B时，如果主机B已经离线，则服务器可以对消息进行缓存，当主机B下次连接到服务器时，服务器自动将缓存的消息发给主机B。

本系列文章最后采用的即是此种模式，不过没有实现过多复杂的功能。接下来我们的理论知识告一段落，开始下一阶段――漫长的编码。

基本操作

1.服务端对端口进行侦听

接下来我们开始编写一些实际的代码，第一步就是开启对本地机器上某一端口的侦听。首先创建一个控制台应用程序，将项目名称命名为ServerConsole，它代表我们的服务端。如果想要与外界进行通信，第一件要做的事情就是开启对端口的侦听，这就像为计算机打开了一个“门”，所有向这个“门”发送的请求（“敲门”）都会被系统接收到。在C#中可以通过下面几个步骤完成，首先使用本机Ip地址和端口号创建一个System.Net.Sockets.TcpListener类型的实例，然后在该实例上调用Start()方法，从而开启对指定端口的侦听。

using System.Net; // 引入这两个命名空间，以下同
using System.Net.Sockets;
using ... // 略
class Server {
static void Main(string[] args) {
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 ...");
Console.WriteLine("\n\n输入\"Q\"键退出。");
ConsoleKey key;
do {
key = Console.ReadKey(true).Key;
} while (key != ConsoleKey.Q);
}
}
// 获得IPAddress对象的另外几种常用方法：
IPAddress ip = IPAddress.Parse("127.0.0.1");
IPAddress ip = Dns.GetHostEntry("localhost").AddressList[0];

上面的代码中，我们开启了对8500端口的侦听。在运行了上面的程序之后，然后打开“命令提示符”，输入“netstat-a”，可以看到计算机器中所有打开的端口的状态。可以从中找到8500端口，看到它的状态是LISTENING，这说明它已经开始了侦听：

TCP jimmy:1030 0.0.0.0:0 LISTENING
TCP jimmy:3603 0.0.0.0:0 LISTENING
TCP jimmy:8500 0.0.0.0:0 LISTENING
TCP jimmy:netbios-ssn 0.0.0.0:0 LISTENING

在打开了对端口的侦听以后，服务端必须通过某种方式进行阻塞（比如Console.ReadKey()），使得程序不能够因为运行结束而退出。否则就无法使用“netstat -a”看到端口的连接状态，因为程序已经退出，连接会自然中断，再运行“netstat -a”当然就不会显示端口了。所以程序最后按“Q”退出那段代码是必要的，下面的每段程序都会含有这个代码段，但为了节省空间，我都省略掉了。

2.客户端与服务端连接

2.1单一客户端与服务端连接

当服务器开始对端口侦听之后，便可以创建客户端与它建立连接。这一步是通过在客户端创建一个TcpClient的类型实例完成。每创建一个新的TcpClient便相当于创建了一个新的套接字Socket去与服务端通信，.Net会自动为这个套接字分配一个端口号，上面说过，TcpClient类不过是对Socket进行了一个包装。创建TcpClient类型实例时，可以在构造函数中指定远程服务器的地址和端口号。这样在创建的同时，就会向远程服务端发送一个连接请求（“握手”），一旦成功，则两者间的连接就建立起来了。也可以使用重载的无参数构造函数创建对象，然后再调用Connect()方法，在Connect()方法中传入远程服务器地址和端口号，来与服务器建立连接。

这里需要注意的是，不管是使用有参数的构造函数与服务器连接，或者是通过Connect()方法与服务器建立连接，都是同步方法（或者说是阻塞的，英文叫block）。它的意思是说，客户端在与服务端连接成功、从而方法返回，或者是服务端不存、从而抛出异常之前，是无法继续进行后继操作的。这里还有一个名为BeginConnect()的方法，用于实施异步的连接，这样程序不会被阻塞，可以立即执行后面的操作，这是因为可能由于网络拥塞等问题，连接需要较长时间才能完成。网络编程中有非常多的异步操作，凡事都是由简入难，关于异步操作，我们后面再讨论，现在只看同步操作。

创建一个新的控制台应用程序项目，命名为ClientConsole，它是我们的客户端，然后添加下面的代码，创建与服务器的连接：

class Client {
static void Main(string[] args) {
Console.WriteLine("Client Running ...");
TcpClient client = new TcpClient();
try {
client.Connect("localhost", 8500); // 与服务器连接
} catch (Exception ex) {
Console.WriteLine(ex.Message);
return;
}
// 打印连接到的服务端信息
Console.WriteLine("Server Connected！{0} --> {1}",
client.Client.LocalEndPoint, client.Client.RemoteEndPoint);
// 按Q退出
}
}

上面带代码中，我们通过调用Connect()方法来与服务端连接。随后，我们打印了这个连接消息：本机的Ip地址和端口号，以及连接到的远程Ip地址和端口号。TcpClient的Client属性返回了一个Socket对象，它的LocalEndPoint和RemoteEndPoint属性分别包含了本地和远程的地址信息。先运行服务端，再运行这段代码。可以看到两边的输出情况如下：

// 服务端：
Server is running ...
Start Listening ...
// 客户端：
Client Running ...
Server Connected！127.0.0.1:4761 --> 127.0.0.1:8500

我们看到客户端使用的端口号为4761，上面已经说过，这个端口号是由.NET随机选取的，并不需要我们来设置，并且每次运行时，这个端口号都不同。再次打开“命令提示符”，输入“netstat -a”，可以看到下面的输出：

TCP jimmy:8500 0.0.0.0:0 LISTENING
TCP jimmy:8500 localhost:4761 ESTABLISHED
TCP jimmy:4761 localhost:8500 ESTABLISHED

从这里我们可以得出几个重要信息：1、端口8500和端口4761建立了连接，这个4761端口便是客户端用来与服务端进行通信的端口；2、8500端口在与客户端建立起一个连接后，仍然继续保持在监听状态。这也就是说一个端口可以与多个远程端口建立通信，这是显然的，大家众所周之的HTTP使用的默认端口为80，但是一个Web服务器要通过这个端口与多少个浏览器通信啊。

2.2多个客户端与服务端连接

那么既然一个服务器端口可以应对多个客户端连接，那么接下来我们就看一下，如何让多个客户端与服务端连接。如同我们上面所说的，一个TcpClient就是一个Socket，所以我们只要创建多个TcpClient，然后再调用Connect()方法就可以了：

class Client {
static void Main(string[] args) {
Console.WriteLine("Client Running ...");
TcpClient client;
for (int i = 0; i <= 2; i++) {
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);
}
// 按Q退出
}
}

上面代码最重要的就是client = new TcpClient()这句，如果你将这个声明放到循环外面，再循环的第二趟就会发生异常，原因很显然：一个TcpClient对象对应一个Socket，一个Socket对应着一个端口，如果不使用new操作符重新创建对象，那么就相当于使用一个已经与服务端建立了连接的端口再次与远程建立连接。

此时，如果在“命令提示符”运行“netstat -a”，则会看到类似下面的的输出：

TCP jimmy:8500 0.0.0.0:0 LISTENING
TCP jimmy:8500 localhost:10282 ESTABLISHED
TCP jimmy:8500 localhost:10283 ESTABLISHED
TCP jimmy:8500 localhost:10284 ESTABLISHED
TCP jimmy:10282 localhost:8500 ESTABLISHED
TCP jimmy:10283 localhost:8500 ESTABLISHED
TCP jimmy:10284 localhost:8500 ESTABLISHED

可以看到创建了三个连接对，并且8500端口持续保持侦听状态，从这里以及上面我们可以推断出TcpListener的Start()方法是一个异步方法。

3.服务端获取客户端连接

3.1获取单一客户端连接

上面服务端、客户端的代码已经建立起了连接，这通过使用“netstat -a”命令，从端口的状态可以看出来，但这是操作系统告诉我们的。那么我们现在需要知道的就是：服务端的程序如何知道已经与一个客户端建立起了连接？

服务器端开始侦听以后，可以在TcpListener实例上调用AcceptTcpClient()来获取与一个客户端的连接，它返回一个TcpClient类型实例。此时它所包装的是由服务端去往客户端的Socket，而我们在客户端创建的TcpClient则是由客户端去往服务端的。这个方法是一个同步方法（或者叫阻断方法，block method），意思就是说，当程序调用它以后，它会一直等待某个客户端连接，然后才会返回，否则就会一直等下去。这样的话，在调用它以后，除非得到一个客户端连接，不然不会执行接下来的代码。一个很好的类比就是Console.ReadLine()方法，它读取输入在控制台中的一行字符串，如果有输入，就继续执行下面代码；如果没有输入，就会一直等待下去。

class Server {
static void Main(string[] args) {
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);
// 按Q退出
}
}

运行这段代码，会发现服务端运行到listener.AcceptTcpClient()时便停止了，并不会执行下面的Console.WriteLine()方法。为了让它继续执行下去，必须有一个客户端连接到它，所以我们现在运行客户端，与它进行连接。简单起见，我们只在客户端开启一个端口与之连接：

class Client {
static void Main(string[] args) {
Console.WriteLine("Client Running ...");
TcpClient client = new TcpClient();
try {
client.Connect("localhost", 8500); // 与服务器连接
} catch (Exception ex) {
Console.WriteLine(ex.Message);
return;
}
// 打印连接到的服务端信息
Console.WriteLine("Server Connected！{0} --> {1}",
client.Client.LocalEndPoint, client.Client.RemoteEndPoint);
// 按Q退出
}
}

此时，服务端、客户端的输出分别为：

// 服务端
Server is running ...
Start Listening ...
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:5188
// 客户端
Client Running ...
Server Connected！127.0.0.1:5188 --> 127.0.0.1:8500

3.2获取多个客户端连接

现在我们再接着考虑，如果有多个客户端发动对服务器端的连接会怎么样，为了避免你将浏览器向上滚动，来查看上面的代码，我将它拷贝了下来，我们先看下客户端的关键代码：

TcpClient client;
for (int i = 0; i <=2; i++) {
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);
}

如果服务端代码不变，我们先运行服务端，再运行客户端，那么接下来会看到这样的输出：

// 服务端
Server is running ...
Start Listening ...
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:5226
// 客户端
Client Running ...
Server Connected！127.0.0.1:5226 --> 127.0.0.1:8500
Server Connected！127.0.0.1:5227 --> 127.0.0.1:8500
Server Connected！127.0.0.1:5228 --> 127.0.0.1:8500

就又回到了本章第2.2小节“多个客户端与服务端连接”中的处境：尽管有三个客户端连接到了服务端，但是服务端程序只接收到了一个。这是因为服务端只调用了一次listener.AcceptTcpClient()，而它只对应一个连往客户端的Socket。但是操作系统是知道连接已经建立了的，只是我们程序中没有处理到，所以我们当我们输入“netstat -a”时，仍然会看到3对连接都已经建立成功。

为了能够接收到三个客户端的连接，我们只要对服务端稍稍进行一下修改，将AcceptTcpClient方法放入一个do/while循环中就可以了：

Console.WriteLine("Start Listening ...");
while (true) {
// 获取一个连接，同步方法
TcpClient remoteClient = listener.AcceptTcpClient();
// 打印连接到的客户端信息
Console.WriteLine("Client Connected！{0} <-- {1}",
remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);
}

这样看上去是一个死循环，但是并不会让你的机器系统资源迅速耗尽。因为前面已经说过了，AcceptTcpClient()再没有收到客户端的连接之前，是不会继续执行的，它的大部分时间都在等待。另外，服务端几乎总是要保持在运行状态，所以这样做并无不可，还可以省去“按Q退出”那段代码。此时再运行代码，会看到服务端可以收到3个客户端的连接了。

Server is running ...
Start Listening ...
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:5305
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:5306
Client Connected！127.0.0.1:8500 <-- 127.0.0.1:5307

本篇文章到此就结束了，接下来一篇我们来看看如何在服务端与客户端之间收发数据。

posted @ 2010-07-24 13:19 大漠银狐 阅读(45) | 评论(0) | 编辑

动态生成类、接口及其成员

1.永春博客里提供的将string动态编译类的方式(以下摘自其博客)

动态生成类
我们可以在程序运行过程中调用.NET中提供的编译类，动态的将一段string编译成一个类，然后再通过反射来调用它
需要使用的命名空间：

动态创建、编译类的代码如下：

代码

propertyString方法就是用来拼写字符串的
整个代码比较简单，主要步骤就是：1、拼写类的字符串 2、调用CSharpCodeProvider类进行编译得到程序集(assembly)
接下来就可以利用之前反射的方法来动态调用这个类中的属性了：

代码

DynamicClass是我动态类的类名，aaa和bbb是其中的属性
ReflectionSetProperty和ReflectionGetProperty代码如下：

给属性赋值

代码

取得属性的值

代码

2.使用Emit动态创建类，并添加实例成员，属性，方法等（以下内容摘自FrogTan的博客）

下面接着说说如何为动态创建的类添加实例成员，属性，方法等。

准备工作 这次来创建一个Student类。首先准备好大致框架：

代码

一、定义实例变量

Student包含以下实例成员：id(int),name(string)。下面就来一一创建它们。

创建实例成员要通过TypeBuilder的DefineField方法来完成。该方法有以下形式：

• DefineField(String, Type, FieldAttributes) :用给定的名称、属性和字段类型，向类型中添加新字段。
• DefineField(String, Type, Type[], Type[], FieldAttributes):用给定的名称、属性、字段类型和自定义修饰符，向类型中添加新字段。

一般情形下，前者使用的比较多。首先创建id:

接着是name:

这时您用reflector打开EmitStudy2.dll会发现Student已经拥有了我们想要的id,name,scores实例变量。

二、定义属性

Student类相应的也包含了三个简单属性：Id,Name。大家都知道，C#中的属性会被编译为相应的get_XXX或set_XXX的方法组。因此创建属性实质就是在创建方法。

创建方法通过TypeBuilder.DefineMethod完成。该方法重载形式较多，这里就不一一列出，感兴趣的请看这里。还是以Id为例，我们为之创建GetId和SetId方法:

代码

这段代码定义了两个方法：GetId和SetId,但是这两个方法还没有真正和属性关联起来。首先，我们需要创建属性Id:

（在这里要说明的一点是，在很多DefineXXX方法中都包含返回类型和参数类型这两个属性，如果无返回值或者无参数直接传递null就可以了）

创建了名称为Id的属性后，我们再将属性和get/set方法关联起来：

另外两个属性类似。在上面创建get/set方法时提到了几个新的OpCodes:

OpCodes.Ldarg_0:Ldarg是加载方法参数的意思。这里arg_0事实上是对当前对象的引用即this。因为类的实例方法（非静态方法）在调用时，this是会作为第一个参数传入的。

OpCodes.Ldarg_1:当然就是参数列表的第一个参数了。

OpCodes.Stfld:用新值替换在对象引用或指针的字段中存储的值。

堆栈转换行为依次为： 1.将对象引用（或指针）推送到堆栈上。

2.将值推送到堆栈上。从堆栈中弹出该值和对象引用/指针；

3.用所提供的值替换对象中 field 的值。

意思就是在往field存值时需要三个步骤：

1.将对象引用（或指针）推送到堆栈上：ilSetId.Emit(OpCodes.Ldarg_0);=》加载this

2.将值推送到堆栈上。从堆栈中弹出该值和对象引用/指针：ilSetId.Emit(OpCodes.Ldarg_1)=》将要存入field的值载入堆栈

3.用所提供的值替换对象中 field 的值：ilSetId.Emit(OpCodes.Stfld, fldId)=》设置field的值

OpCodes.Ldfld:当然就是将指定field的值加载到堆栈上了。

OpCodes的成员命名都是很规范的，ldXXX一般就是加载什么到堆栈,stXXX则是设置xxx的值，ldcXX则是加载常量xx到堆栈，所以写代码时如果遇到不知道命令是什么就完全可以按照这种规则去推测。对于命令不知道如何用时去查查MSDN相应的堆栈转换规则是什么就一目了然了。

三、创建方法

在上一小节已经创建了几个方法，这里再大致描述下创建方法的流程:

1.使用TypeBuilder.DefineMethod创建一个方法;

2.调用 MethodBuilder.GetIlGenerator获取IL生成器

3.写入自己需要的IL代码。

我们在这里为Student添加一个ToString方法,我们要达到的目标如下:

在这里要注意的是string.Format产生的结果并不会被推送到堆栈上，而是会被存储到一个局部变量当中。只不过平时写C#代码并未体现出这一点而已。因此可以如下创建此方法:

代码

这里有几个新元素：

1.创建局部变量:使用ILGenerator.DeclareLocal完成

2.OpCodes.Box：对值类型装箱，注意第二个参数为该值类型的类型。

3.OpCodes.Stloc和OpCodes.Ldloc:设置局部变量的值和加载局部变量值到堆栈。

到现在为止，我们的Student反编译后大致如下：

代码

四.其他

上面的实例都是关于实例成员的，对于静态成员呢？

加载或设置静态实例字段会相应的变为:stsfld和ldsfld。而静态方法则由于不会将this作为第一个参数传递，因此ldarg_0就相应地变成了实际参数列表的第一个从参数。

posted @ 2010-06-03 15:00 大漠银狐 阅读(157) | 评论(1) | 编辑

动态代码的使用(反射和动态生成类)

在软件开发尤其是框架和底层开发时，为了更灵活的控制代码，常常需要进行一些动态的操作。比如根据用户的输入等动态的调用类中的方法或者根据数据库表结构、用户要求动态的生成一些类，然后再动态的调用类中的方法。当然使用这些方式时会对性能有一点影响，具体使用过程中可以根据实际情况来定，不过一般的B/S开发中主要的瓶颈还是在数据库操作和网速方面，这点影响应该可以忽略的
下面我就从这两个方面来说说动态代码的使用：
一、反射的使用
可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。
需要使用的命名空间：System.Reflection
反射的作用很多，下面的例子主要是看一下怎么动态的调用类中的方法。

例子类
class ReflTest1
{
private string _prop1;

public string Prop1
{
get{ return _prop1; }
set{ _prop1 = value; }
}

public void Write1(string strText)
{
Console.WriteLine("111111111:" + strText);
}
public void Write2(string strText)
{
Console.WriteLine("222222222:" + strText);
}
public void MyWrite(string strText)
{
Console.WriteLine("3333333333:" + strText);
}
}

这个例子中提供了三个方法和一个属性，下面的代码来动态的调用它们：

string strText = "abcd";

BindingFlags flags = (BindingFlags.NonPublic | BindingFlags.Public |
BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly);

Type t = typeof(ReflTest1);
MethodInfo[] mi = t.GetMethods(flags);
Object obj = Activator.CreateInstance(t);

foreach (MethodInfo m in mi)
{
if (m.Name.StartsWith("Write"))
{
m.Invoke(obj, new object[]{ strText });
}
}

MethodInfo mMy = t.GetMethod("MyWrite");
if (mMy != null)
{
mMy.Invoke(obj, new object[]{ strText });
}

BindingFlags用来设置要取得哪些类型的方法，然后我们就可以取得这些方法来动态的调用。(当然为了可以循环的调用方法，在方法的命名方面可以自己指定一个规则)
二、动态生成类
我们可以在程序运行过程中调用.NET中提供的编译类，动态的将一段string编译成一个类，然后再通过反射来调用它
需要使用的命名空间：System.CodeDom System.CodeDom.Compiler Microsoft.CSharp System.Reflection
动态创建、编译类的代码如下：

public static Assembly NewAssembly()
{
//创建编译器实例。
provider = new CSharpCodeProvider();
//设置编译参数。
paras = new CompilerParameters();
paras.GenerateExecutable = false;
paras.GenerateInMemory = true;

//创建动态代码。
StringBuilder classSource = new StringBuilder();
classSource.Append("public class DynamicClass \n");
classSource.Append("{\n");

//创建属性。
classSource.Append(propertyString("aaa"));
classSource.Append(propertyString("bbb"));
classSource.Append(propertyString("ccc"));

classSource.Append("}");

System.Diagnostics.Debug.WriteLine(classSource.ToString());

//编译代码。
CompilerResults result = provider.CompileAssemblyFromSource(paras, classSource.ToString());

//获取编译后的程序集。
Assembly assembly = result.CompiledAssembly;

return assembly;
}

private static string propertyString(string propertyName)
{
StringBuilder sbProperty = new StringBuilder();
sbProperty.Append(" private int _" + propertyName + " = 0;\n");
sbProperty.Append(" public int " + "" + propertyName + "\n");
sbProperty.Append(" {\n");
sbProperty.Append(" get{ return _" + propertyName + ";} \n");
sbProperty.Append(" set{ _" + propertyName + " = value; }\n");
sbProperty.Append(" }");
return sbProperty.ToString();
}

propertyString方法就是用来拼写字符串的
整个代码比较简单，主要步骤就是：1、拼写类的字符串 2、调用CSharpCodeProvider类进行编译得到程序集(assembly)
接下来就可以利用之前反射的方法来动态调用这个类中的属性了：

Assembly assembly = NewAssembly();

object Class1 = assembly.CreateInstance("DynamicClass");
ReflectionSetProperty(Class1, "aaa", 10);
ReflectionGetProperty(Class1, "aaa");

object Class2 = assembly.CreateInstance("DynamicClass");
ReflectionSetProperty(Class1, "bbb", 20);
ReflectionGetProperty(Class1, "bbb");

DynamicClass是我动态类的类名，aaa和bbb是其中的属性
ReflectionSetProperty和ReflectionGetProperty代码如下：

给属性赋值
private static void ReflectionSetProperty(object objClass, string propertyName, int value)
{
PropertyInfo[] infos = objClass.GetType().GetProperties();
foreach (PropertyInfo info in infos)
{
if (info.Name == propertyName && info.CanWrite)
{
info.SetValue(objClass, value, null);
}
}
}

取得属性的值
private static void ReflectionGetProperty(object objClass, string propertyName)
{
PropertyInfo[] infos = objClass.GetType().GetProperties();
foreach (PropertyInfo info in infos)
{
if (info.Name == propertyName && info.CanRead)
{
System.Console.WriteLine(info.GetValue(objClass, null));
}
}
}

posted @ 2010-06-03 14:59 大漠银狐 阅读(62) | 评论(1) | 编辑