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

在上一篇中，我们由简到繁，提到了服务端的四种方式：服务一个客户端的一个请求、服务一个客户端的多个请求、服务多个客户端的一个请求、服务多个客户端的多个请求。我们说到可以将里层的while循环交给一个新建的线程去让它来完成。除了这种方式以外，我们还可以使用一种更好的方式――使用线程池中的线程来完成。我们可以使用BeginRead()、BeginWrite()等异步方法，同时让这BeginRead()方法和它的回调方法形成一个类似于while的无限循环：首先在第一层循环中，接收到一个客户端后，调用BeginRead()，然后为该方法提供一个读取完成后的回调方法，然后在回调方法中对收到的字符进行处理，随后在回调方法中接着调用BeginRead()方法，并传入回调方法本身。

由于程序实现功能和上一篇完全相同，我就不再细述了。而关于异步调用方法更多详细内容，可以参见 C#中的委托和事件(续)。

1.服务端的实现

当程序越来越复杂的时候，就需要越来越高的抽象，所以从现在起我们不再把所有的代码全部都扔进Main()里，这次我创建了一个RemoteClient类，它对于服务端获取到的TcpClient进行了一个包装：

  1. public class RemoteClient { 
  2. private TcpClient client; 
  3. private NetworkStream streamToClient; 
  4. private const int BufferSize = 8192; 
  5. private byte[] buffer; 
  6. private RequestHandler handler; 
  8. public RemoteClient(TcpClient client) { 
  9. this.client = client; 
  11. // 打印连接到的客户端信息
  12.         Console.WriteLine("\nClient Connected！{0} <-- {1}", 
  13.             client.Client.LocalEndPoint, client.Client.RemoteEndPoint); 
  15. // 获得流
  16.         streamToClient = client.GetStream(); 
  17.         buffer = new byte[BufferSize]; 
  19. // 设置RequestHandler
  20.         handler = new RequestHandler(); 
  22. // 在构造函数中就开始准备读取
  23.         AsyncCallback callBack = new AsyncCallback(ReadComplete); 
  24.         streamToClient.BeginRead(buffer, 0, BufferSize, callBack, null); 
  25.     } 
  27. // 再读取完成时进行回调
  28. private void ReadComplete(IAsyncResult ar) { 
  29. int bytesRead = 0; 
  30. try { 
  31. lock (streamToClient) { 
  32.                 bytesRead = streamToClient.EndRead(ar); 
  33.                 Console.WriteLine("Reading data, {0} bytes ...", bytesRead); 
  34.             } 
  35. if (bytesRead == 0) throw new Exception("读取到0字节"); 
  37. string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead); 
  38.             Array.Clear(buffer,0,buffer.Length);        // 清空缓存，避免脏读
  40. string[] msgArray = handler.GetActualString(msg);   // 获取实际的字符串
  42. // 遍历获得到的字符串
  43. foreach (string m in msgArray) { 
  44.                 Console.WriteLine("Received: {0}", m); 
  45. string back = m.ToUpper(); 
  47. // 将得到的字符串改为大写并重新发送
  48. byte[] temp = Encoding.Unicode.GetBytes(back); 
  49.                 streamToClient.Write(temp, 0, temp.Length); 
  50.                 streamToClient.Flush(); 
  51.                 Console.WriteLine("Sent: {0}", back); 
  52.             }              
  54. // 再次调用BeginRead()，完成时调用自身，形成无限循环
  55. lock (streamToClient) { 
  56.                 AsyncCallback callBack = new AsyncCallback(ReadComplete); 
  57.                 streamToClient.BeginRead(buffer, 0, BufferSize, callBack, null); 
  58.             } 
  59.         } catch(Exception ex) { 
  60. if(streamToClient!=null) 
  61.                 streamToClient.Dispose(); 
  62.             client.Close(); 
  63.             Console.WriteLine(ex.Message);      // 捕获异常时退出程序           
  64.         } 
  65.     } 
  66. } 

随后，我们在主程序中仅仅创建TcpListener类型实例，由于RemoteClient类在构造函数中已经完成了初始化的工作，所以我们在下面的while循环中我们甚至不需要调用任何方法：

  1. class Server { 
  2. static void Main(string[] args) { 
  3.         Console.WriteLine("Server is running ... "); 
  4.         IPAddress ip = new IPAddress(new byte[] { 127, 0, 0, 1 }); 
  5.         TcpListener listener = new TcpListener(ip, 8500); 
  7.         listener.Start();           // 开始侦听
  8.         Console.WriteLine("Start Listening ..."); 
  10. while (true) { 
  11. // 获取一个连接，同步方法，在此处中断
  12.             TcpClient client = listener.AcceptTcpClient();             
  13.             RemoteClient wapper = new RemoteClient(client); 
  14.         } 
  15.     } 
  16. } 

好了，服务端的实现现在就完成了，接下来我们再看一下客户端的实现：

2.客户端的实现

与服务端类似，我们首先对TcpClient进行一个简单的包装，使它的使用更加方便一些，因为它是服务端的客户，所以我们将类的名称命名为ServerClient：

  1. public class ServerClient { 
  2. private const int BufferSize = 8192; 
  3. private byte[] buffer; 
  4. private TcpClient client; 
  5. private NetworkStream streamToServer; 
  6. private string msg = "Welcome to TraceFact.Net!"; 
  8. public ServerClient() { 
  9. try { 
  10.             client = new TcpClient(); 
  11.             client.Connect("localhost", 8500);      // 与服务器连接
  12.         } catch (Exception ex) { 
  13.             Console.WriteLine(ex.Message); 
  14. return; 
  15.         } 
  16.         buffer = new byte[BufferSize]; 
  18. // 打印连接到的服务端信息
  19.         Console.WriteLine("Server Connected！{0} --> {1}", 
  20.             client.Client.LocalEndPoint, client.Client.RemoteEndPoint); 
  22.         streamToServer = client.GetStream(); 
  23.     } 
  25. // 连续发送三条消息到服务端
  26. public void SendMessage(string msg) { 
  28.         msg = String.Format("[length={0}]{1}", msg.Length, msg); 
  30. for (int i = 0; i <= 2; i++) { 
  31. byte[] temp = Encoding.Unicode.GetBytes(msg);   // 获得缓存
  32. try { 
  33.                 streamToServer.Write(temp, 0, temp.Length); // 发往服务器
  34.                 Console.WriteLine("Sent: {0}", msg); 
  35.             } catch (Exception ex) { 
  36.                 Console.WriteLine(ex.Message); 
  37. break; 
  38.             } 
  39.         } 
  41. lock (streamToServer) { 
  42.             AsyncCallback callBack = new AsyncCallback(ReadComplete); 
  43.             streamToServer.BeginRead(buffer, 0, BufferSize, callBack, null); 
  44.         } 
  45.     } 
  47. public void SendMessage() { 
  48.         SendMessage(this.msg); 
  49.     } 
  51. // 读取完成时的回调方法
  52. private void ReadComplete(IAsyncResult ar) { 
  53. int bytesRead; 
  55. try { 
  56. lock (streamToServer) { 
  57.                 bytesRead = streamToServer.EndRead(ar); 
  58.             } 
  59. if (bytesRead == 0) throw new Exception("读取到0字节"); 
  61. string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead); 
  62.             Console.WriteLine("Received: {0}", msg); 
  63.             Array.Clear(buffer, 0, buffer.Length);      // 清空缓存，避免脏读
  65. lock (streamToServer) { 
  66.                 AsyncCallback callBack = new AsyncCallback(ReadComplete); 
  67.                 streamToServer.BeginRead(buffer, 0, BufferSize, callBack, null); 
  68.             } 
  69.         } catch (Exception ex) { 
  70. if(streamToServer!=null) 
  71.                 streamToServer.Dispose(); 
  72.             client.Close(); 
  74.             Console.WriteLine(ex.Message); 
  75.         } 
  76.     } 
  77. } 

在上面的SendMessage()方法中，我们让它连续发送了三条同样的消息，这么仅仅是为了测试，因为异步操作同样会出现上面说过的：服务器将客户端的请求拆开了的情况。最后我们在Main()方法中创建这个类型的实例，然后调用SendMessage()方法进行测试：

  1. class Client { 
  2. static void Main(string[] args) { 
  3.         ConsoleKey key; 
  5.         ServerClient client = new ServerClient(); 
  6.         client.SendMessage(); 
  8.         Console.WriteLine("\n\n输入\"Q\"键退出。"); 
  9. do { 
  10.             key = Console.ReadKey(true).Key; 
  11.         } while (key != ConsoleKey.Q); 
  12.     } 
  13. } 

是不是感觉很清爽？因为良好的代码重构，使得程序在复杂程度提高的情况下依然可以在一定程度上保持良好的阅读性。

3.程序测试

最后一步，我们先运行服务端，接着连续运行两个客户端，看看它们的输出分别是什么：

大家可以看到，在服务端，我们可以连接多个客户端，同时为它们服务；除此以外，由接收的字节数发现，两个客户端均有两个请求被服务端合并成了一条请求，因为我们在其中加入了特殊的协议，所以在服务端可以对这种情况进行良好的处理。

在客户端，我们没有采取类似的处理，所以当客户端收到应答时，仍然会发生请求合并的情况。对于这种情况，我想大家已经知道该如何处理了，就不再多费口舌了。

使用这种定义协议的方式有它的优点，但缺点也很明显，如果客户知道了这个协议，有意地输入[length=xxx]，但是后面的长度却不匹配，此时程序就会出错。可选的解决办法是对“[”和“]”进行编码，当客户端有意输入这两个字符时，我们将它替换成“\[”和“\]”或者别的字符，在读取后再将它还原。

关于这个范例就到此结束了，剩下的两个范例都将采用异步传输的方式，并且会加入更多的协议内容。下一篇我们将介绍如何向服务端发送或接收文件。

这篇文章我们将前进一大步，使用异步的方式来对服务端编程，以使它成为一个真正意义上的服务器：可以为多个客户端的多次请求服务。但是开始之前，我们需要解决上一节中遗留的一个问题。

消息发送时的问题

这个问题就是：客户端分两次向流中写入数据（比如字符串）时，我们主观上将这两次写入视为两次请求；然而服务端有可能将这两次合起来视为一条请求，这在两个请求间隔时间比较短的情况下尤其如此。同样，也有可能客户端发出一条请求，但是服务端将其视为两条请求处理。下面列出了可能的情况，假设我们在客户端连续发送两条“Welcome to Tracefact.net!”，则数据到达服务端时可能有这样三种情况：

NOTE：在这里我们假设采用ASCII编码方式，因为此时上面的一个方框正好代表一个字节，而字符串到达末尾后为持续的0（因为byte是值类型，且最小为0）。

上面的第一种情况是最理想的情况，此时两条消息被视为两个独立请求由服务端完整地接收。第二种情况的示意图如下，此时一条消息被当作两条消息接收了：

而对于第三种情况，则是两条消息被合并成了一条接收：

如果你下载了上一篇文章所附带的源码，那么将Client2.cs进行一下修改，不通过用户输入，而是使用一个for循环连续的发送三个请求过去，这样会使请求的间隔时间更短，下面是关键代码：

  1. string msg = "Welcome to TraceFact.Net!"; 
  3. for (int i = 0; i <= 2; i++) { 
  4. byte[] buffer = Encoding.Unicode.GetBytes(msg);     // 获得缓存
  5. try { 
  6.         streamToServer.Write(buffer, 0, buffer.Length); // 发往服务器
  7.         Console.WriteLine("Sent: {0}", msg); 
  8.     } catch (Exception ex) { 
  9.         Console.WriteLine(ex.Message); 
  10. break; 
  11.     } 
  12. } 

运行服务端，然后再运行这个客户端，你可能会看到这样的结果：

可以看到，尽管上面将消息分成了三条单独发送，但是服务端却将后两条合并成了一条。对于这些情况，我们可以这样处理：就好像HTTP协议一样，在实际的请求和应答内容之前包含了HTTP头，其中是一些与请求相关的信息。我们也可以订立自己的协议，来解决这个问题，比如说，对于上面的情况，我们就可以定义这样一个协议：

[length=XXX]：其中xxx是实际发送的字符串长度（注意不是字节数组buffer的长度），那么对于上面的请求，则我们发送的数据为：“[length=25]Welcome to TraceFact.Net!”。而服务端接收字符串之后，首先读取这个“元数据”的内容，然后再根据“元数据”内容来读取实际的数据，它可能有下面这样两种情况：

NOTE：我觉得这里借用“元数据”这个术语还算比较恰当，因为“元数据”就是用来描述数据的数据。

•    “[“”]”中括号是完整的，可以读取到length的字节数。然后根据这个数值与后面的字符串长度相比，如果相等，则说明发来了一条完整信息；如果多了，那么说明接收的字节数多了，取出合适的长度，并将剩余的进行缓存；如果少了，说明接收的不够，那么将收到的进行一个缓存，等待下次请求，然后将两条合并。

•    “[”“]”中括号本身就不完整，此时读不到length的值，因为中括号里的内容被截断了，那么将读到的数据进行缓存，等待读取下次发送来的数据，然后将两次合并之后再按上面的方式进行处理。

接下来我们来看下如何来进行实际的操作，实际上，这个问题已经不属于C#网络编程的内容了，而完全是对字符串的处理。所以我们不再编写服务端/客户端代码，直接编写处理这几种情况的方法：

  1. public class RequestHandler { 
  2. private string temp = string.Empty; 
  4. public string[] GetActualString(string input) { 
  5. return GetActualString(input, null); 
  6.     } 
  8. private string[] GetActualString(string input, List<string> outputList) { 
  9. if (outputList == null) 
  10.             outputList = new List<string>(); 
  12. if (!String.IsNullOrEmpty(temp)) 
  13.             input = temp + input; 
  15. string output = ""; 
  16. string pattern = @"(?<=^\[length=)(\d+)(?=\])"; 
  17. int length; 
  19. if (Regex.IsMatch(input, pattern)) { 
  21.             Match m = Regex.Match(input, pattern); 
  23. // 获取消息字符串实际应有的长度
  24.             length = Convert.ToInt32(m.Groups[0].Value); 
  26. // 获取需要进行截取的位置
  27. int startIndex = input.IndexOf(']') + 1; 
  29. // 获取从此位置开始后所有字符的长度
  30.             output = input.Substring(startIndex); 
  32. if (output.Length == length) { 
  33. // 如果output的长度与消息字符串的应有长度相等
  34. // 说明刚好是完整的一条信息
  35.                 outputList.Add(output); 
  36.                 temp = ""; 
  37.             } else if (output.Length < length) { 
  38. // 如果之后的长度小于应有的长度，
  39. // 说明没有发完整，则应将整条信息，包括元数据，全部缓存
  40. // 与下一条数据合并起来再进行处理
  41.                 temp = input; 
  42. // 此时程序应该退出，因为需要等待下一条数据到来才能继续处理
  44.             } else if (output.Length > length) { 
  45. // 如果之后的长度大于应有的长度，
  46. // 说明消息发完整了，但是有多余的数据
  47. // 多余的数据可能是截断消息，也可能是多条完整消息
  49. // 截取字符串
  50.                 output = output.Substring(0, length); 
  51.                 outputList.Add(output); 
  52.                 temp = ""; 
  54. // 缩短input的长度
  55.                 input = input.Substring(startIndex + length); 
  57. // 递归调用
  58.                 GetActualString(input, outputList); 
  59.             } 
  60.         } else {    // 说明“[”，“]”就不完整
  61.             temp = input; 
  62.         } 
  64. return outputList.ToArray(); 
  65.     } 
  66. } 

这个方法接收一个满足协议格式要求的输入字符串，然后返回一个数组，这是因为如果出现多次请求合并成一个发送过来的情况，那么就将它们全部返回。随后简单起见，我在这个类中添加了一个静态的Test()方法和PrintOutput()帮助方法，进行了一个简单的测试，注意我直接输入了length=13，这个是我提前计算好的。

  1. public static void Test() { 
  2.     RequestHandler handler = new RequestHandler(); 
  3. string input; 
  5. // 第一种情况测试 - 一条消息完整发送
  6.     input = "[length=13]明天中秋，祝大家节日快乐！"; 
  7.     handler.PrintOutput(input); 
  9. // 第二种情况测试 - 两条完整消息一次发送
  10.     input = "明天中秋，祝大家节日快乐！"; 
  11.     input = String.Format 
  12.         ("[length=13]{0}[length=13]{0}", input); 
  13.     handler.PrintOutput(input); 
  15. // 第三种情况测试A - 两条消息不完整发送
  16.     input = "[length=13]明天中秋，祝大家节日快乐！[length=13]明天中秋"; 
  17.     handler.PrintOutput(input); 
  19.     input = "，祝大家节日快乐！"; 
  20.     handler.PrintOutput(input); 
  22. // 第三种情况测试B - 两条消息不完整发送
  23.     input = "[length=13]明天中秋，祝大家"; 
  24.     handler.PrintOutput(input); 
  26.     input = "节日快乐！[length=13]明天中秋，祝大家节日快乐！"; 
  27.     handler.PrintOutput(input); 
  30. // 第四种情况测试 - 元数据不完整
  31.     input = "[leng"; 
  32.     handler.PrintOutput(input);     // 不会有输出
  34.     input = "th=13]明天中秋，祝大家节日快乐！"; 
  35.     handler.PrintOutput(input); 
  37. } 
  39. // 用于测试输出
  40. private void PrintOutput(string input) { 
  41.     Console.WriteLine(input); 
  42. string[] outputArray = GetActualString(input); 
  43. foreach (string output in outputArray) { 
  44.         Console.WriteLine(output); 
  45.     } 
  46.     Console.WriteLine(); 
  47. } 

运行上面的程序，可以得到如下的输出：

OK，从上面的输出可以看到，这个方法能够满足我们的要求。对于这篇文章最开始提出的问题，可以很轻松地通过加入这个方法来解决，这里就不再演示了，但在本文所附带的源代码含有修改过的程序。在这里花费了很长的时间，接下来让我们回到正题，看下如何使用异步方式完成上一篇中的程序吧。

C#编写简单的聊天程序(2009-04-07 12:16:11)

引言

这是一篇基于Socket进行网络编程的入门文章，我对于网络编程的学习并不够深入，这篇文章是对于自己知识的一个巩固，同时希望能为初学的朋友提供一点参考。文章大体分为四个部分：程序的分析与设计、C#网络编程基础(篇外篇)、聊天程序的实现模式、程序实现。

程序的分析与设计

1.明确程序功能

如果大家现在已经参加了工作，你的经理或者老板告诉你，“小王，我需要你开发一个聊天程序”。那么接下来该怎么做呢？你是不是在脑子里有个雏形，然后就直接打开VS2005开始设计窗体，编写代码了呢？在开始之前，我们首先需要进行软件的分析与设计。就拿本例来说，如果只有这么一句话“一个聊天程序”，恐怕现在大家对这个“聊天程序”的概念就很模糊，它可以是像QQ那样的非常复杂的一个程序，也可以是很简单的聊天程序；它可能只有在对方在线的时候才可以进行聊天，也可能进行留言；它可能每次将消息只能发往一个人，也可能允许发往多个人。它还可能有一些高级功能，比如向对方传送文件等。所以我们首先需要进行分析，而不是一上手就开始做，而分析的第一步，就是搞清楚程序的功能是什么，它能够做些什么。在这一步，我们的任务是了解程序需要做什么，而不是如何去做。

了解程序需要做什么，我们可以从两方面入手，接下来我们分别讨论。

1.1请求客户提供更详细信息

我们可以做的第一件事就是请求客户提供更加详细的信息。尽管你的经理或老板是你的上司，但在这个例子中，他就是你的客户（当然通常情况下，客户是公司外部委托公司开发软件的人或单位）。当遇到上面这种情况，我们只有少得可怜的一条信息“一个聊天程序”，首先可以做的，就是请求客户提供更加确切的信息。比如，你问经理“对这个程序的功能能不能提供一些更具体的信息？”。他可能会像这样回答：“哦，很简单，可以登录聊天程序，登录的时候能够通知其他在线用户，然后与在线的用户进行对话，如果不想对话了，就注销或者直接关闭，就这些吧。”

有了上面这段话，我们就又可以得出下面几个需求：

1.    程序可以进行登录。

2.    登录后可以通知其他在线用户。

3.    可以与其他用户进行对话。

4.    可以注销或者关闭。

1.2对于用户需求进行提问，并进行总结

经常会有这样的情况：可能客户给出的需求仍然不够细致，或者客户自己本身对于需求就很模糊，此时我们需要做的就是针对用户上面给出的信息进行提问。接下来我就看看如何对上面的需求进行提问，我们至少可以向经理提出以下问题：

NOTE：这里我穿插一个我在见到的一个印象比较深刻的例子：客户往往向你表达了强烈的意愿他多么多么想拥有一个属于自己的网站，但是，他却没有告诉你网站都有哪些内容、栏目，可以做什么。而作为开发者，我们显然关心的是后者。

1.    登录时需要提供哪些内容？需不需要提供密码？

2.    允许多少人同时在线聊天？

3.    与在线用户聊天时，可以将一条消息发给一个用户，还是可以一次将消息发给多个用户？

4.    聊天时发送的消息包括哪些内容？

5.    注销和关闭有什么区别？

6.    注销和关闭对对方需不需要给对方提示？

由于这是一个范例程序，而我在为大家讲述，所以我只能再充当一下客户的角色，来回答上面的问题：

1.    登录时只需要提供用户名称就可以了，不需要输入密码。

2.    允许两个人在线聊天。（这里我们只讲述这种简单情况，允许多人聊天需要使用多线程）

3.    因为只有两个人，那么自然是只能发给一个用户了。

4.    聊天发送的消息包括：用户名称、发送时间还有正文。

5.    注销并不关闭程序，只是离开了对话，可以再次进行连接。关闭则是退出整个应用程序。

6.    注销和关闭均需要给对方提示。

好了，有了上面这些信息我们基本上就掌握了程序需要完成的功能，那么接下来做什么？开始编码了么？上面的这些属于业务流程，除非你对它已经非常熟悉，或者程序非常的小，那么可以对它进行编码，但是实际中，我们最好再编写一些用例，这样会使程序的流程更加的清楚。

1.3编写用例

通常一个用例对应一个功能或者叫需求，它是程序的一个执行路径或者执行流程。编写用例的思路是：假设你已经有了这样一个聊天程序，那么你应该如何使用它？我们的使用步骤，就是一个用例。用例的特点就每次只针对程序的一个功能编写，最后根据用例编写代码，最终完成程序的开发。我们这里的需求只有简单的几个：登录，发送消息，接收消息，注销或关闭，上面的分析是对这几点功能的一个明确。接下来我们首先编写第一个用例：登录。

在开始之前，我们先明确一个概念：客户端，服务端。因为这个程序只是在两个人（机器）之间聊天，那么我们大致可以绘出这样一个图来：

我们期望用户A和用户B进行对话，那么我们就需要在它们之间建立起连接。尽管“用户A”和“用户B”的地位是对等的，但按照约定俗称的说法：我们将发起连接请求的一方称为客户端（或叫本地），另一端称为服务端（或叫远程）。所以我们的登录过程，就是“用户A”连接到“用户B”的过程，或者说客户端（本地）连接到服务端（远程）的过程。在分析这个程序的过程中，我们总是将其分为两部分，一部分为发起连接、发送消息的一方（本地），一方为接受连接、接收消息的一方（远程）。

登录和连接（本地）

主路径
可选路径

1.打开应用程序，显示登录窗口

2.输入用户名

3.点击“登录”按钮，登录成功
3.“登录”失败 如果用户名为空，重新进入第2步。

4.显示主窗口，显示登录的用户名称

5.点击“连接”，连接至远程

6.连接成功

6.1提示用户，连接已经成功。

6.连接失败

6.1 提示用户，连接不成功

5.在用户界面变更控件状态

5.2连接为灰色，表示已经连接

5.3注销为亮色，表示可以注销

5.4发送为亮色，表示可以发消息

这里我们的用例名称为登录和连接，但是后面我们又打了一个括号，写着“本地”，它的意思是说，登录和连接是客户端，也就是发起连接的一方采取的动作。同样，我们需要写下当客户端连接至服务端时，服务端采取的动作。

登录和连接（远程）

主路径
可选路径

1-4 同客户端    

5.等待连接    

6.如果有连接，自动在用户界面显示“远程主机连接成功”    

接下来我们来看发送消息。在发送消息时，已经是登录了的，也就是“用户A”、“用户B”已经做好了连接，所以我们现在就可以只关注发送这一过程：

发送消息（本地）

主路径
可选路径

1.输入消息

2.点击发送按钮
2.没有输入消息，重新回到第1步

3.在用户界面上显示发出的消息
3.服务端已经断开连接或者关闭 3.1在客户端用户界面上显示错误消息

然后我们看一下接收消息，此时我们只关心接收消息这一部分。

接收消息（远程）

主路径
可选路径

1.侦听到客户端发来的消息，自动显示在用户界面上。

注意到这样一点：当远程主机向本地返回消息时，它的用例又变为了上面的用例“发送消息（本地）”。因为它们的角色已经互换了。

最后看一下注销，我们这里研究的是当我们在本地机器点击“注销”后，双方采取的动作：

注销（本地主动）

主路径
可选路径

1.点击注销按钮，断开与远程的连接    

2.在用户界面显示已经注销    

3.更改控件状态 3.1注销为灰色，表示已经注销 3.2连接为亮色，表示可以连接

3.3发送为灰色，表示无法发送     

与此对应，服务端应该作出反应：

注销（远程被动）

主路径
可选路径

1.自动显示远程用户已经断开连接。    

注意到一点：当远程主动注销时，它采取的动作为上面的“本地主动”，本地采取的动作则为这里的“远程被动”。

至此，应用程序的功能分析和用例编写就告一段落了，通过上面这些表格，之后再继续编写程序变得容易了许多。另外还需要记得，用例只能为你提供一个操作步骤的指导，在实现的过程中，因为技术等方面的原因，可能还会有少量的修改。如果修改量很大，可以重新修改用例；如果修改量不大，那么就可以直接编码。这是一个迭代的过程，也没有一定的标准，总之是以高效和合适为标准。

2.分析与设计

我们已经很清楚地知道了程序需要做些什么，尽管现在还不知道该如何去做。我们甚至可以编写出这个程序所需要的接口，以后编写代码的时候，我们只要去实现这些接口就可以了。这也符合面向接口编程的原则。另外我们注意到，尽管这是一个聊天程序，但是却可以明确地划分为两部分，一部分发送消息，一部分接收消息。另外注意上面标识为自动的语句，它们暗示这个操作需要通过事件的通知机制来完成。关于委托和事件，可以参考这两篇文章：

•    C#中的委托和事件 - 委托和事件的入门文章，同时捎带讲述了Observer设计模式和.NET的事件模型

•    C#中的委托和事件(续) - 委托和事件更深入的一些问题，包括异常、超时的处理，以及使用委托来异步调用方法。

2.1消息Message

首先我们可以定义消息，前面我们已经明确了消息包含三个部分：用户名、时间、内容，所以我们可以定义一个结构来表示这个消息：

  1. public struct Message { 
  2. private readonly string userName; 
  3. private readonly string content; 
  4. private readonly DateTime postDate; 
  6. public Message(string userName, string content) { 
  7. this.userName = userName; 
  8. this.content = content; 
  9. this.postDate = DateTime.Now; 
  10.     } 
  12. public Message(string content) : this("System", content) { } 
  14. public string UserName { 
  15. get { return userName; } 
  16.     } 
  18. public string Content { 
  19. get { return content; } 
  20.     } 
  22. public DateTime PostDate { 
  23. get { return postDate; } 
  24.     } 
  26. public override string ToString() { 
  27. return String.Format("{0}[{1}]：\r\n{2}\r\n", userName, postDate, content); 
  28.     } 
  29. } 

2.2消息发送方IMessageSender

从上面我们可以看出，消息发送方主要包含这样几个功能：登录、连接、发送消息、注销。另外在连接成功或失败时还要通知用户界面，发送消息成功或失败时也需要通知用户界面，因此，我们可以让连接和发送消息返回一个布尔类型的值，当它为真时表示连接或发送成功，反之则为失败。因为登录没有任何的业务逻辑，仅仅是记录控件的值并进行显示，所以我不打算将它写到接口中。因此我们可以得出它的接口大致如下：

  1. public interface IMessageSender { 
  2. bool Connect(IPAddress ip, int port);       // 连接到服务端
  3. bool SendMessage(Message msg);              // 发送用户
  4. void SignOut();                                 // 注销系统
  5. } 

2.3消息接收方IMessageReceiver

而对于消息接收方，从上面我们可以看出，它的操作全是被动的：客户端连接时自动提示，客户端连接丢失时显示自动提示，侦听到消息时自动提示。注意到上面三个词都用了“自动”来修饰，在C#中，可以定义委托和事件，用于当程序中某种情况发生时，通知另外一个对象。在这里，程序即是我们的IMessageReceiver，某种情况就是上面的三种情况，而另外一个对象则为我们的用户界面。因此，我们现在首先需要定义三个委托：

  1. public delegate void MessageReceivedEventHandler(string msg);  
  2. public delegate void ClientConnectedEventHandler(IPEndPoint endPoint); 
  3. public delegate void ConnectionLostEventHandler(string info); 

接下来，我们注意到接收方需要侦听消息，因此我们需要在接口中定义的方法是StartListen()和StopListen()方法，这两个方法是典型的技术相关，而不是业务相关，所以从用例中是看不出来的，可能大家现在对这两个方法是做什么的还不清楚，没有关系，我们现在并不写实现，而定义接口并不需要什么成本，我们写下IMessageReceiver的接口定义：

  1. public interface IMessageReceiver { 
  2. event MessageReceivedEventHandler MessageReceived; // 接收到发来的消息
  3. event ConnectionLostEventHandler ClientLost;            // 远程主动断开连接
  4. event ClientConnectedEventHandler ClientConnected;  // 远程连接到了本地
  5. void StartListen();         // 开始侦听端口
  6. void StopListen();          // 停止侦听端口
  7. } 

我记得曾经看过有篇文章说过，最好不要在接口中定义事件，但是我忘了他的理由了，所以本文还是将事件定义在了接口中。

2.4主程序Talker

而我们的主程序是既可以发送，又可以接收，一般来说，如果一个类像获得其他类的能力，以采用两种方法：继承和复合。因为C#中没有多重继承，所以我们无法同时继承实现了IMessageReceiver和IMessageSender的类。那么我们可以采用复合，将它们作为类成员包含在Talker内部：

  1. public class Talker { 
  2. private IMessageReceiver receiver; 
  3. private IMessageSender sender; 
  5. public Talker(IMessageReceiver receiver, IMessageSender sender) { 
  6. this.receiver = receiver; 
  7. this.sender = sender; 
  8.     } 
  9. } 

现在，我们的程序大体框架已经完成，接下来要关注的就是如何实现它，现在让我们由设计走入实现，看看实现一个网络聊天程序，我们需要掌握的技术吧。

4.设计窗体，编写窗体事件代码

现在我们开始设计窗体，我已经设计好了，现在可以先进行一下预览：

这里需要注意的就是上面的侦听端口，是程序接收消息时的侦听端口，也就是IMessageReceiver所使用的。其他的没有什么好说的，下来我们直接看一下代码，控件的命名是自解释的，我就不多说什么了。唯一要稍微说明下的是txtMessage指的是下面发送消息的文本框，txtContent指上面的消息记录文本框：

  1. public partial class PrimaryForm : Form { 
  2. private Talker talker; 
  3. private string userName; 
  4. public PrimaryForm(string name) { 
  5.         InitializeComponent(); 
  6.         userName = lbName.Text = name; 
  7. this.talker = new Talker(); 
  8. this.Text = userName + " Talking ..."; 
  9.         talker.ClientLost += 
  10. new ConnectionLostEventHandler(talker_ClientLost); 
  11.         talker.ClientConnected += 
  12. new ClientConnectedEventHandler(talker_ClientConnected); 
  13.         talker.MessageReceived += 
  14. new MessageReceivedEventHandler(talker_MessageReceived); 
  15.         talker.PortNumberReady += 
  16. new PortNumberReadyEventHandler(PrimaryForm_PortNumberReady); 
  17.     } 
  18. void ConnectStatus() {  } 
  19. void DisconnectStatus() { } 
  20. // 端口号OK
  21. void PrimaryForm_PortNumberReady(int portNumber) {         
  22.         PortNumberReadyEventHandler del = delegate(int port) { 
  23.             lbPort.Text = port.ToString(); 
  24.         }; 
  25.         lbPort.Invoke(del, portNumber); 
  26.     } 
  27. // 接收到消息
  28. void talker_MessageReceived(string msg) { 
  29.         MessageReceivedEventHandler del = delegate(string m) { 
  30.             txtContent.Text += m; 
  31.         }; 
  32.         txtContent.Invoke(del, msg); 
  33.     } 
  34. // 有客户端连接到本机
  35. void talker_ClientConnected(IPEndPoint endPoint) { 
  36.         ClientConnectedEventHandler del = delegate(IPEndPoint end) { 
  37.             IPHostEntry host = Dns.GetHostEntry(end.Address); 
  38.             txtContent.Text += 
  39.                 String.Format("System[{0}]：\r\n远程主机{1}连接至本地。\r\n", DateTime.Now, end); 
  40.         }; 
  41.         txtContent.Invoke(del, endPoint); 
  42.     } 
  43. // 客户端连接断开
  44. void talker_ClientLost(string info) { 
  45.         ConnectionLostEventHandler del = delegate(string information) { 
  46.             txtContent.Text += 
  47.                 String.Format("System[{0}]：\r\n{1}\r\n", DateTime.Now, information); 
  48.         }; 
  49.         txtContent.Invoke(del, info); 
  50.     } 
  51. // 发送消息
  52. private void btnSend_Click(object sender, EventArgs e) { 
  53. if (String.IsNullOrEmpty(txtMessage.Text)) { 
  54.             MessageBox.Show("请输入内容！"); 
  55.             txtMessage.Clear(); 
  56.             txtMessage.Focus(); 
  57. return; 
  58.         } 
  59.         Message msg = new Message(userName, txtMessage.Text); 
  60. if (talker.SendMessage(msg)) { 
  61.             txtContent.Text += msg.ToString(); 
  62.             txtMessage.Clear(); 
  63.         } else { 
  64.             txtContent.Text += 
  65.                 String.Format("System[{0}]：\r\n远程主机已断开连接\r\n", DateTime.Now); 
  66.             DisconnectStatus(); 
  67.         } 
  68.     } 
  69. // 点击连接
  70. private void btnConnect_Click(object sender, EventArgs e) { 
  71. string host = txtHost.Text; 
  72. string ip = txtHost.Text; 
  73. int port; 
  74. if (String.IsNullOrEmpty(txtHost.Text)) { 
  75.             MessageBox.Show("主机名称或地址不能为空"); 
  76.         }           
  77. try{ 
  78.             port = Convert.ToInt32(txtPort.Text); 
  79.         }catch{ 
  80.             MessageBox.Show("端口号不能为空，且必须为数字"); 
  81. return; 
  82.         } 
  83. if (talker.ConnectByHost(host, port)) { 
  84.             ConnectStatus(); 
  85.             txtContent.Text += 
  86.                 String.Format("System[{0}]：\r\n已成功连接至远程\r\n", DateTime.Now); 
  87. return; 
  88.         } 
  89. if(talker.ConnectByIp(ip, port)){ 
  90.             ConnectStatus(); 
  91.             txtContent.Text += 
  92.                 String.Format("System[{0}]：\r\n已成功连接至远程\r\n", DateTime.Now); 
  93.         }else{ 
  94.             MessageBox.Show("远程主机不存在，或者拒绝连接！"); 
  95.         }           
  96.         txtMessage.Focus(); 
  97.     } 
  98. // 关闭按钮点按
  99. private void btnClose_Click(object sender, EventArgs e) { 
  100. try { 
  101.             talker.Dispose(); 
  102.             Application.Exit(); 
  103.         } catch { 
  104.         } 
  105.     } 
  106. // 直接点击右上角的叉
  107. private void PrimaryForm_FormClosing(object sender, FormClosingEventArgs e) { 
  108. try { 
  109.             talker.Dispose(); 
  110.             Application.Exit(); 
  111.         } catch { 
  112.         } 
  113.     } 
  114. // 点击注销
  115. private void btnSignout_Click(object sender, EventArgs e) { 
  116.         talker.SignOut(); 
  117.         DisconnectStatus(); 
  118.         txtContent.Text += 
  119.             String.Format("System[{0}]：\r\n已经注销\r\n",DateTime.Now); 
  120.     } 
  122. private void btnClear_Click(object sender, EventArgs e) { 
  123.         txtContent.Clear(); 
  124.     } 
  125. } 

在上面代码中，分别通过四个方法订阅了四个事件，以实现自动通知的机制。最后需要注意的就是SignOut()和Dispose()的区分。SignOut()只是断开连接，Dispose()则是离开应用程序。

总结

这篇文章简单地分析、设计及实现了一个聊天程序。这个程序只是对无服务器模式实现聊天的一个尝试。我们分析了需求，随后编写了几个用例，并对本地、远程的概念做了定义，接着编写了程序接口并最终实现了它。这个程序还有很严重的不足：它无法实现自动上线通知，而必须要事先知道端口号并进行手动连接。为了实现一个功能强大且开发容易的程序，更好的办法是使用集中型服务器模式。

感谢阅读，希望这篇文章能对你有所帮助。

编写程序代码

如果你已经看完了上面一节C#网络编程，那么本章完全没有讲解的必要了，所以我只列出代码，对个别值得注意的地方稍微地讲述一下。首先需要了解的就是，我们采用的是三个模式中开发起来难度较大的一种，无服务器参与的模式。还有就是我们没有使用广播消息，所以需要提前知道连接到的远程主机的地址和端口号。

1.实现IMessageSender接口

  1. public class MessageSender : IMessageSender { 
  2.     TcpClient client; 
  3.     Stream streamToServer; 
  4. // 连接至远程
  5. public bool Connect(IPAddress ip, int port) { 
  6. try { 
  7.             client = new TcpClient(); 
  8.             client.Connect(ip, port); 
  9.             streamToServer = client.GetStream();    // 获取连接至远程的流
  10. return true; 
  11.         } catch { 
  12. return false; 
  13.         } 
  14.     } 
  15. // 发送消息
  16. public bool SendMessage(Message msg) { 
  17. try { 
  18. lock (streamToServer) { 
  19. byte[] buffer = Encoding.Unicode.GetBytes(msg.ToString()); 
  20.                 streamToServer.Write(buffer, 0, buffer.Length); 
  21. return true; 
  22.             } 
  23.         } catch { 
  24. return false; 
  25.         } 
  26.     } 
  27. // 注销
  28. public void SignOut() { 
  29. if (streamToServer != null) 
  30.             streamToServer.Dispose(); 
  31. if (client != null) 
  32.             client.Close(); 
  33.     } 
  34. } 

这段代码可以用朴实无华来形容，所以我们直接看下一段。

2.实现IMessageReceiver接口

  1. public delegate void PortNumberReadyEventHandler(int portNumber); 
  2. public class MessageReceiver : IMessageReceiver { 
  3. public event MessageReceivedEventHandler MessageReceived; 
  4. public event ConnectionLostEventHandler ClientLost; 
  5. public event ClientConnectedEventHandler ClientConnected; 
  6. // 当端口号Ok的时候调用 -- 需要告诉用户界面使用了哪个端口号在侦听
  7. // 这里是业务上体现不出来，在实现中才能体现出来的
  8. public event PortNumberReadyEventHandler PortNumberReady; 
  9. private Thread workerThread; 
  10. private TcpListener listener; 
  11. public MessageReceiver() { 
  12.         ((IMessageReceiver)this).StartListen(); 
  13.     } 
  14. // 开始侦听：显示实现接口
  15. void IMessageReceiver.StartListen() { 
  16.         ThreadStart start = new ThreadStart(ListenThreadMethod); 
  17.         workerThread = new Thread(start); 
  18.         workerThread.IsBackground = true; 
  19.         workerThread.Start(); 
  20.     } 
  21. // 线程入口方法
  22. private void ListenThreadMethod() { 
  23.         IPAddress localIp = IPAddress.Parse("127.0.0.1"); 
  24.         listener = new TcpListener(localIp, 0); 
  25.         listener.Start(); 
  26. // 获取端口号
  27.         IPEndPoint endPoint = listener.LocalEndpoint as IPEndPoint; 
  28. int portNumber = endPoint.Port; 
  29. if (PortNumberReady != null) { 
  30.             PortNumberReady(portNumber);        // 端口号已经OK，通知用户界面
  31.         } 
  32. while (true) { 
  33.             TcpClient remoteClient; 
  34. try { 
  35.                 remoteClient = listener.AcceptTcpClient(); 
  36.             } catch { 
  37. break; 
  38.             } 
  39. if (ClientConnected != null) { 
  40. // 连接至本机的远程端口
  41.                 endPoint = remoteClient.Client.RemoteEndPoint as IPEndPoint; 
  42.                 ClientConnected(endPoint);      // 通知用户界面远程客户连接
  43.             } 
  44.             Stream streamToClient = remoteClient.GetStream(); 
  45. byte[] buffer = new byte[8192]; 
  46. while (true) { 
  47. try { 
  48. int bytesRead = streamToClient.Read(buffer, 0, 8192); 
  49. if (bytesRead == 0) { 
  50. throw new Exception("客户端已断开连接"); 
  51.                     } 
  52. string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead); 
  53. if (MessageReceived != null) { 
  54.                         MessageReceived(msg);       // 已经收到消息
  55.                     } 
  56.                 } catch (Exception ex) { 
  57. if (ClientLost != null) { 
  58.                         ClientLost(ex.Message);     // 客户连接丢失
  59. break;                      // 退出循环
  60.                     } 
  61.                 } 
  62.             } 
  63.         } 
  64.     } 
  65. // 停止侦听端口
  66. public void StopListen() { 
  67. try { 
  68.             listener.Stop(); 
  69.             listener = null; 
  70.             workerThread.Abort(); 
  71.         } catch { } 
  72.     } 
  73. } 

这里需要注意的有这样几点：我们StartListen()为显式实现接口，因为只能通过接口才能调用此方法，接口的实现类看不到此方法；这通常是对于一个接口采用两种实现方式时使用的，但这里我只是不希望MessageReceiver类型的客户调用它，因为在MessageReceiver的构造函数中它已经调用了StartListen。意思是说，我们希望这个类型一旦创建，就立即开始工作。我们使用了两个嵌套的while循环，这个它可以为多个客户端的多次请求服务，但是因为是同步操作，只要有一个客户端连接着，我们的后台线程就会陷入第二个循环中无法自拔。所以结果是：如果有一个客户端已经连接上了，其它客户端即使连接了也无法对它应答。最后需要注意的就是四个事件的使用，为了向用户提供侦听的端口号以进行连接，我又定义了一个PortNumberReadyEventHandler委托。

3.实现Talker类

Talker类是最平庸的一个类，它的全部功能就是将操作委托给实际的IMessageReceiver和IMessageSender。定义这两个接口的好处也从这里可以看出来：如果日后想重新实现这个程序，所有Windows窗体的代码和Talker的代码都不需要修改，只需要针对这两个接口编程就可以了。

  1. public class Talker { 
  2. private IMessageReceiver receiver; 
  3. private IMessageSender sender; 
  4. public Talker(IMessageReceiver receiver, IMessageSender sender) { 
  5. this.receiver = receiver; 
  6. this.sender = sender; 
  7.     } 
  8. public Talker() { 
  9. this.receiver = new MessageReceiver(); 
  10. this.sender = new MessageSender(); 
  11.     } 
  12. public event MessageReceivedEventHandler MessageReceived { 
  13.         add { 
  14.             receiver.MessageReceived += value; 
  15.         } 
  16.         remove { 
  17.             receiver.MessageReceived -= value; 
  18.         } 
  19.     } 
  20. public event ClientConnectedEventHandler ClientConnected { 
  21.         add { 
  22.             receiver.ClientConnected += value; 
  23.         } 
  24.         remove { 
  25.             receiver.ClientConnected -= value; 
  26.         } 
  27.     } 
  28. public event ConnectionLostEventHandler ClientLost { 
  29.         add { 
  30.             receiver.ClientLost += value; 
  31.         } 
  32.         remove { 
  33.             receiver.ClientLost -= value; 
  34.         } 
  35.     } 
  36. // 注意这个事件
  37. public event PortNumberReadyEventHandler PortNumberReady { 
  38.         add { 
  39.             ((MessageReceiver)receiver).PortNumberReady += value; 
  40.         } 
  41.         remove { 
  42.             ((MessageReceiver)receiver).PortNumberReady -= value; 
  43.         } 
  44.     } 
  45. // 连接远程 - 使用主机名
  46. public bool ConnectByHost(string hostName, int port) { 
  47.         IPAddress[] ips = Dns.GetHostAddresses(hostName); 
  48. return sender.Connect(ips[0], port); 
  49.     } 
  50. // 连接远程 - 使用IP
  51. public bool ConnectByIp(string ip, int port) { 
  52.         IPAddress ipAddress; 
  53. try { 
  54.             ipAddress = IPAddress.Parse(ip); 
  55.         } catch { 
  56. return false; 
  57.         } 
  58. return sender.Connect(ipAddress, port); 
  59.     } 
  60. // 发送消息
  61. public bool SendMessage(Message msg) { 
  62. return sender.SendMessage(msg); 
  63.     } 
  64. // 释放资源，停止侦听
  65. public void Dispose() { 
  66. try { 
  67.             sender.SignOut(); 
  68.             receiver.StopListen(); 
  69.         } catch { 
  70.         } 
  71.     } 
  72. // 注销
  73. public void SignOut() { 
  74. try { 
  75.             sender.SignOut(); 
  76.         } catch { 
  77.         } 
  78.     } 
  79. } 
posted @ 2010-07-24 13:28  大漠银狐  阅读(701)  评论(1)  编辑  收藏  举报