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

时间 2020-09-20

标签 c# 网络编程基本概念 part.1 栏目 C# 繁體版

原文原文链接

引言

C#网络编程系列文章计划简单地讲述网络编程方面的基础知识，因为本人在这方面功力有限，因此只能提供一些初步的入门知识，但愿能对刚开始学习的朋友提供一些帮助。若是想要更加深刻的内容，能够参考相关书籍。html

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

与本文相关的还有一篇文章是：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就是端口。将端口分配给一个应用程序，那么来自这个端口的数据则老是针对这个应用程序的。有这样一个很好的例子：能够将主机地址想象为电话号码，而将端口号想象为分机号。post

在.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

从这里咱们能够得出几个重要信息：一、端口8500和端口4761创建了链接，这个4761端口即是客户端用来与服务端进行通讯的端口；二、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()方法。为了让它继续执行下去，必须有一个客户端链接到它，因此咱们如今运行客户端，与它进行链接。简单起见，咱们只在客户端开启一个端口与之链接：

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

// 服务端
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

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

出处：http://www.cnblogs.com/JimmyZhang/archive/2008/09/07/1286300.html