C#中Socket通信编程的同步实现



目录(?) [+]

1. Socket编程基础
2. 什么是Socket编程的同步实现
3. 如何实现Socket同步通信
   1. 服务端
      1. 基本流程
   2. 客户端
      1. 基本流程
      2. 代码示例
      3. 同样地我们现在来运行客户端程序这样客户端就可以和服务端进行通信了
4. 总结

本文通过分析和总结C#中Socket通信编程的关键技术，按照同步实现的方式实现了一个简单的Socket聊天程序，目的是通过这个程序来掌握Socket编程，为进一步开发Unity3D网络游戏打下一个坚实的基础。

Socket编程基础

关于Socket编程基础部分的内容，主要是了解和掌握.NET框架下为Socket编程提供的相关类和接口方法。.NET中常见的网络相关的API都集中在System.NET和System.NET.Socket这两个命名空间下，大家可以通过MSDN去了解这两个命名空间下相关的类和方法。这里援引一位朋友总结的一篇文章http://www.cnblogs.com/sunev/archive/2012/08/05/2604189.html，大家可以从这里获得更为直观的认识。

什么是Socket编程的同步实现

本文的目的是按照同步实现的方式来实现一个简单的Socket聊天程序，因此在解决这个问题前，我们首先来看看什么是Socket编程的同步实现。所谓Socket编程的同步实现就是指按照同步过程的方法来实现Socket通信。从编程来说，我们常用的方法或者函数都是同步过程。因为当我们调用一个方法或者函数的时候我们能够立即得到它的返回值。可是我们知道在Socket通信中，我们不能保证时时刻刻连接都通畅、更不能够保证时时刻刻都有数据收发，因为我们就需要不断去读取相应的值来确定整个过程的状态。这就是Socket编程的同步实现了，下面我们来看具体的实现过程。

如何实现Socket同步通信

服务端

服务端的主要职责是处理各个客户端发送来的数据，因此在客户端的Socket编程中需要使用两个线程来循环处理客户端的请求，一个线程用于监听客户端的连接情况，一个线程用于监听客户端的消息发送，当服务端接收到客户端的消息后需要将消息处理后再分发给各个客户端。

基本流程

• 创建套接字
• 绑定套接字的IP和端口号——Bind()
• 将套接字处于监听状态等待客户端的连接请求——Listen()
• 当请求到来后，接受请求并返回本次会话的套接字——Accept()
• 使用返回的套接字和客户端通信——Send()/Receive()
• 返回，再次等待新的连接请求
• 关闭套接字

代码示例

[csharp] view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4. using System.Net;  
5. using System.Net.Sockets;  
6. using System.Threading;  
7.   
8. namespace TCPLib  
9. {  
10.     public class TCPServer  
11.     {  
12.         private byte[] result = new byte[1024];  
13.         /// <summary>  
14.         /// 最大的监听数量  
15.         /// </summary>  
16.         private int maxClientCount;  
17.         public int MaxClientCount  
18.         {  
19.             get { return maxClientCount; }  
20.             set { maxClientCount = value; }  
21.         }  
22.   
23.         /// <summary>  
24.         /// IP地址  
25.         /// </summary>  
26.         private string ip;  
27.         public string IP  
28.         {  
29.             get { return ip; }  
30.             set { ip = value; }  
31.         }  
32.   
33.         /// <summary>  
34.         /// 端口号  
35.         /// </summary>  
36.         private int port;  
37.         public int Port  
38.         {  
39.             get { return port; }  
40.             set { port = value; }  
41.         }  
42.   
43.         /// <summary>  
44.         /// 客户端列表  
45.         /// </summary>  
46.         private List<Socket> mClientSockets;  
47.         public List<Socket> ClientSockets  
48.         {  
49.             get { return mClientSockets; }  
50.         }  
51.   
52.         /// <summary>  
53.         /// IP终端  
54.         /// </summary>  
55.         private IPEndPoint ipEndPoint;  
56.   
57.         /// <summary>  
58.         /// 服务端Socket  
59.         /// </summary>  
60.         private Socket mServerSocket;  
61.   
62.         /// <summary>  
63.         /// 当前客户端Socket  
64.         /// </summary>  
65.         private Socket mClientSocket;  
66.         public Socket ClientSocket   
67.         {  
68.             get { return mClientSocket;  }  
69.             set { mClientSocket = value; }  
70.         }  
71.   
72.         /// <summary>  
73.         /// 构造函数  
74.         /// </summary>  
75.         /// <param name="port">端口号</param>  
76.         /// <param name="count">监听的最大树目</param>  
77.         public TCPServer(int port, int count)  
78.         {  
79.             this.ip = IPAddress.Any.ToString();  
80.             this.port = port;  
81.             this.maxClientCount=count;  
82.   
83.             this.mClientSockets = new List<Socket>();  
84.   
85.             //初始化IP终端  
86.             this.ipEndPoint = new IPEndPoint(IPAddress.Any, port);  
87.             //初始化服务端Socket  
88.             this.mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
89.             //端口绑定  
90.             this.mServerSocket.Bind(this.ipEndPoint);  
91.             //设置监听数目  
92.             this.mServerSocket.Listen(maxClientCount);  
93.         }  
94.   
95.         /// <summary>  
96.         /// 构造函数  
97.         /// </summary>  
98.         /// <param name="ip">ip地址</param>  
99.         /// <param name="port">端口号</param>  
100.         /// <param name="count">监听的最大数目</param>  
101.         public TCPServer(string ip,int port,int count)  
102.         {  
103.             this.ip = ip;  
104.             this.port = port;  
105.             this.maxClientCount = count;  
106.   
107.             this.mClientSockets = new List<Socket>();  
108.   
109.             //初始化IP终端  
110.             this.ipEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);  
111.             //初始化服务端Socket  
112.             this.mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
113.             //端口绑定  
114.             this.mServerSocket.Bind(this.ipEndPoint);  
115.             //设置监听数目  
116.             this.mServerSocket.Listen(maxClientCount);  
117.   
118.         }  
119.   
120.         /// <summary>  
121.         /// 定义一个Start方法将构造函数中的方法分离出来  
122.         /// </summary>  
123.         public void Start()  
124.         {  
125.             //创建服务端线程，实现客户端连接请求的循环监听  
126.             var mServerThread = new Thread(this.ListenClientConnect);  
127.             //服务端线程开启  
128.             mServerThread.Start();  
129.         }  
130.   
131.         /// <summary>  
132.         /// 监听客户端链接  
133.         /// </summary>  
134.         private void ListenClientConnect()  
135.         {  
136.             //设置循环标志位  
137.             bool flag = true;  
138.             while (flag)  
139.             {  
140.                 //获取连接到服务端的客户端  
141.                 this.ClientSocket = this.mServerSocket.Accept();  
142.                 //将获取到的客户端添加到客户端列表  
143.                 this.mClientSockets.Add(this.ClientSocket);  
144.                 //向客户端发送一条消息  
145.                 this.SendMessage(string.Format("客户端{0}已成功连接到服务器", this.ClientSocket.RemoteEndPoint));  
146.                 //创建客户端消息线程，实现客户端消息的循环监听  
147.                 var mReveiveThread = new Thread(this.ReceiveClient);  
148.                 //注意到ReceiveClient方法传入了一个参数  
149.                 //实际上这个参数就是此时连接到服务器的客户端  
150.                 //即ClientSocket  
151.                 mReveiveThread.Start(this.ClientSocket);  
152.             }  
153.         }  
154.   
155.         /// <summary>  
156.         /// 接收客户端消息的方法  
157.         /// </summary>  
158.         private void ReceiveClient(object obj)  
159.         {  
160.             //获取当前客户端  
161.             //因为每次发送消息的可能并不是同一个客户端，所以需要使用var来实例化一个新的对象  
162.             //可是我感觉这里用局部变量更好一点  
163.             var mClientSocket = (Socket)obj;  
164.             // 循环标志位  
165.             bool flag = true;  
166.             while (flag)  
167.             {  
168.                 try  
169.                 {  
170.                     //获取数据长度  
171.                     int receiveLength = mClientSocket.Receive(result);  
172.                     //获取客户端消息  
173.                     string clientMessage = Encoding.UTF8.GetString(result, 0, receiveLength);  
174.                     //服务端负责将客户端的消息分发给各个客户端  
175.                     this.SendMessage(string.Format("客户端{0}发来消息:{1}",mClientSocket.RemoteEndPoint,clientMessage));  
176.   
177.                 }  
178.                 catch (Exception e)  
179.                 {  
180.                     //从客户端列表中移除该客户端  
181.                     this.mClientSockets.Remove(mClientSocket);  
182.                     //向其它客户端告知该客户端下线  
183.                     this.SendMessage(string.Format("服务器发来消息:客户端{0}从服务器断开,断开原因:{1}",mClientSocket.RemoteEndPoint,e.Message));  
184.                     //断开连接  
185.                     mClientSocket.Shutdown(SocketShutdown.Both);  
186.                     mClientSocket.Close();  
187.                     break;  
188.                 }  
189.             }  
190.   
191.         }  
192.   
193.         /// <summary>  
194.         /// 向所有的客户端群发消息  
195.         /// </summary>  
196.         /// <param name="msg">message</param>  
197.         public void SendMessage(string msg)  
198.         {  
199.             //确保消息非空以及客户端列表非空  
200.             if (msg == string.Empty || this.mClientSockets.Count <= 0) return;  
201.             //向每一个客户端发送消息  
202.             foreach (Socket s in this.mClientSockets)  
203.             {  
204.                 (s as Socket).Send(Encoding.UTF8.GetBytes(msg));  
205.             }  
206.         }  
207.   
208.         /// <summary>  
209.         /// 向指定的客户端发送消息  
210.         /// </summary>  
211.         /// <param name="ip">ip</param>  
212.         /// <param name="port">port</param>  
213.         /// <param name="msg">message</param>  
214.         public void SendMessage(string ip,int port,string msg)  
215.         {  
216.             //构造出一个终端地址  
217.             IPEndPoint _IPEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);  
218.             //遍历所有客户端  
219.             foreach (Socket s in mClientSockets)  
220.             {  
221.                 if (_IPEndPoint == (IPEndPoint)s.RemoteEndPoint)  
222.                 {  
223.                     s.Send(Encoding.UTF8.GetBytes(msg));  
224.                 }  
225.             }  
226.         }  
227.     }  
228. }  

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace TCPLib
{
    public class TCPServer
    {
        private byte[] result = new byte[1024];
        /// <summary>
        /// 最大的监听数量
        /// </summary>
        private int maxClientCount;
        public int MaxClientCount
        {
            get { return maxClientCount; }
            set { maxClientCount = value; }
        }

        /// <summary>
        /// IP地址
        /// </summary>
        private string ip;
        public string IP
        {
            get { return ip; }
            set { ip = value; }
        }

        /// <summary>
        /// 端口号
        /// </summary>
        private int port;
        public int Port
        {
            get { return port; }
            set { port = value; }
        }

        /// <summary>
        /// 客户端列表
        /// </summary>
        private List<Socket> mClientSockets;
        public List<Socket> ClientSockets
        {
            get { return mClientSockets; }
        }

        /// <summary>
        /// IP终端
        /// </summary>
        private IPEndPoint ipEndPoint;

        /// <summary>
        /// 服务端Socket
        /// </summary>
        private Socket mServerSocket;

        /// <summary>
        /// 当前客户端Socket
        /// </summary>
        private Socket mClientSocket;
        public Socket ClientSocket 
        {
            get { return mClientSocket;  }
            set { mClientSocket = value; }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="port">端口号</param>
        /// <param name="count">监听的最大树目</param>
        public TCPServer(int port, int count)
        {
            this.ip = IPAddress.Any.ToString();
            this.port = port;
            this.maxClientCount=count;

            this.mClientSockets = new List<Socket>();

            //初始化IP终端
            this.ipEndPoint = new IPEndPoint(IPAddress.Any, port);
            //初始化服务端Socket
            this.mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //端口绑定
            this.mServerSocket.Bind(this.ipEndPoint);
            //设置监听数目
            this.mServerSocket.Listen(maxClientCount);
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="ip">ip地址</param>
        /// <param name="port">端口号</param>
        /// <param name="count">监听的最大数目</param>
        public TCPServer(string ip,int port,int count)
        {
            this.ip = ip;
            this.port = port;
            this.maxClientCount = count;

            this.mClientSockets = new List<Socket>();

            //初始化IP终端
            this.ipEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);
            //初始化服务端Socket
            this.mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //端口绑定
            this.mServerSocket.Bind(this.ipEndPoint);
            //设置监听数目
            this.mServerSocket.Listen(maxClientCount);

        }

        /// <summary>
        /// 定义一个Start方法将构造函数中的方法分离出来
        /// </summary>
        public void Start()
        {
            //创建服务端线程，实现客户端连接请求的循环监听
            var mServerThread = new Thread(this.ListenClientConnect);
            //服务端线程开启
            mServerThread.Start();
        }

        /// <summary>
        /// 监听客户端链接
        /// </summary>
        private void ListenClientConnect()
        {
            //设置循环标志位
            bool flag = true;
            while (flag)
            {
                //获取连接到服务端的客户端
                this.ClientSocket = this.mServerSocket.Accept();
                //将获取到的客户端添加到客户端列表
                this.mClientSockets.Add(this.ClientSocket);
                //向客户端发送一条消息
                this.SendMessage(string.Format("客户端{0}已成功连接到服务器", this.ClientSocket.RemoteEndPoint));
                //创建客户端消息线程，实现客户端消息的循环监听
                var mReveiveThread = new Thread(this.ReceiveClient);
                //注意到ReceiveClient方法传入了一个参数
                //实际上这个参数就是此时连接到服务器的客户端
                //即ClientSocket
                mReveiveThread.Start(this.ClientSocket);
            }
        }

        /// <summary>
        /// 接收客户端消息的方法
        /// </summary>
        private void ReceiveClient(object obj)
        {
            //获取当前客户端
            //因为每次发送消息的可能并不是同一个客户端，所以需要使用var来实例化一个新的对象
            //可是我感觉这里用局部变量更好一点
            var mClientSocket = (Socket)obj;
            // 循环标志位
            bool flag = true;
            while (flag)
            {
                try
                {
                    //获取数据长度
                    int receiveLength = mClientSocket.Receive(result);
                    //获取客户端消息
                    string clientMessage = Encoding.UTF8.GetString(result, 0, receiveLength);
                    //服务端负责将客户端的消息分发给各个客户端
                    this.SendMessage(string.Format("客户端{0}发来消息:{1}",mClientSocket.RemoteEndPoint,clientMessage));

                }
                catch (Exception e)
                {
                    //从客户端列表中移除该客户端
                    this.mClientSockets.Remove(mClientSocket);
                    //向其它客户端告知该客户端下线
                    this.SendMessage(string.Format("服务器发来消息:客户端{0}从服务器断开,断开原因:{1}",mClientSocket.RemoteEndPoint,e.Message));
                    //断开连接
                    mClientSocket.Shutdown(SocketShutdown.Both);
                    mClientSocket.Close();
                    break;
                }
            }

        }

        /// <summary>
        /// 向所有的客户端群发消息
        /// </summary>
        /// <param name="msg">message</param>
        public void SendMessage(string msg)
        {
            //确保消息非空以及客户端列表非空
            if (msg == string.Empty || this.mClientSockets.Count <= 0) return;
            //向每一个客户端发送消息
            foreach (Socket s in this.mClientSockets)
            {
                (s as Socket).Send(Encoding.UTF8.GetBytes(msg));
            }
        }

        /// <summary>
        /// 向指定的客户端发送消息
        /// </summary>
        /// <param name="ip">ip</param>
        /// <param name="port">port</param>
        /// <param name="msg">message</param>
        public void SendMessage(string ip,int port,string msg)
        {
            //构造出一个终端地址
            IPEndPoint _IPEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);
            //遍历所有客户端
            foreach (Socket s in mClientSockets)
            {
                if (_IPEndPoint == (IPEndPoint)s.RemoteEndPoint)
                {
                    s.Send(Encoding.UTF8.GetBytes(msg));
                }
            }
        }
    }
}

好了，现在我们已经编写好了一个具备接收和发送数据能力的服务端程序。现在我们来尝试让服务端运行起来：

[csharp] view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4. using TCPLib;  
5. using System.Net;  
6. using System.Net.Sockets;  
7.   
8. namespace TCPLib.Test  
9. {  
10.     class Program  
11.     {  
12.         static void Main(string[] args)  
13.         {  
14.             //指定IP和端口号及最大监听数目的方式  
15.             TCPLib.TCPServer s1 = new TCPServer("127.0.0.1", 6001, 10);  
16.             //指定端口号及最大监听数目的方式  
17.             TCPLib.TCPServer s2 = new TCPServer(6001, 10);  
18.   
19.             //执行Start方法  
20.             s1.Start();  
21.         }  
22.     }  
23. }  

using System;
using System.Collections.Generic;
using System.Text;
using TCPLib;
using System.Net;
using System.Net.Sockets;

namespace TCPLib.Test
{
    class Program
    {
        static void Main(string[] args)
        {
            //指定IP和端口号及最大监听数目的方式
            TCPLib.TCPServer s1 = new TCPServer("127.0.0.1", 6001, 10);
            //指定端口号及最大监听数目的方式
            TCPLib.TCPServer s2 = new TCPServer(6001, 10);

            //执行Start方法
            s1.Start();
        }
    }
}

现在我们来看看编写客户端Socket程序的基本流程

客户端

客户端相对于服务端来说任务要轻许多，因为客户端仅仅需要和服务端通信即可，可是因为在和服务器通信的过程中，需要时刻保持连接通畅，因此同样需要两个线程来分别处理连接情况的监听和消息发送的监听。

基本流程

• 创建套接字保证与服务器的端口一致
• 向服务器发出连接请求——Connect()
• 和服务器端进行通信——Send()/Receive()
• 关闭套接字

代码示例

[csharp] view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4. using System.Net;  
5. using System.Net.Sockets;  
6. using System.Threading;  
7.   
8. namespace TCPLib  
9. {  
10.     public class TCPClient  
11.     {  
12.         /// <summary>  
13.         /// 定义数据  
14.         /// </summary>  
15.         private byte[] result = new byte[1024];  
16.   
17.         /// <summary>  
18.         /// 客户端IP  
19.         /// </summary>  
20.         private string ip;  
21.         public string IP  
22.         {  
23.             get { return ip; }  
24.             set { ip = value; }  
25.         }  
26.   
27.         /// <summary>  
28.         /// 客户端端口号  
29.         /// </summary>  
30.         private int port;  
31.         public int Port  
32.         {  
33.             get { return port; }  
34.             set { port = value; }  
35.         }  
36.   
37.         /// <summary>  
38.         /// IP终端  
39.         /// </summary>  
40.         private IPEndPoint ipEndPoint;  
41.   
42.         /// <summary>  
43.         /// 客户端Socket  
44.         /// </summary>  
45.         private Socket mClientSocket;  
46.   
47.         /// <summary>  
48.         /// 是否连接到了服务器  
49.         /// 默认为flase  
50.         /// </summary>  
51.         private bool isConnected = false;  
52.   
53.         /// <summary>  
54.         /// 构造函数  
55.         /// </summary>  
56.         /// <param name="ip">IP地址</param>  
57.         /// <param name="port">端口号</param>  
58.         public TCPClient(string ip, int port)  
59.         {  
60.             this.ip=ip;  
61.             this.port=port;  
62.             //初始化IP终端  
63.             this.ipEndPoint = new IPEndPoint(IPAddress.Parse(this.ip), this.port);  
64.             //初始化客户端Socket  
65.             mClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
66.   
67.         }  
68.   
69.         public void Start()  
70.         {  
71.             //创建一个线程以不断连接服务器  
72.             var mConnectThread = new Thread(this.ConnectToServer);  
73.             //开启线程  
74.             mConnectThread.Start();  
75.         }  
76.   
77.         /// <summary>  
78.         /// 连接到服务器  
79.         /// </summary>  
80.         private void ConnectToServer()  
81.         {  
82.             //当没有连接到服务器时开始连接  
83.             while (!isConnected)  
84.             {  
85.                 try  
86.                 {  
87.                     //开始连接  
88.                     mClientSocket.Connect(this.ipEndPoint);  
89.                     this.isConnected = true;  
90.                 }  
91.                 catch (Exception e)  
92.                 {  
93.                     //输出Debug信息  
94.                     Console.WriteLine(string.Format("因为一个错误的发生，暂时无法连接到服务器，错误信息为:{0}",e.Message));  
95.                     this.isConnected = false;  
96.                 }  
97.   
98.                 //等待5秒钟后尝试再次连接  
99.                 Thread.Sleep(5000);  
100.                 Console.WriteLine("正在尝试重新连接...");  
101.             }  
102.   
103.             //连接成功后  
104.             Console.WriteLine("连接服务器成功，现在可以和服务器进行会话了");  
105.             //创建一个线程以监听数据接收  
106.             var mReceiveThread = new Thread(this.ReceiveMessage);  
107.             //开启线程  
108.             mReceiveThread.Start();  
109.         }  
110.   
111.         /// <summary>  
112.         /// 因为客户端只接受来自服务器的数据  
113.         /// 因此这个方法中不需要参数  
114.         /// </summary>  
115.         private void ReceiveMessage()  
116.         {  
117.             //设置循环标志位  
118.             bool flag = true;  
119.             while (flag)  
120.             {  
121.                 try  
122.                 {  
123.                     //获取数据长度  
124.                     int receiveLength = this.mClientSocket.Receive(result);  
125.                     //获取服务器消息  
126.                     string serverMessage = Encoding.UTF8.GetString(result, 0, receiveLength);  
127.                     //输出服务器消息  
128.                     Console.WriteLine(serverMessage);  
129.                 }  
130.                 catch (Exception e)  
131.                 {  
132.                     //停止消息接收  
133.                     flag = false;  
134.                     //断开服务器  
135.                     this.mClientSocket.Shutdown(SocketShutdown.Both);  
136.                     //关闭套接字  
137.                     this.mClientSocket.Close();  
138.   
139.                     //重新尝试连接服务器  
140.                     this.isConnected = false;  
141.                     ConnectToServer();  
142.                 }  
143.             }  
144.   
145.         }  
146.   
147.         /// <summary>  
148.         /// 发送消息  
149.         /// </summary>  
150.         /// <param name="msg">消息文本</param>  
151.         public void SendMessage(string msg)  
152.         {  
153.             if(msg==string.Empty || this.mClientSocket==null) return;  
154.   
155.             mClientSocket.Send(Encoding.UTF8.GetBytes(msg));  
156.         }  
157.     }  
158. }  

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace TCPLib
{
    public class TCPClient
    {
        /// <summary>
        /// 定义数据
        /// </summary>
        private byte[] result = new byte[1024];

        /// <summary>
        /// 客户端IP
        /// </summary>
        private string ip;
        public string IP
        {
            get { return ip; }
            set { ip = value; }
        }

        /// <summary>
        /// 客户端端口号
        /// </summary>
        private int port;
        public int Port
        {
            get { return port; }
            set { port = value; }
        }

        /// <summary>
        /// IP终端
        /// </summary>
        private IPEndPoint ipEndPoint;

        /// <summary>
        /// 客户端Socket
        /// </summary>
        private Socket mClientSocket;

        /// <summary>
        /// 是否连接到了服务器
        /// 默认为flase
        /// </summary>
        private bool isConnected = false;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="ip">IP地址</param>
        /// <param name="port">端口号</param>
        public TCPClient(string ip, int port)
        {
            this.ip=ip;
            this.port=port;
            //初始化IP终端
            this.ipEndPoint = new IPEndPoint(IPAddress.Parse(this.ip), this.port);
            //初始化客户端Socket
            mClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        }

        public void Start()
        {
            //创建一个线程以不断连接服务器
            var mConnectThread = new Thread(this.ConnectToServer);
            //开启线程
            mConnectThread.Start();
        }

        /// <summary>
        /// 连接到服务器
        /// </summary>
        private void ConnectToServer()
        {
            //当没有连接到服务器时开始连接
            while (!isConnected)
            {
                try
                {
                    //开始连接
                    mClientSocket.Connect(this.ipEndPoint);
                    this.isConnected = true;
                }
                catch (Exception e)
                {
                    //输出Debug信息
                    Console.WriteLine(string.Format("因为一个错误的发生，暂时无法连接到服务器，错误信息为:{0}",e.Message));
                    this.isConnected = false;
                }

                //等待5秒钟后尝试再次连接
                Thread.Sleep(5000);
                Console.WriteLine("正在尝试重新连接...");
            }

            //连接成功后
            Console.WriteLine("连接服务器成功，现在可以和服务器进行会话了");
            //创建一个线程以监听数据接收
            var mReceiveThread = new Thread(this.ReceiveMessage);
            //开启线程
            mReceiveThread.Start();
        }

        /// <summary>
        /// 因为客户端只接受来自服务器的数据
        /// 因此这个方法中不需要参数
        /// </summary>
        private void ReceiveMessage()
        {
            //设置循环标志位
            bool flag = true;
            while (flag)
            {
                try
                {
                    //获取数据长度
                    int receiveLength = this.mClientSocket.Receive(result);
                    //获取服务器消息
                    string serverMessage = Encoding.UTF8.GetString(result, 0, receiveLength);
                    //输出服务器消息
                    Console.WriteLine(serverMessage);
                }
                catch (Exception e)
                {
                    //停止消息接收
                    flag = false;
                    //断开服务器
                    this.mClientSocket.Shutdown(SocketShutdown.Both);
                    //关闭套接字
                    this.mClientSocket.Close();

                    //重新尝试连接服务器
                    this.isConnected = false;
                    ConnectToServer();
                }
            }

        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="msg">消息文本</param>
        public void SendMessage(string msg)
        {
            if(msg==string.Empty || this.mClientSocket==null) return;

            mClientSocket.Send(Encoding.UTF8.GetBytes(msg));
        }
    }
}

同样地，我们现在来运行客户端程序，这样客户端就可以和服务端进行通信了：

[csharp] view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4. using TCPLib;  
5. using System.Net;  
6. using System.Net.Sockets;  
7.   
8. namespace TCPLib.Test  
9. {  
10.     class Program  
11.     {  
12.         static void Main(string[] args)  
13.         {  
14.             //保证端口号和服务端一致  
15.             TCPLib.TCPClient c = new TCPClient("127.0.0.1",6001);  
16.             //执行Start方法  
17.             c.Start();  
18.             while(true)  
19.             {  
20.                 //读取客户端输入的消息  
21.                 string msg = Console.ReadLine();  
22.                 //发送消息到服务端  
23.                 c.SendMessage(msg);  
24.             }  
25.         }  
26.     }  
27. }  

using System;
using System.Collections.Generic;
using System.Text;
using TCPLib;
using System.Net;
using System.Net.Sockets;

namespace TCPLib.Test
{
    class Program
    {
        static void Main(string[] args)
        {
            //保证端口号和服务端一致
            TCPLib.TCPClient c = new TCPClient("127.0.0.1",6001);
            //执行Start方法
            c.Start();
            while(true)
            {
                //读取客户端输入的消息
                string msg = Console.ReadLine();
                //发送消息到服务端
                c.SendMessage(msg);
            }
        }
    }
}

注意要先运行服务端的程序、再运行客户端的程序，不然程序会报错，嘿嘿！好了，下面是今天的效果演示图：

服务器端窗口：无内容输出

客户端窗口效果如下:

总结

今天我们基本上写出了一个可以使用的用例，不过这个例子目前还存在以下问题： 
* 这里仅仅实现了发送字符串的功能，如何让这个程序支持更多的类型，从基础的int、float、double、string、single等类型到structure、class甚至是二进制文件的类型？ 
* 如何让这个用例更具有扩展性，我们发现所有的Socket编程流程都是一样的，唯一不同就是在接收到数据以后该如何去处理，因为能不能将核心功能和自定义功能分离开来？ 
* 在今天的这个用例中，数据传输的缓冲区大小我们人为设定为1024，那么如果碰到比这个设定更大的数据类型，这个用例该怎么来写？（可以参照以下网址：http://www.jb51.net/article/82795.htm）

好了，这就是今天的内容了，希望大家喜欢，同时希望大家关注我的博客！