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

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

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\乙\甲乙丙丁\" }; 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: 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 78 25 78 1 78 Retrived: 甲乙丙丁

大体上可以得出这么几个结论：

 

ASCII不能保存中文(貌似谁都知道=_-`)。

UTF8是变长编码。在对ASCII字符编码时，UTF更省空间，只占1个字节，与ASCII编码方式和长度相同；Unicode在对ASCII字符编码时，占用2个字节，且第2个字节补零。

 UTF8在对中文编码时需要占用3个字节；Unicode对中文编码则只需要2个字节。

C#网络编程(异步传输字符串) - Part.3

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

消息发送时的问题

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

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

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

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

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

string msg = \"Welcome to TraceFact.Net!\";

for (int i = 0; i <= 2; i++) {

byte[] buffer = Encoding.Unicode.GetBytes(msg); // 获得缓存 try {

streamToServer.Write(buffer, 0, buffer.Length); // 发往服务器 Console.WriteLine(\"Sent: {0}\", msg); } catch (Exception ex) {

Console.WriteLine(ex.Message); break; } }

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

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

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

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

 “[“”]”中括号是完整的，可以读取到length的字节数。然后根据这个数值与后面的字符串长度相比，如果相等，则说明发来了一条完整信

息；如果多了，那么说明接收的字节数多了，取出合适的长度，并将剩余的进行缓存；如果少了，说明接收的不够，那么将收到的进行一个缓存，等待下次请求，然后将两条合并。



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

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

public class RequestHandler {

private string temp = string.Empty;

public string[] GetActualString(string input) { return GetActualString(input, null); }

private string[] GetActualString(string input, List outputList) {

if (outputList == null)

outputList = new List();

if (!String.IsNullOrEmpty(temp)) input = temp + input;

string output = \"\";

string pattern = @\"(?<=^\\[length=)(\\d+)(?=\\])\"; int length;

if (Regex.IsMatch(input, pattern)) {

Match m = Regex.Match(input, pattern);

// 获取消息字符串实际应有的长度

length = Convert.ToInt32(m.Groups[0].Value);

// 获取需要进行截取的位置

int startIndex = input.IndexOf(']') + 1;

// 获取从此位置开始后所有字符的长度 output = input.Substring(startIndex);

if (output.Length == length) {

// 如果output的长度与消息字符串的应有长度相等 // 说明刚好是完整的一条信息 outputList.Add(output); temp = \"\";

} else if (output.Length < length) { // 如果之后的长度小于应有的长度，

// 说明没有发完整，则应将整条信息，包括元数据，全部缓存 // 与下一条数据合并起来再进行处理 temp = input;

// 此时程序应该退出，因为需要等待下一条数据到来才能继续处理

} else if (output.Length > length) { // 如果之后的长度大于应有的长度， // 说明消息发完整了，但是有多余的数据

// 多余的数据可能是截断消息，也可能是多条完整消息

// 截取字符串

output = output.Substring(0, length); outputList.Add(output); temp = \"\";

// 缩短input的长度

input = input.Substring(startIndex + length);

// 递归调用

GetActualString(input, outputList); }

} else { // 说明“[”，“]”就不完整 temp = input; }

return outputList.ToArray(); } }

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

public static void Test() {

RequestHandler handler = new RequestHandler(); string input;

// 第一种情况测试 - 一条消息完整发送

input = \"[length=13]明天中秋，祝大家节日快乐！\"; handler.PrintOutput(input);

// 第二种情况测试 - 两条完整消息一次发送 input = \"明天中秋，祝大家节日快乐！\"; input = String.Format

(\"[length=13]{0}[length=13]{0}\", input); handler.PrintOutput(input);

// 第三种情况测试A - 两条消息不完整发送

input = \"[length=13]明天中秋，祝大家节日快乐！[length=13]明天中秋\"; handler.PrintOutput(input);

input = \"，祝大家节日快乐！\"; handler.PrintOutput(input);

// 第三种情况测试B - 两条消息不完整发送 input = \"[length=13]明天中秋，祝大家\"; handler.PrintOutput(input);

input = \"节日快乐！[length=13]明天中秋，祝大家节日快乐！\"; handler.PrintOutput(input);

// 第四种情况测试 - 元数据不完整 input = \"[leng\";

handler.PrintOutput(input); // 不会有输出

input = \"th=13]明天中秋，祝大家节日快乐！\"; handler.PrintOutput(input); }

// 用于测试输出

private void PrintOutput(string input) { Console.WriteLine(input);

string[] outputArray = GetActualString(input); foreach (string output in outputArray) { Console.WriteLine(output); }

Console.WriteLine(); }

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

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