C#中Socket用法，多个聊天和单一聊天。

自己琢磨Socket刚刚几天，所以整理出来和大家共享一下。废话少说直接进入正题。

在C#中提供了两种网络服务，一种是Socket类，另一种是TcpListener（服务器）,TcpClient（客户端）;

至于这两种有什么区别那；MSDN上是这样解释的：

TcpClient 类，TcpListener 类提供了一些简单的方法，用于在同步阻止模式下通过网络来连接、发送和接收流数据。

Socket 类为网络通信提供了一套丰富的方法和属性。 Socket 类允许您使用 ProtocolType 枚举中所列出的任何一种协议执行异步和同步数据传输。

个人理解就是一个是用于简单的业务，一种用于复杂的业务。所以感觉是一样的。本文事例主要用Socket类来实现。一般来说复杂的会了，简单的应该也差不多了。

先从第一个情景来说：第一个就是建立多人聊天的模式，就是多个客户端连接一个服务器，然后可以和多个客户端通信。就像QQ里的群聊。

首先我们来见一个服务器：

就包含一个文本框就行了，里边具体代码如下：

    public partial class server : Form
    {
        private IPEndPoint ServerInfo;//存放服务器的IP和端口信息
        private Socket ServerSocket;//服务端运行的SOCKET
        private Thread ServerThread;//服务端运行的线程
        private Socket[] ClientSocket;//为客户端建立的SOCKET连接
        private int ClientNumb;//存放客户端数量
        private byte[] MsgBuffer;//存放消息数据

        private object obj;

        public server()
        {
            InitializeComponent();
            ListenClient();
        }

        /// <summary>
        /// 开始服务，监听客户端
        /// </summary>
        private void ListenClient()
        {
            try
            {
                ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPAddress ip = IPAddress.Parse("127.0.0.1");
                ServerInfo = new IPEndPoint(ip, Int32.Parse("3000"));
                ServerSocket.Bind(ServerInfo);
                ServerSocket.Listen(10);

                ClientSocket = new Socket[65535];
                MsgBuffer = new byte[65535];
                ClientNumb = 0;

                ServerThread = new Thread(new ThreadStart(RecieveAccept));
                ServerThread.Start();
            }
            catch (System.Exception ex)
            {

            }
        }

        /// <summary>
        /// 添加阻塞，监听客户端
        /// </summary>
        private void RecieveAccept()
        {
            while (true)
            {
                //等待接受客户端连接，如果有就执行下边代码，没有就阻塞
                ClientSocket[ClientNumb] = ServerSocket.Accept();
                //接受客户端信息，没有阻塞，则会执行下边输出的代码；如果是Receive则不会执行下边输出代码
                ClientSocket[ClientNumb].BeginReceive(MsgBuffer, 0, MsgBuffer.Length, SocketFlags.None,
                    new AsyncCallback(ReceiveCallback), ClientSocket[ClientNumb]);
                this.Invoke((MethodInvoker)delegate
                {
                    lock (this.textBox1)
                        this.textBox1.Text += "客户端：" + ClientNumb.ToString() + "连接成功！" + "
";
                });
                ClientNumb++;
            }
        }

        /// <summary>
        /// 回发数据到客户端
        /// </summary>
        /// <param name="ar"></param>
        private void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                Socket rSocket = (Socket)ar.AsyncState;
                int rEnd = rSocket.EndReceive(ar);

                for (int i = 0; i < ClientNumb; i++)
                {
                    if (ClientSocket[i].Connected)
                    {
                        //发送数据到客户端
                        ClientSocket[i].Send(MsgBuffer, 0, rEnd, SocketFlags.None);
                    }

                    //同时接受客户端回发的数据，用于回发
                    rSocket.BeginReceive(MsgBuffer, 0, MsgBuffer.Length, 0, new AsyncCallback(ReceiveCallback), rSocket);
                }
            }
            catch (System.Exception ex)
            {

            }
        }
    }

然后我们添加客户端代码，客户端要一个按钮和两个文本框

具体代码如下：

 1     public partial class Client : Form
 2     {
 3         private IPEndPoint ServerInfo;
 4         private Socket ClientSocket;
 5         private object obj;
 6 
 7         //信息接收缓存
 8         private Byte[] MsgBuffer;
 9         //信息发送存储
10         private Byte[] MsgSend;
11 
12         public Client()
13         {
14             InitializeComponent();
15             ConnectServer();
16             this.button1.Click += new EventHandler(button1_Click);
17         }
18 
19         /// <summary>
20         /// 打开客户端，即连接服务器
21         /// </summary>
22         private void ConnectServer()
23         {
24             try
25             {
26                 ClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
27                 MsgBuffer = new byte[65535];
28                 MsgSend = new byte[65535];
29                 IPAddress ip = IPAddress.Parse("127.0.0.1");
30                 ServerInfo = new IPEndPoint(ip, Int32.Parse("3000"));
31                 ClientSocket.Connect(ServerInfo);
32                 //发送信息至服务器
33                 ClientSocket.Send(Encoding.Unicode.GetBytes("用户： 进入系统！" + "
"));
34                 ClientSocket.BeginReceive(MsgBuffer, 0, MsgBuffer.Length, SocketFlags.None,
35                     new AsyncCallback(ReceiveCallback), null);
36                 this.textBox1.Text += "登录服务器成功" + "
";
37             }
38             catch (System.Exception ex)
39             {
40 
41             }
42         }
43 
44         /// <summary>
45         /// 回调时调用
46         /// </summary>
47         /// <param name="ar"></param>
48         private void ReceiveCallback(IAsyncResult ar)
49         {
50             int rEnd = ClientSocket.EndReceive(ar);
51             this.Invoke((MethodInvoker)delegate
52                  {
53                      lock (this.textBox1)
54                      {
55                          this.textBox1.Text += Encoding.Unicode.GetString(MsgBuffer, 0, rEnd) + "
";
56                      }
57                  });
58             ClientSocket.BeginReceive(MsgBuffer, 0, MsgBuffer.Length, 0, new AsyncCallback(ReceiveCallback), null);
59         }
60 
61         /// <summary>
62         /// 发送信息
63         /// </summary>
64         /// <param name="sender"></param>
65         /// <param name="e"></param>
66         private void button1_Click(object sender, EventArgs e)
67         {
68             MsgSend = Encoding.Unicode.GetBytes("说：
" + this.textBox2.Text + "

");
69             if (ClientSocket.Connected)
70             {
71                 ClientSocket.Send(MsgSend);
72             }
73         }
74 
75     }
76 }

这样先运行服务器，在多运行几个客户端就可以了。

下边讲一下第二种案例:这种是多个客户端和服务器连接，每个客户端都可以和服务器通信，但是客户端之间没有通信，而且每个客户端和服务器通信时，不会影响其他客户端。

具体样式如图：

接着我们来看看具体的代码：

先来看看服务器的，样式和第一种一样，

具体代码：

    public partial class Server : Form
    {
        private Socket socket = null;
        private Thread thread = null;

        public Server()
        {
            InitializeComponent();
            StartListening();
        }

        /// 
        /// 开始监听客户端
        /// 
        private void StartListening()
        {
            try
            {
                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPAddress ipaddress = IPAddress.Parse("127.0.0.1");
                IPEndPoint endPoint = new IPEndPoint(ipaddress, int.Parse("3000"));

                socket.Bind(endPoint);
                socket.Listen(20);

                thread = new Thread(new ThreadStart(WatchConnection));
                thread.IsBackground = true;
                thread.Start();

                this.listBox1.Text = "开始监听客户端传来的消息" + "
";
            }
            catch (System.Exception ex)
            {
                this.listBox1.Text += "SocketException" + ex;
            }
        }

        Socket[] socConnection = new Socket[12];
        private static int clientNum = 0;

        /// <summary>
        /// 监听客户端发来的请求
        /// </summary>
        private void WatchConnection()
        {
            while (true)
            {
                socConnection[clientNum] = socket.Accept();
                this.Invoke((MethodInvoker)delegate
                {
                    this.listBox1.Text += "客户端连接成功" + "
";
                });

                Thread thread = new Thread(new ParameterizedThreadStart(ServerRecMsg));
                thread.IsBackground = true;
                thread.Start(socConnection[clientNum]);
                clientNum++;
            }
        }

        /// <summary>
        /// 接受客户端消息并发送消息
        /// </summary>
        /// <param name="socketClientPara"></param>
        private void ServerRecMsg(object socketClientPara)
        {
            Socket socketServer = socketClientPara as Socket;
            try
            {
                while (true)
                {
                    byte[] arrServerRecMsg = new byte[1024 * 1024];
                    int length = socketServer.Receive(arrServerRecMsg);

                    string strSRecMsg = Encoding.UTF8.GetString(arrServerRecMsg, 0, length);
                    this.Invoke((MethodInvoker)delegate
                    {
                        this.listBox1.Text += "接收到：" + strSRecMsg + "
";
                    });

                    byte[] arrSendMsg = Encoding.UTF8.GetBytes("收到服务器发来的消息");
                    //发送消息到客户端
                    socketServer.Send(arrSendMsg);
                }
            }
            catch (System.Exception ex)
            {

            }
        }
    }

再来看看客户端代码：

样式和第一种也一样：

    public partial class Client : Form
    {
        private Socket socketClient = null;
        private Thread threadClient = null;

        public Client()
        {
            InitializeComponent();
            ConnectionServer();
            this.button1.Click += new EventHandler(button1_Click);
        }

        /// <summary>
        /// 连接服务器
        /// </summary>
        private void ConnectionServer()
        {
            socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPAddress ipaddress = IPAddress.Parse("127.0.0.1");
            IPEndPoint endPoint = new IPEndPoint(ipaddress, int.Parse("3000"));
            try
            {
                socketClient.Connect(endPoint);
                threadClient = new Thread(RecMsg);
                threadClient.IsBackground = true;
                threadClient.Start();
            }
            catch (System.Exception ex)
            {

            }

        }

        /// <summary>
        /// 接收服务器消息
        /// </summary>
        private void RecMsg()
        {
            while (true)
            {
                //内存缓冲区1M,用于临时存储接收到服务器端的消息
                byte[] arrRecMsg = new byte[1024 * 1024];
                //将接收到的数据放入内存缓冲区，获取其长度
                int length = socketClient.Receive(arrRecMsg);
                //将套接字获取到的字节数组转换为我们可以理解的字符串
                string strRecMsg = Encoding.UTF8.GetString(arrRecMsg, 0, length);
                this.Invoke((MethodInvoker)delegate
                {
                    lock (this.listBox1)
                    {
                        this.listBox1.Text += "服务器：" + strRecMsg + "
";
                    }
                });
            }
        }

        /// <summary>
        /// 向服务器发送消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            ClientSendMsg(this.textBox1.Text.Trim());
        }

        /// <summary>
        /// 发送信息到服务器
        /// </summary>
        /// <param name="sendMsg"></param>
        private void ClientSendMsg(string sendMsg)
        {
            //将输入的字符串转化为机器可以识别的字节数组
            byte[] arrClientSendMsg = Encoding.UTF8.GetBytes(sendMsg);
            //发送数据
            socketClient.Send(arrClientSendMsg);
            this.listBox1.Text += "客户端：" + sendMsg + "
";
        }
    }

到此两种方式就说完了，不知道说的对不对，请各位吐槽！！！，转载注明出处。