Socket编程

在.net下进行网络编程其实也相对比较简单，因为在.net类库已经提供了大量封装好的类。在.net下网络编程比较底层的类是System.NET.Sockets.Socket类，这个类提供了丰富的方法和属性，并且还提供了异步数据传输支持。
对Socket类做一个简单的介绍，它有如下常见方法：
public Socket Accept ()：为新建连接创建新的 Socket。    
public void Bind (EndPoint localEP)：使 Socket 与一个本地终结点相关联。  
public void Close ()：关闭 Socket 连接并释放所有关联的资源。注意这个方法有冲载方法。 
public void Connect (EndPoint remoteEP)：建立与远程主机的连接。注意这个方法有重载方法。
public void Disconnect (bool reuseSocket)：关闭套接字连接并是否允许重用套接字。  
public void Listen (int backlog)：将 Socket 置于侦听状态。  
public int Receive (byte[] buffer)：接收来自绑定的 Socket 的数据。注意这个方法有重载方法。 
public int ReceiveFrom (byte[] buffer,ref EndPoint remoteEP)：接收数据报并存储源终结点。注意这个方法有重载方法。
public int Send (byte[] buffer)：将数据发送到连接的 Socket。注意这个方法有重载方法。
public void SendFile (string fileName)：将文件和可选数据异步发送到连接的 Socket。注意这个方法有重载方法。
public int SendTo (byte[] buffer,EndPoint remoteEP)：将数据发送到特定终结点。注意这个方法有重载方法。
public void Shutdown (SocketShutdown how)：禁用某 Socket 上的发送和接收。

因为在网络传输时传输的数据都是二进制形式的（表现为字节数组），所以如果要传输类似于中文这样的双字节字符就需要在传输之前用合适的编码转换成字节数组，然后接收方按照发送方的编码将接收到字节数组转换成字符串。另外，注意接收数据的时候是先声明了一个字节数组，然后将接收到的数据保存到字节数组中，这个方法有个返回值表示实际接收了多少字节数据。这是因为数组是不可变的，假如声明了一个1024字节大小的数组，而发送方仅发送1字节数据，而接收方并不直到发送方发送的数据量把整个1024字节当作发送发送的数据的话，最终会发生错误。

 

要实现一个服务器端的面向连接的Socket用于接收客户端的请求的话，有如下步骤：
（1）首先根据IP地址和端口号实例化一个Socket，注意端口要要大于1024并且不要使用特殊端口号，要大于1024的原因是1024以下的端口号已经被指派了，而1433、3306这样的端口号已经被用作SQL Server和MySQL的默认端口号了，若指定为这些端口号容易发生冲突。
（3）接着调用Bind()方法进行绑定，然后再调用Listen()方法用于监听，Listen()方法的参数用于指定监听的队列大小，也就是最多可容纳的等待接受的传入连接数。
（4）再调用Accept()方法，调用这个方法之后会是程序处于阻塞状态，直至有客户端连接为止。当有客户端连接，这个方法将会返回一个新的Socket，使用这个Socket与客户端进行通讯。
（5）使用Accept()方法返回的新Socket的Send()方法就可以向客户端发送数据了，还可以使用这个新Socket的Receive()接收客户端的数据。
（6）最后终止与客户端会话时，注意使用ShutDown()方法关闭Socket连接，并且使用Close()方法释放所占用的资源。

 

使用Socket类编写客户端的Socket程序步骤如下：
（1）首先指定远程主机和端口号实例化Socket类，注意连接的端口号一定要与服务器监听的端口号一致。
（2）接着调用Connect()方法连接远程主机。
（3）连接到远程主机之后就可以调用Send()方法向服务器发送请求了，然后可以调用Receive()方法接收服务器响应数据，注意如果是发送的类似于中文这样的双字节字符串的话，还需要按照服务器响应的字符串编码将字节数组转换成字符串。

 

最后终止与客户端会话时，注意使用ShutDown()方法关闭Socket连接，并且使用Close()方法释放所占用的资源。
需要特别说明的是上面是建立连接式Socket（如建立TCP协议Socket）的一般步骤，如果是建立非连接式Socket（如UDP协议Socket）就不需要进行监听端口了，直接使用ReceiveFrom()方法就能接收来自指定主机端口的数据，用SendTo()方法就能向直接主机端口发送数据。
下面一个例子来演示Socket的编程，在这个例子里服务器端可以处理多个客户端请求并响应，具体的做法是每接收到一个客户端请求就新建一个线程来与客户端通讯，主程序依然继续监听，在例子中新建的与客户端通讯的Socket类仅处理客户端的日期时间请求（为了演示，这里做了简化），根据客户端的请求的不同发送日期时间中响应信息到客户端，客户端接收到数据之后在控制台显示。

 

服务器端主要由两个类组成：ServerSocket类和SocketThread类，ServerSocket类用于监听客户端连接请求，SocketThread类用于接收日期时间显示请求并做出应答。

ServerSocket类代码如下（ServerSocket类和SocketThread类位于同一个类库项目中）：

  1. using System;  
  2. using System.Net;  
  3. using System.Net.Sockets;  
  4. using System.Text;  
  5.   
  6. namespace ServerSocket  
  7. {  
  8.     public class ServerSocket:IDisposable  
  9.     {  
  10.         Socket listener = null;  
  11.         /// <summary>  
  12.         /// 开始监听指定端口  
  13.         /// </summary>  
  14.         public void StartListening(int port)  
  15.         {  
  16.             // Data buffer for incoming data.  
  17.             byte[] bytes = new Byte[1024];  
  18.   
  19.             //以运行服务器端程序所在的机器为服务器监听客户端连接  
  20.             IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());  
  21.             IPAddress ipAddress = ipHostInfo.AddressList[0];  
  22.             IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);  
  23.   
  24.             //创建一个TCP/IP Socket用于监听客户端连接  
  25.             Socket listener = new Socket(AddressFamily.InterNetwork,  
  26.                 SocketType.Stream, ProtocolType.Tcp);  
  27.   
  28.             try  
  29.             {  
  30.                 //先绑定要监听的主机和端口  
  31.                 listener.Bind(localEndPoint);  
  32.                 //再开始监听，并且指定监听队列的最大长度  
  33.                 listener.Listen(10);  
  34.   
  35.                 //开始监听连接  
  36.                 while (true)  
  37.                 {  
  38.                     Console.WriteLine("等待客户端连接...");  
  39.                     //线程将一直阻塞直到有新的客户端连接  
  40.                     Socket handler = listener.Accept();  
  41.                     //启用一个新的线程用于处理客户端连接  
  42.                     //这样主线程还可以继续接受客户端连接  
  43.                     SocketThread socketThread = new SocketThread(handler);  
  44.                 }  
  45.   
  46.             }  
  47.             catch (Exception e)  
  48.             {  
  49.                 Console.WriteLine(e.ToString());  
  50.             }  
  51.   
  52.         }  
  53.   
  54.         public static int Main(String[] args)  
  55.         {  
  56.             ServerSocket server = new ServerSocket();  
  57.             server.StartListening(11000);  
  58.             return 0;  
  59.         }  
  60.  
  61.         #region IDisposable 成员  
  62.   
  63.         public void Dispose()  
  64.         {  
  65.             if (listener != null)  
  66.             {  
  67.                 listener.Shutdown(SocketShutdown.Both);  
  68.                 listener.Close();  
  69.             }  
  70.         }  
  71.  
  72.         #endregion  
  73.     }  
  74. }   

SocketThread类代码如下：

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Threading;  
  5. using System.Net.Sockets;  
  6.   
  7. namespace ServerSocket  
  8. {  
  9.     public class SocketThread:IDisposable  
  10.     {  
  11.         private Socket socket;  
  12.         private Thread thread;  
  13.         private bool isListening = false;  
  14.         private string text;  
  15.         /// <summary>  
  16.         /// 构造方法  
  17.         /// </summary>  
  18.         /// <param name="socket">用于处理客户端应答的Socket</param>  
  19.         public SocketThread(Socket socket)  
  20.         {  
  21.             this.socket = socket;  
  22.             isListening = true;  
  23.             thread = new Thread(new ThreadStart(Work));  
  24.             thread.Start();  
  25.         }  
  26.   
  27.   
  28.         public void Work()  
  29.         {  
  30.             byte[] buffer=new byte[1024];  
  31.             while (isListening)  
  32.             {  
  33.                 int receivedLength = socket.Receive(buffer);  
  34.                 text=System.Text.Encoding.UTF8.GetString(buffer,0,receivedLength);  
  35.                 //<EOF>是自定义的协议，表示中止消息交流  
  36.                 if (text.IndexOf("<EOF>") > -1)  
  37.                 {  
  38.                     isListening=false;  
  39.                     socket.Send(new byte[] { 0 });  
  40.                 }  
  41.                 else  
  42.                 {  
  43.                     //Console.WriteLine("接收到的数据：" + text);  
  44.                     //根据客户端的请求获取相应的响应信息  
  45.                     string message = GetMessage(text);  
  46.                     //将响应信息以字节的方式发送到客户端  
  47.                     socket.Send(Encoding.UTF8.GetBytes(message));  
  48.                 }  
  49.             }  
  50.         }  
  51.         private string GetMessage(string request)  
  52.         {  
  53.             string message = string.Empty;  
  54.             //Console.WriteLine("Message=" + request);  
  55.             switch (request)  
  56.             {  
  57.                 case "date": message = "服务器日期："+DateTime.Now.ToString("yyyy-MM-dd"); break;  
  58.                 case "time": message ="服务器时间："+ DateTime.Now.ToString("HH:mm:ss"); break;  
  59.                 case "datetime": message = "服务器日期时间：" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); break;  
  60.                 case "year": message = "服务器年份：" + DateTime.Now.Year.ToString(); break;  
  61.                 case "month": message = "服务器月份：" + DateTime.Now.Month.ToString(); break;  
  62.                 case "day": message = "这是本月第" + DateTime.Now.Day.ToString()+"天"; break;  
  63.                 default: message = "不正确的参数"; break;  
  64.             }  
  65.             return message;  
  66.         }  
  67.  
  68.         #region IDisposable 成员  
  69.   
  70.         public void Dispose()  
  71.         {  
  72.             isListening = false;  
  73.             if (thread != null)  
  74.             {  
  75.                 if (thread.ThreadState != ThreadState.Aborted)  
  76.                 {  
  77.                     thread.Abort();  
  78.                 }  
  79.                 thread = null;  
  80.             }  
  81.             if (socket != null)  
  82.             {  
  83.                 socket.Shutdown(SocketShutdown.Both);  
  84.                 socket.Close();  
  85.             }  
  86.         }  
  87.  
  88.         #endregion  
  89.   
  90.           
  91.     }  
  92. }  

客户端请求的Socket代码如下（与前面两个类位于不同的控制台项目中）：

  1. using System;  
  2. using System.Net;  
  3. using System.Net.Sockets;  
  4. using System.Text;  
  5.   
  6. namespace ServerSocket  
  7. {  
  8.     public class ClientSocket:IDisposable  
  9.     {  
  10.         private Socket sender = null;  
  11.         private bool isListening = false;  
  12.         //定义用于接收服务器响应的存储区.  
  13.         private byte[] bytes = new byte[1024];  
  14.         //用于终止Soket的消息  
  15.         private string shutDownMessage = "<EOF>";  
  16.   
  17.         public ClientSocket()  
  18.         {  
  19.             try  
  20.             {  
  21.                 //设置要连接的主机信息并使用11000作为监听端口.  
  22.                 IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());  
  23.                 IPAddress ipAddress = ipHostInfo.AddressList[0];  
  24.                 IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);  
  25.   
  26.                 // 创建一个TCP/IP协议的socket连接  
  27.                 sender = new Socket(AddressFamily.InterNetwork,  
  28.                     SocketType.Stream, ProtocolType.Tcp);  
  29.                 sender.Connect(remoteEP);  
  30.                 isListening = true;  
  31.             }  
  32.             catch (Exception ex)  
  33.             {  
  34.                   
  35.                 Console.WriteLine(ex.ToString());  
  36.             }  
  37.         }  
  38.   
  39.         public void StartClient()  
  40.         {  
  41.             // 连接到远程主机，并捕获所有信息  
  42.             try  
  43.             {  
  44.                   
  45.                 Console.WriteLine("连接到主机{0}",  
  46.                     sender.RemoteEndPoint.ToString());  
  47.                 OutParameters();  
  48.                 string consoleMessage = Console.ReadLine();  
  49.                 while (isListening&&!string.IsNullOrEmpty(consoleMessage))  
  50.                 {  
  51.                     consoleMessage = consoleMessage.ToLower();  
  52.                     if (consoleMessage == "bye")  
  53.                     {  
  54.                         SendShutDownMessage();  
  55.                     }  
  56.                     else  
  57.                     {  
  58.                         string resultMessage=SendMessage(consoleMessage);  
  59.                         Console.WriteLine(resultMessage);  
  60.                         OutParameters();  
  61.                         consoleMessage = Console.ReadLine();  
  62.                         //Console.WriteLine("consoleMessage=" + consoleMessage);  
  63.                     }  
  64.                 }  
  65.   
  66.             }  
  67.             catch (ArgumentNullException ane)  
  68.             {  
  69.                 Console.WriteLine("参数异常 : {0}", ane.ToString());  
  70.             }  
  71.             catch (SocketException se)  
  72.             {  
  73.                 Console.WriteLine("出现Socket异常: {0}", se.ToString());  
  74.             }  
  75.             catch (Exception e)  
  76.             {  
  77.                 Console.WriteLine("出现了异常 : {0}", e.ToString());  
  78.             }  
  79.   
  80.         }  
  81.         /// <summary>  
  82.         /// 向远程主机发送信息  
  83.         /// </summary>  
  84.         /// <param name="message">要发送的信息</param>  
  85.         public string SendMessage(string message)  
  86.         {  
  87.             byte[] buffer = Encoding.UTF8.GetBytes(message);  
  88.             sender.Send(buffer);  
  89.             int count=sender.Receive(bytes);  
  90.             return Encoding.UTF8.GetString(bytes, 0, count);  
  91.         }  
  92.         /// <summary>  
  93.         /// 向服务器发送关闭Socket信息，并中止与服务器的连接  
  94.         /// </summary>  
  95.         public void SendShutDownMessage()  
  96.         {  
  97.             SendMessage(shutDownMessage);  
  98.             Console.WriteLine("已经关闭与服务器的连接");  
  99.             isListening = false;  
  100.             Environment.Exit(0);  
  101.         }  
  102.   
  103.         private void OutParameters()  
  104.         {  
  105.             Console.WriteLine("参数说明：");  
  106.             Console.WriteLine("获取服务器日期：date");  
  107.             Console.WriteLine("获取服务器时间：time");  
  108.             Console.WriteLine("获取服务器日期时间：datetime");  
  109.             Console.WriteLine("获取服务器年份：year");  
  110.             Console.WriteLine("获取服务器月份：month");  
  111.             Console.WriteLine("获取服务器天数：day");  
  112.             Console.WriteLine("关闭连接：bye");  
  113.             Console.WriteLine("请输入你要进行的操作：");  
  114.         }  
  115.   
  116.         public static int Main(String[] args)  
  117.         {  
  118.             ClientSocket client = new ClientSocket();  
  119.             client.StartClient();  
  120.             return 0;  
  121.         }  
  122.  
  123.         #region IDisposable 成员  
  124.   
  125.         public void Dispose()  
  126.         {  
  127.             isListening = false;  
  128.             if (sender != null)  
  129.             {  
  130.                 sender.Shutdown(SocketShutdown.Both);  
  131.                 sender.Close();  
  132.             }  
  133.         }  
  134.  
  135.         #endregion  
  136.     }  
  137. }  

上面的三个类位于两个控制台项目中ServerSocket类和SocketThread类位于同一个类库项目中，其中ClientSocket类位于另一个控制台项目中，编译之后会生成两个exe文件，运行的时候首先运行服务器端exe程序以便监听，再运行客户端exe程序。

注意，在终止程序的时候首先在客户端向服务器发送一个自定义的字符串“<EOF>”，在客户端使用命令行参数“bye”就是发送这个字符串的，这样就会正确终止服务器端响应Socket及正确关闭客户端请求的Socket，否则有可能抛出异常。

 

posted on 2017-03-15 15:02  可爱的春哥  阅读(248)  评论(0)  编辑  收藏  举报

导航