1.原理

长连接和短连接在程序上基本没有区别，区别是短连接每次发送完消息都要调用Close()方法来释放资源，而长连接则不调用Close()方法，从而保持持续不断的通信功能。

2.Socket服务端代码：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Net;
  5. using System.Net.Sockets;
  6. using System.Text;
  7. using System.Threading;
  8. using System.Threading.Tasks;
  10. namespace SocketServer
  11. {
  12.     class Program
  13.     {
  14.         static Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  15.         private static byte[] result = new byte[1024];
  17.         static void Main(string[] args)
  18.         {
  19.             SocketServie();
  20.         }
  23.         public static void SocketServie()
  24.         {
  25.             Console.WriteLine("服务端已启动");
  26.             string host = "127.0.0.1";//IP地址
  27.             int port = 2000;//端口
  28.             socket.Bind(new IPEndPoint(IPAddress.Parse(host), port));
  29.             socket.Listen(100);//设定最多100个排队连接请求   
  30.             Thread myThread = new Thread(ListenClientConnect);//通过多线程监听客户端连接  
  31.             myThread.Start();
  32.             Console.ReadLine();
  33.         }
  35.         /// <summary>  
  36.         /// 监听客户端连接  
  37.         /// </summary>  
  38.         private static void ListenClientConnect()
  39.         {
  40.             while (true)
  41.             {
  42.                 Socket clientSocket = socket.Accept();
  43.                 clientSocket.Send(Encoding.UTF8.GetBytes("我是服务器"));
  44.                 Thread receiveThread = new Thread(ReceiveMessage);
  45.                 receiveThread.Start(clientSocket);
  46.             }
  47.         }
  49.         /// <summary>  
  50.         /// 接收消息  
  51.         /// </summary>  
  52.         /// <param name="clientSocket"></param>  
  53.         private static void ReceiveMessage(object clientSocket)
  54.         {
  55.             Socket myClientSocket = (Socket)clientSocket;
  56.             while (true)
  57.             {
  58.                 try
  59.                 {
  60.                     //通过clientSocket接收数据  
  61.                     int receiveNumber = myClientSocket.Receive(result);
  62.                     if (receiveNumber == 0)
  63.                         return;
  64.                     Console.WriteLine("接收客户端{0} 的消息：{1}", myClientSocket.RemoteEndPoint.ToString(), Encoding.UTF8.GetString(result, 0, receiveNumber));
  65.                     //给Client端返回信息
  66.                     string sendStr = "已成功接到您发送的消息";
  67.                     byte[] bs = Encoding.UTF8.GetBytes(sendStr);//Encoding.UTF8.GetBytes()不然中文会乱码
  68.                     myClientSocket.Send(bs, bs.Length, 0);  //返回信息给客户端
  69.                     //myClientSocket.Close(); //发送完数据关闭Socket并释放资源//长连接的话就不关闭
  70.                     //Console.ReadLine();
  71.                 }
  72.                 catch (Exception ex)
  73.                 {
  74.                     Console.WriteLine(ex.Message);
  75.                     myClientSocket.Close();//关闭Socket并释放资源
  76.                     myClientSocket.Shutdown(SocketShutdown.Both);//禁止发送和上传
  77.                     break;
  78.                 }
  79.             }
  80.         }
  81.     }
  82. }

3.Socket客户端代码：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Net;
  5. using System.Net.Sockets;
  6. using System.Text;
  7. using System.Threading.Tasks;
  9. namespace SocketClient
  10. {
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  15.             //短连接
  16.             shotlink("");
  17.             //长连接
  18.             //longlink();
  19.         }
  23.         /// <summary>
  24.         /// 短连接，最后调用Close释放资源
  25.         /// </summary>
  26.         /// <param name="input"></param>
  27.         public static void shotlink(string input)
  28.         {
  29.             //设定服务器IP地址  
  30.             IPAddress ip = IPAddress.Parse("127.0.0.1");
  31.             Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  32.             try
  33.             {
  34.                 clientSocket.Connect(new IPEndPoint(ip, 2000)); //配置服务器IP与端口  
  35.                 Console.WriteLine("连接服务器成功");
  36.             }
  37.             catch
  38.             {
  39.                 Console.WriteLine("连接服务器失败，请按回车键退出！");
  40.                 Console.ReadLine();
  41.                 return;
  42.             }
  44.             string sendMessage = "你好";//发送到服务端的内容
  45.             clientSocket.Send(Encoding.UTF8.GetBytes(sendMessage));//向服务器发送数据，需要发送中文则需要使用Encoding.UTF8.GetBytes()，否则会乱码
  46.             Console.WriteLine("向服务器发送消息：" + sendMessage);
  48.             //接受从服务器返回的信息
  49.             string recvStr = "";
  50.             byte[] recvBytes = new byte[1024];
  51.             int bytes;
  52.             bytes = clientSocket.Receive(recvBytes, recvBytes.Length, 0);    //从服务器端接受返回信息 
  53.             recvStr += Encoding.UTF8.GetString(recvBytes, 0, bytes);
  54.             Console.WriteLine("服务端发来消息：{0}", recvStr);//回显服务器的返回信息
  55.             //每次完成通信后，关闭连接并释放资源
  56.             clientSocket.Close();
  57.             Console.ReadLine();
  58.         }
  61.         /// <summary>
  62.         /// 长连接不调用Close释放资源
  63.         /// </summary>
  64.         public static void longlink()
  65.         {
  66.             //设定服务器IP地址  
  67.             IPAddress ip = IPAddress.Parse("127.0.0.1");
  68.             Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  69.             try
  70.             {
  71.                 clientSocket.Connect(new IPEndPoint(ip, 2000)); //配置服务器IP与端口  
  72.                 Console.WriteLine("连接服务器成功");
  73.             }
  74.             catch
  75.             {
  76.                 Console.WriteLine("连接服务器失败，请按回车键退出！");
  77.                 Console.ReadLine();
  78.                 return;
  79.             }
  81.             //循环读取输入数据
  82.             while (true)
  83.             {
  84.                 Console.WriteLine("请输入");
  85.                 string sentstr = Console.ReadLine();
  86.                 SentMsg(sentstr, clientSocket);
  87.             }
  88.         }
  91.         /// <summary>
  92.         /// 长连接，不释放资源
  93.         /// </summary>
  94.         /// <param name="sentstr"></param>
  95.         /// <param name="clientSocket"></param>
  96.         public static void SentMsg(string sentstr, Socket clientSocket)
  97.         {
  98.             string sendMessage = "你好";//发送到服务端的内容
  99.             sendMessage = sentstr;//发送到服务端的内容
  100.             //向服务器发送数据，需要发送中文则需要使用Encoding.UTF8.GetBytes()，否则会乱码
  101.             clientSocket.Send(Encoding.UTF8.GetBytes(sendMessage));
  102.             Console.WriteLine("向服务器发送消息：" + sendMessage);
  104.             //接受从服务器返回的信息
  105.             string recvStr = "";
  106.             byte[] recvBytes = new byte[1024];
  107.             int bytes;
  108.             bytes = clientSocket.Receive(recvBytes, recvBytes.Length, 0);    //从服务器端接受返回信息 
  109.             recvStr += Encoding.UTF8.GetString(recvBytes, 0, bytes);
  110.             Console.WriteLine("服务端发来消息：{0}", recvStr);    //回显服务器的返回信息
  111.             //clientSocket.Close();//关闭连接并释放资源//如果是长连接，注释掉close
  112.         }
  113.     }
  114. }