c#实现Socket网络编程

命名空间：

　　在网络环境下，我们最感兴趣的两个命名空间是System.Net和 System.Net.Sockets。

　　System.Net命名空间通常与较高程的操作有关，例如download或upload，试用HTTP和其他协议进行Web请求等等

　　System.Net.Sockets命名空间所包含的类通常与较低程的操作有关。如果要直接使用Sockets或者 TCP/IP之类的协议

 

Socket对象创建：

　　针对Socket编程，.NET 框架的 Socket 类是 Winsock32 API 提供的套接字服务的托管代码版本。Socket可以象流Stream一样被视为一个数据通道，这个通道架设在应用程序端（客户端）和远程服务器端之间，而后，数据的读取（接收）和写入（发送）均针对这个通道来进行。

　　Socket 类支持两种基本模式：同步和异步。其区别在于：在同步模式中，对执行网络操作的函数（如 Send 和 Receive）的调用一直等到操作完成后才将控制返回给调用程序。在异步模式中，这些调用立即返回。 

 

　　在使用之前，你需要首先创建Socket对象的实例，这可以通过Socket类的构造方法来实现： 

　　public Socket(AddressFamily addressFamily,SocketType socketType,ProtocolType protocolType); 

　　其中，addressFamily 参数指定 Socket 使用的寻址方案，socketType 参数指定 Socket 的类型，protocolType 参数指定 Socket 使用的协议。 

　　下面的示例语句创建一个 Socket，它可用于在基于 TCP/IP 的网络（如 Internet）上通讯。 

Socket temp = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 

　　若要使用 UDP 而不是 TCP，需要更改协议类型，如下面的示例所示： 

Socket temp = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); 

一旦创建 Socket，在客户端，你将可以通过Connect方法连接到指定的服务器，并通过Send/SendTo

 

Socket操作流程：

　　方法向远程服务器发送数据，而后可以通过 Receive/ReceiveFrom从服务端接收数据；而在服务器端，你需要使用Bind方法绑定所指定的接口使Socket与一个本地终结点相联，并通过Listen方法侦听该接口上的请求，当侦听到用户端的连接时，调用Accept完成连接的操作，创建新的Socket以处理传入的连接请求。使用完 Socket 后，记住使用 Shutdown 方法禁用 Socket，并使用 Close 方法关闭 Socket。

 

终结点：

　　在Internet中，TCP/IP 使用套接字(一个网络地址和一个服务端口号)来唯一标识设备。网络地址(IP)标识网络上的特定设备；端口号(Port)标识要连接到的该设备上的特定服务。网络地址和服务端口的组合称为终结点，在 .NET 框架中正是由 EndPoint 类表示这个终结点，它提供表示网络资源或服务的抽象，用以标志网络地址等信息。

　　.Net同时也为每个受支持的地址族定义了 EndPoint 的子代；对于 IP 地址族，该类为 IPEndPoint。IPEndPoint 类包含应用程序连接到主机上的服务所需的主机和端口信息。

 

IP地址获取方式:

　　用到IPEndPoint类的时候就不可避免地涉及到计算机IP地址，System.Net命名空间中有两种类可以得到IP地址实例： 

　　IPAddress类： 在同一局域网中采用的获取方式。 IPAddress 类包含计算机在 IP 网络上的地址。其Parse方法可将 IP 地址字符串转换为 IPAddress 实例。下面的语句创建一个 IPAddress 实例： 

IPAddress myIP = IPAddress.Parse("192.168.0.1"); 

　　Dns 类：  在互联网中采用的获取方式。 向使用 TCP/IP Internet 服务的应用程序提供域名服务。其Resolve 方法查询 DNS 服务器以将用户友好的域名（如"host.mydomain.com"）映射到数字形式的 Internet 地址（如 192.168.0.1）。

　　Resolve方法 返回一个 IPHostEnty 实例，该实例包含所请求名称的地址和别名的列表。大多数情况下，可以使用 AddressList 数组中返回的第一个地址。下面的代码获取一个 IPAddress 实例，该实例包含服务器 host.mydomain.com 的 IP 地址。 

　　IPHostEntry ipHostInfo = Dns.Resolve("host.mydomain.com "); 

　　IPAddress ipAddress = ipHostInfo.AddressList[0]; 

　　你也可以使用GetHostName方法得到IPHostEntry实例： 

　　IPHosntEntry hostInfo=Dns.GetHostByName("host.mydomain.com ") 

　　在使用以上方法时，你将可能需要处理以下几种异常： 

　　SocketException异常：访问Socket时操作系统发生错误引发 

　　ArgumentNullException异常：参数为空引用引发 

　　ObjectDisposedException异常：Socket已经关闭引发

 

通信过程示例:

 

服务器端：

 

服务器端接收客户端数据步骤：

 

1. 创建一个服务器端的实体
2. 创建服务器端对客户端的监听
3. EndAccept方法返回客户端实体
4. 新建线程负责接收客户端的数据

 

 

 public class CM
     {
         public static bool ISAddSocekt = true;//现在是否继续接收新的客户端连接

         public static int AddressIndex = 0;//这是当前与服务器端连接的第几个客户端 
         //病历号和客户端IP关联表(key:病历号 value:客户端的IP地址,不包含port)
         public static Dictionary<string, string> dic_Patient_IP = new Dictionary<string, string>();
         //客户端IP和客户端连接顺序关联表(key:病历号 value:客户端的IP地址,不包含port)
         public static Dictionary<string, int> dic_IP_Index = new Dictionary<string, int>();
         //客户端集合 key:客户端IP地址,Value:客户端实体
         public static Dictionary<string, Socket> dic_IP_Socket = new Dictionary<string, Socket>();

    
         private delegate void AcceptDelegete();
         private delegate void ReadDelegete(Socket s);

         public static int ServerPort = 2000;//服务器端端口
         public static Socket serverSocket;//服务器端      
         //用20个线程分别接受一个设备的数据
         public static int ClientCount_Max = 20;//客户端的最大数量


         public static void Listen()
         {
             AcceptDelegete listen = AcceptConnection;
             IAsyncResult asy = listen.BeginInvoke(null, null);
         }
         private static void AcceptConnection()
         {
             try
             {
                 serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                 IPEndPoint localEP = new IPEndPoint(IPAddress.Any, ServerPort);
                 //将socket绑定到本地的终结点上
                 serverSocket.Bind(localEP);
                 //开始监听
                 serverSocket.Listen(ClientCount_Max);
                 serverSocket.BeginAccept(new AsyncCallback(AcceptCallBack), null);

             }
             catch (Exception ex)
             {

             }
         }

         private static void AcceptCallBack(IAsyncResult iar)
         {
             try
             {
                 while (ISAddSocekt)
                 {
                     // 调用EndAccept完成BeginAccept异步调用，返回一个新的Socket处理与客户的通信
                     Socket clientSocket = serverSocket.EndAccept(iar);
                     IPEndPoint clientPoint = clientSocket.RemoteEndPoint as IPEndPoint;

                     if (!dic_IP_Index.ContainsKey(clientPoint.Address.ToString()))
                     {
                         dic_IP_Index.Add(clientPoint.Address.ToString(), AddressIndex);
                         AddressIndex += 1;
                         //去除旧的客户端实体
                         dic_IP_Socket.Remove(clientPoint.Address.ToString());
                     }
                         dic_IP_Socket.Add(clientPoint.Address.ToString(), clientSocket);
                     

                     //开启新线程读取数据
                     CM_Data client = new CM_Data(clientSocket);
                     Thread thClient = new Thread(new ThreadStart(client.ClientServer));
                     thClient.Start();
                     //在达到多大的客户端连接限制前，继续监听是否有新的客户端连接
                     if (dic_IP_Index.Count < ClientCount_Max)
                     {
                         serverSocket.BeginAccept(new AsyncCallback(AcceptCallBack), null);
                     }
                 }
             }
             catch (Exception ex)
             {

             }
         }
     }


  //在新线程中不同的循环接收客户端发送过来的数据信息
        //  CM_Data类里的代码
  public class CM_Data
     {
         Encoding encoding = Encoding.GetEncoding("GB2312"); //解码器（可以用于汉字）
         private Socket client;//当前与服务器端通信的客户端实体

         private byte[] receiveBytes = new byte[1024];//服务器端设置缓冲区
         private int recCount;
         byte[] byte_Data;
         //传递连接socket
         public CM_Data(Socket ClientSocket)
         {
             this.client = ClientSocket;
         }

         public void ClientServer()
         {

             try
             {
                 while (true)
                 {
                     recCount = client.Receive(receiveBytes, receiveBytes.Length, 0);//从客户端接收信息,recCount为有效数据的个数
                     if (recCount != 0)//当服务器端的缓冲区接收到的信息不为空时
                     {
                         byte_Data = new byte[recCount];
                         for (int i = 0; i < recCount; i++)
                         {
                             byte_Data[i] = receiveBytes[i];
                         }
                         //获取数据后的数据处理
                         DataRead(byte_Data);

                     }
                     else
                     {
                         break;
                     }
                 }
             }
             catch (Exception ex)
             {
                 MessageBox.Show("数据接收时发生错误:"+ex.Message);
             }
             client.Close();
         }

 

服务器端向客户端发送数据：

1. 获取当前与服务器端通信的客户端（或者要与之通信的目标客户端）
2. BeginSend 将数据发送，要发送的数据使用的是byte数组的形式。
3. 示例中向客户端发送的数据也是异步发送的

public void WorkCommand(string clientIP,int WorkState)
        {
            Socket client = (Socket)CM.dic_IP_Socket[clientIP];

            byte[] b1 = new byte[6];
            b1[0] = 0x55;
            b1[1] = 0xaa;
            b1[2] = 0x04;
            b1[3] = 0x81;
            switch (WorkState)
            {
                case 1: b1[4] = 0x01; break;
                case 2: b1[4] = 0x02; break;
                case 3: b1[4] = 0x03; break;
                case 4: b1[4] = 0x04; break;
            }
            b1[5] = CM_Data.GetParityBit(b1) ;
            client.BeginSend(b1, 0, b1.Length, SocketFlags.None, new AsyncCallback(SendCallBack), client);
        }

        private void SendCallBack(IAsyncResult iar)
        {
            Socket workerSocket = (Socket)iar.AsyncState;
            workerSocket.EndSend(iar);
        }

客户端：

　　项目的客户端代码是否下位机完成的（使用C++代码），下面的客户端示例，是我在测试程序中使用到的c#版本的代码示例。

客户端接收服务器端数据步骤：

1. 创建客户端实体，IPEndPoint 里指定的是服务器端的IP地址和服务器端的端口号。
2. 客户端等待服务器端的连接。
3. 客户端循环等待服务器端的发送数据

private int serverPort = 2000;
        public byte[] dataBuffer = new byte[10000000];
        Socket client;

    //连接服务器
        private void ServerConnection()
        {
            try
            {
                client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPAddress ip = IPAddress.Parse("192.168.10.188");
                IPEndPoint iep = new IPEndPoint(ip, 2000);
                client.BeginConnect(iep, new AsyncCallback(Connect), null);
            }
            catch { }
        }

        private void Connect(IAsyncResult asy)
        {

            try
            {
                client.EndConnect(asy);
                client.BeginReceive(dataBuffer, 0, dataBuffer.Length, SocketFlags.None, new AsyncCallback(RecieveCallBack), null);
            }
            catch { }
        }
      

        //接收byte字节方式
        private void RecieveCallBack(IAsyncResult iar)
        {
            try
            {
                int iRx = client.EndReceive(iar);

                byte[] byte_Receive = new byte[iRx];
                for (int i = 0; i < iRx; i++)
                {
                    byte_Receive[i] = dataBuffer[i];
                   listBox1.Items.Add(Convert.ToString(byte_Receive[i], 16));
                }
                string revStr = System.Text.Encoding.UTF7.GetString(byte_Receive, 0, iRx);
               
                //继续监听下一次的数据接收
                client.BeginReceive(dataBuffer, 0, dataBuffer.Length, SocketFlags.None, new AsyncCallback(RecieveCallBack), null);

            }
            catch { }
        }

Void SendMessage()
{
try    
            {
                byte[] buffer = System.Text.Encoding.Default.GetBytes(textBox1.Text);
                int snLen = 0;
                client.BeginSend(buffer, snLen, buffer.Length, SocketFlags.None, new AsyncCallback(SendCallBack), client);
            }
            catch { }
}