【转】C# Socket编程(4)初识Socket和数据流

【转自：https://www.cnblogs.com/IPrograming/archive/2012/10/15/CSharp_Socket_4.html】　

经过前面基础知识作为背景，现在对Socket编程进行进一步的学习。在 System.Net.Socket 命名空间提供了Socket类，利用该类我们可以直接编写Socket的客户端和服务的的程序。但是直接使用Socket类编写Socket程序会比较麻烦、而且容易出错，所以.NET为我们提供了进一步封装好的TcpListener类、TCPClient类和UdpClient类。同时，当我们希望通过网络传输数据时，首先应该将数据转换为数据流。

1.Socket的类型

　　Socket的中文释义称为套接字，是支撑TCP/IP通信最基本的操作单元。可以将Socket看做不同主机之间的进程进行双向通信的端点，在一个双方都可以通信的Socket实例中，既保存了对方的IP地址和端口，也保持了双方通信采用的协议等信息。Socket有三种不同的类型：

• ①.流套接字：实现面向连接的TCP通信
• ②.数据报套接字：实现无连接的UDP通信
• ③.原始套接字：实现IP数据包的通信(这里不做讨论)

 三种类型的套接字的对象均可使用Socket类来构造：

/// <summary>
        /// Socket 构造函数
        /// </summary>
        /// <param name="addressFamily">网络类型</param>
        /// <param name="socketType">Socket类型</param>
        /// <param name="protocolType">Socket使用的协议</param>
        public Socket(AddressFamily addressFamily,SocketType socketType,ProtocolType protocolType)

当我们编写基于TCP和UDP的应用程序时，既可以使用对套接字进行进一步封装的TcpListener类、TCPClient类和UdpClient类，也可以直接使用Socket类来实现，如果没有特殊需求应该使用进一步封装过的类，由于Socket类是他们实现的基础，所有在这里我们先从学习Socket类入手。

2.第一个Socket程序

 　　在C# Socket编程(1)基本的术语和概念这篇博客中我们知道：IP协议层之上是传输层(transport layer),它提供了两种可选的协议:TCP协议和UDP协议，它们分别是面向连接和无连接的两种协议。在面向连接的Socket中，使用TCP来建立两个地址端点的会话。一旦建立这种连接，就可以在设备之间进行可靠的数据传输。在进行跟深入的学习前我们先巩固一个简单的例子(TCP)来对Socket编程建立一个直观的印象。　　

　　TCP Socket连接的过程可以简单的分为：①.服务端监听 ②.客户端请求 ③.建立连接。在使用面向连接的Socket进行通信之前，两个应用程序之间首先要建立一个TCP连接，这涉及两台相互通信的主机的TCP部件间完成的握手消息(handshake message)的交换。下面我们通过直接使用Socket类来构建一个简单的Socket应用程序(这里先从同步Socket入手，实际项目要比这复杂，有许多需要考虑的问题：如消息边界问题、端口号是否冲突、消息命令的解析等等)。在这里我们为了和每一个客户端进行通信建立两个线程：一个是接受客户端连接的线程，一个是接受客户端数据的线程，下面是分别是示例程序的服务端和客户端的代码：

2.1 服务器端代码：

private static byte[] m_DataBuffer = new byte[1024];
        //设置端口号
        private static int m_Port = 8099;
        static Socket serverSocket;
        static void Main(string[] args)
        {
            //为了方便在本机上同时运行Client和server，使用回环地址为服务的监听地址
            IPAddress ip = IPAddress.Loopback;
            //实例化一个Socket对象，确定网络类型、Socket类型、协议类型
            serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //Socket对象绑定IP和端口号
            serverSocket.Bind(new IPEndPoint(ip, m_Port));
            //挂起连接队列的最大长度为15，启动监听
            serverSocket.Listen(15);

            Console.WriteLine("启动监听{0}成功", serverSocket.LocalEndPoint.ToString());
            //一个客户端连接服务器时创建一个新的线程
            Thread myThread = new Thread(ListenClientConnect);
            myThread.Start();
        }

        /// <summary>
        /// 接收连接
        /// </summary>
        private static void ListenClientConnect()
        {
            while (true)
            {
                //运行到Accept()方法是会阻塞程序(同步Socket)，
                //收到客户端请求创建一个新的Socket Client对象继续执行
                Socket clientSocket = serverSocket.Accept();
                clientSocket.Send(Encoding.UTF8.GetBytes("Server说：Client 你好！"));
                //创建一个接受客户端发送消息的线程
                Thread reciveThread = new Thread(ReciveMessage);
                reciveThread.Start(clientSocket);
            }
        }
          
        /// <summary>
        /// 接收信息
        /// </summary>
        /// <param name="clientSocket">包含客户端信息的套接字</param>
        private static void ReciveMessage(Object clientSocket)
        {
            if (clientSocket != null)
            {
                Socket m_ClientSocket = clientSocket as Socket;
                while (true)
                {
                    try
                    {
                        //通过clientSocket接收数据
                        int reciverNumber = m_ClientSocket.Receive(m_DataBuffer);
                        Console.WriteLine("接收客户端：{0}消息：{1}", m_ClientSocket.RemoteEndPoint.ToString(), Encoding.UTF8.GetString(m_DataBuffer, 0, reciverNumber));
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                        m_ClientSocket.Shutdown(SocketShutdown.Both);
                        m_ClientSocket.Close();
                        break;
                    }
                }
            }
        }
    }

 2.2 客户端代码： 

//创建一个数据缓冲区
        private static byte[] m_DataBuffer = new byte[1024];
        static void Main(string[] args)
        {
            IPAddress ip = IPAddress.Loopback;
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                clientSocket.Connect(new IPEndPoint(ip, 8099));
                Console.WriteLine("连接服务器成功");
            }
            catch (Exception ex)
            {
                Console.WriteLine("连接服务器失败，按回车键退出");
                Console.WriteLine(ex.Message);
                return;
            }
            //通过clientSocket接收数据
            int receiveLength = clientSocket.Receive(m_DataBuffer);
            Console.WriteLine("接受服务器消息：{0}", Encoding.UTF8.GetString(m_DataBuffer, 0, receiveLength));
            //通过clientSocket发送数据
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    Thread.Sleep(1000);
                    string sendMessage = string.Format("{0} {1}", "Server 你好！", DateTime.Now.ToString());
                    clientSocket.Send(Encoding.UTF8.GetBytes(sendMessage));
                    Console.WriteLine("向服务器发送消息：{0}", sendMessage);
                }
                catch
                {
                    clientSocket.Shutdown(SocketShutdown.Both);
                    clientSocket.Close();
                    break;
                }
            }
            Console.WriteLine("发送完毕，按回车键退出");
            Console.Read();
        }
    }

2.3 运行示例程序

 首先运行服务端程序：

　　

接着运行客户端程序，向服务端发送消息后

　　

这时候我们可以看到服务端已经收到了客户端发送的消息

　　

 

3.网络流和内存流

　　通过网络传输数据，或者对文件数据进行操作的时候都需要先将数据转换为数据流。典型的数据流是和某个外部数据源相关，数据源可以是文件、外部设备、内存、网络套接字等。.NET提供多个从Stream类派生的子类来对不同的数据源提供支持，每个类都代表了一种具体的数据流类型。例如和磁盘文件相关的文件流FileStream和Socket相关的NetworkStream，和内存相关的MemoryStream等，在Socket编程中我们只需了解NetworkStream和MemoryStream(具体文件IO可以参考博文：.NET I/O 学习笔记：文件的读和写)，一个用来网络数据的传输，另一个用作数据缓冲区。

3.1 网络流(NetworkStream)

　　数据在网络的各个位置之间是以连续的字节形式传输的，我们使用NetworkStream类来发送和接收网络数据。和其他的的流类型不同NetworkStream 类是在System.Net.Sockets 命名空间中的，该类实现专门用于网络资源的 Stream 类。NetworkStream 选件类和其他流之间的主要差异在于NetworkStream 没有当前位置的概念，因此不支持查找功能，并且NetworkStream仅支持面向连接(TCP)的Socket。

　　对于NetworkStream来说，写入操作是指将数据源内存缓冲区到网络上的数据传输；读取操作是从网络上到接收端内存缓冲区的数据传输。

创建NetworkStream对象

　　我们可以通过TcpClient对象的GetStream()方法获取该对象发送和接收数据的 NetworkStream 对象：

 

TcpClient client = new TcpClient();
client.Connect("www.baidu.com", 8099);
NetworkStream nStream = client.GetStream();

 

 　　也可以通过使用Socket来获取 NetworkStream 对象：

NetworkStream myNetworkStream = new NetworkStream(mySocket);   

通过NetworkStream对象获取数据

　　接收数据端通过调用Read方法将数据从接收缓冲区中读取到进程缓冲区中，完成读取操作。可以通过调用DataAvailable属性来确定是否还有数据可供读取，如下：

 

TcpClient client = new TcpClient();
            client.Connect("www.baidu.com", 8099);
            NetworkStream nStream = client.GetStream();
            //是否有数据可读
            if (nStream.CanRead)
            {
                //接受数据的缓冲区
                byte[] myReadBuffer = new byte[1024];
                StringBuilder completeMessage = new StringBuilder();
                int numberOfBytesRead = 0;
                //准备接收的信息也有可能大于1024所以使用循环
                do
                {
                    numberOfBytesRead = nStream.Read(myReadBuffer,0,myReadBuffer.Length);
                    completeMessage.AppendFormat("{0}",Encoding.UTF8.GetString(myReadBuffer,0,numberOfBytesRead);
                }while(nStream.DataAvailable);
                Console.WriteLine("接受的信息为："+completeMessage);
            }
            else
            {
                Console.WriteLine("当前没有可供读取的数据。");
            }

 

3.2 内存流(MemoryStream)

 　　MemoryStream表示保存在内存中的数据流，有该类封装的数据可以直接在内存中访问。内存流一般用于暂时缓存数据以降低应用程序对临时缓冲区和临时文件的需要。内存流相对于字节数组容量可以自动增长，并且在需要对数据进行加密以及对数据长度不定的数据进行缓存时，使用内存流比较方便。MemoryStream支持对数据流的查找和随机访问，当该类对象的CanSeek属性值为True时，程序可以通过范围Position属性获取内存流当前的位置。下面我们通过一个简单的小示例学习如何具体使用内存流：

 

static void Main(string[] args)
        {
            //构造MemoryStream实例
            MemoryStream m_Stream = new MemoryStream();
            Console.WriteLine("初始化分配容量：{0}", m_Stream.Capacity);
            Console.WriteLine("初始使用量：{0}", m_Stream.Length);

            //将待写入数据从字符串转换为字节数组
            UnicodeEncoding encoder = new UnicodeEncoding();
            byte[] bytes = encoder.GetBytes("新增数据");

            //向内存流中写入数据
            for (int i = 0; i < 4; i++)
            {
                Console.WriteLine("第{0}写入新数据", i);
                m_Stream.Write(bytes, 0, bytes.Length);
            }

            //写入数据后MemoryStream实例的容量和使用量的大小
            Console.WriteLine("当前分配容量：{0}", m_Stream.Capacity);
            Console.WriteLine("当前使用量：{0}", m_Stream.Length);

            Console.Read();
        }