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(""));

                 ServerSocket.Bind(ServerInfo);

                 ServerSocket.Listen();

                 ClientSocket = new Socket[];

                 MsgBuffer = new byte[];

                 ClientNumb = ;

                 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, , MsgBuffer.Length, SocketFlags.None,

                     new AsyncCallback(ReceiveCallback), ClientSocket[ClientNumb]);

                 this.Invoke((MethodInvoker)delegate

                 {

                     lock (this.textBox1)

                         this.textBox1.Text += "客户端：" + ClientNumb.ToString() + "连接成功！" + "\r\n";

                 });

                 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 = ; i < ClientNumb; i++)

                 {

                     if (ClientSocket[i].Connected)

                     {

                         //发送数据到客户端

                         ClientSocket[i].Send(MsgBuffer, , rEnd, SocketFlags.None);

                     }

                     //同时接受客户端回发的数据，用于回发

                     rSocket.BeginReceive(MsgBuffer, , MsgBuffer.Length, , 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("用户： 进入系统！" + "\r\n"));

34                 ClientSocket.BeginReceive(MsgBuffer, 0, MsgBuffer.Length, SocketFlags.None,

35                     new AsyncCallback(ReceiveCallback), null);

36                 this.textBox1.Text += "登录服务器成功" + "\r\n";

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) + "\r\n";

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("说：\n" + this.textBox2.Text + "\n\r");

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(""));

                 socket.Bind(endPoint);

                 socket.Listen();

                 thread = new Thread(new ThreadStart(WatchConnection));

                 thread.IsBackground = true;

                 thread.Start();

                 this.listBox1.Text = "开始监听客户端传来的消息" + "\r\n";

             }

             catch (System.Exception ex)

             {

                 this.listBox1.Text += "SocketException" + ex;

             }

         }

         Socket[] socConnection = new Socket[];

         private static int clientNum = ;

         /// <summary>

         /// 监听客户端发来的请求

         /// </summary>

         private void WatchConnection()

         {

             while (true)

             {

                 socConnection[clientNum] = socket.Accept();

                 this.Invoke((MethodInvoker)delegate

                 {

                     this.listBox1.Text += "客户端连接成功" + "\r\n";

                 });

                 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[ * ];

                     int length = socketServer.Receive(arrServerRecMsg);

                     string strSRecMsg = Encoding.UTF8.GetString(arrServerRecMsg, , length);

                     this.Invoke((MethodInvoker)delegate

                     {

                         this.listBox1.Text += "接收到：" + strSRecMsg + "\r\n";

                     });

                     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(""));

             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[ * ];

                 //将接收到的数据放入内存缓冲区，获取其长度

                 int length = socketClient.Receive(arrRecMsg);

                 //将套接字获取到的字节数组转换为我们可以理解的字符串

                 string strRecMsg = Encoding.UTF8.GetString(arrRecMsg, , length);

                 this.Invoke((MethodInvoker)delegate

                 {

                     lock (this.listBox1)

                     {

                         this.listBox1.Text += "服务器：" + strRecMsg + "\r\n";

                     }

                 });

             }

         }

         /// <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 + "\r\n";

         }

     }

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

巴特西

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

最新文章

热门文章