Home  >  Article  >  Backend Development  >  Tutorial on using the Socket framework in C#

Tutorial on using the Socket framework in C#

黄舟
黄舟Original
2017-09-18 11:19:151959browse

A recent project requires the use of Socket transmission issues, so I decided to study it and summarize and share what I learned. The following article mainly introduces you to the relevant information about the use of Socket simple and practical framework in C# .NET. , the article introduces it in detail through sample code, friends in need can refer to it.

Preface

When it comes to Socket, everyone must have been involved in it more or less, starting from the initial computer network course. TCP protocol, and Socket is a further encapsulation of the protocol, making it easier for our developers to communicate between software.

I just accepted a shared parking space lock project this week. It needs to use Socket to communicate with the hardware. To put it bluntly, it means sending instructions to the lock to control its opening or closing, and then opening the operation interface to the App to use it. It is convenient for testing and user use. The core of this is the use of Socket. After developing this function, I found it very inconvenient to use, so I spent 2 days abstracting its core functions and encapsulating them into a framework. Finally, I used this framework to reconstruct the original project and put it online. It greatly improves the scalability, robustness and fault tolerance of the software.

Principle that I firmly believe in: Everything is an object

Okay, no more nonsense, let’s enter the text

Text:

1. First, let’s briefly talk about the simple use of Socket in C#.

Step 1: The server listens to a certain port

Step 2: The client initiates a Socket connection request to the server address and port

Step 3 : The server creates a Socket connection after receiving the connection request and maintains the connection queue.

Step 4: The client and server have established duplex communication (ie, two-way communication). The client and server can send information to each other easily and conveniently.

As for the specific implementation codes for simple use, I have encapsulated them into the project. If you need to learn simple implementation, you can look at my source code, or you can Baidu yourself. There are many tutorials

2. Core, use of framework

In fact, it may be a bit far-fetched to say it is a framework, because everyone has their own understanding of the framework, but what is the essence of class libraries and frameworks? What's the difference? It’s all code~haha, I’m going too far.

First of all, let’s put all the code first:

Server source file:

SocketServer.cs


using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;

namespace Coldairarrow.Util.Sockets
{
 /// <summary>
 /// Socket服务端
 /// </summary>
 public class SocketServer
 {
  #region 构造函数

  /// <summary>
  /// 构造函数
  /// </summary>
  /// <param name="ip">监听的IP地址</param>
  /// <param name="port">监听的端口</param>
  public SocketServer(string ip, int port)
  {
   _ip = ip;
   _port = port;
  }

  /// <summary>
  /// 构造函数,监听IP地址默认为本机0.0.0.0
  /// </summary>
  /// <param name="port">监听的端口</param>
  public SocketServer(int port)
  {
   _ip = "0.0.0.0";
   _port = port;
  }

  #endregion

  #region 内部成员

  private Socket _socket = null;
  private string _ip = "";
  private int _port = 0;
  private bool _isListen = true;
  private void StartListen()
  {
   try
   {
    _socket.BeginAccept(asyncResult =>
    {
     try
     {
      Socket newSocket = _socket.EndAccept(asyncResult);

      //马上进行下一轮监听,增加吞吐量
      if (_isListen)
       StartListen();

      SocketConnection newClient = new SocketConnection(newSocket, this)
      {
       HandleRecMsg = HandleRecMsg == null ? null : new Action<byte[], SocketConnection, SocketServer>(HandleRecMsg),
       HandleClientClose = HandleClientClose == null ? null : new Action<SocketConnection, SocketServer>(HandleClientClose),
       HandleSendMsg = HandleSendMsg == null ? null : new Action<byte[], SocketConnection, SocketServer>(HandleSendMsg),
       HandleException = HandleException == null ? null : new Action<Exception>(HandleException)
      };

      newClient.StartRecMsg();
      ClientList.AddLast(newClient);

      HandleNewClientConnected?.Invoke(this, newClient);
     }
     catch (Exception ex)
     {
      HandleException?.Invoke(ex);
     }
    }, null);
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
   }
  }

  #endregion

  #region 外部接口

  /// <summary>
  /// 开始服务,监听客户端
  /// </summary>
  public void StartServer()
  {
   try
   {
    //实例化套接字(ip4寻址协议,流式传输,TCP协议)
    _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    //创建ip对象
    IPAddress address = IPAddress.Parse(_ip);
    //创建网络节点对象包含ip和port
    IPEndPoint endpoint = new IPEndPoint(address, _port);
    //将 监听套接字绑定到 对应的IP和端口
    _socket.Bind(endpoint);
    //设置监听队列长度为Int32最大值(同时能够处理连接请求数量)
    _socket.Listen(int.MaxValue);
    //开始监听客户端
    StartListen();
    HandleServerStarted?.Invoke(this);
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
   }
  }

  /// <summary>
  /// 所有连接的客户端列表
  /// </summary>
  public LinkedList<SocketConnection> ClientList { get; set; } = new LinkedList<SocketConnection>();

  /// <summary>
  /// 关闭指定客户端连接
  /// </summary>
  /// <param name="theClient">指定的客户端连接</param>
  public void CloseClient(SocketConnection theClient)
  {
   theClient.Close();
  }

  #endregion

  #region 公共事件

  /// <summary>
  /// 异常处理程序
  /// </summary>
  public Action<Exception> HandleException { get; set; }

  #endregion

  #region 服务端事件

  /// <summary>
  /// 服务启动后执行
  /// </summary>
  public Action<SocketServer> HandleServerStarted { get; set; }

  /// <summary>
  /// 当新客户端连接后执行
  /// </summary>
  public Action<SocketServer, SocketConnection> HandleNewClientConnected { get; set; }

  /// <summary>
  /// 服务端关闭客户端后执行
  /// </summary>
  public Action<SocketServer, SocketConnection> HandleCloseClient { get; set; }

  #endregion

  #region 客户端连接事件

  /// <summary>
  /// 客户端连接接受新的消息后调用
  /// </summary>
  public Action<byte[], SocketConnection, SocketServer> HandleRecMsg { get; set; }

  /// <summary>
  /// 客户端连接发送消息后回调
  /// </summary>
  public Action<byte[], SocketConnection, SocketServer> HandleSendMsg { get; set; }

  /// <summary>
  /// 客户端连接关闭后回调
  /// </summary>
  public Action<SocketConnection, SocketServer> HandleClientClose { get; set; }

  #endregion
 }
}


using System;
using System.Net.Sockets;
using System.Text;

namespace Coldairarrow.Util.Sockets
{
 /// <summary>
 /// Socket连接,双向通信
 /// </summary>
 public class SocketConnection
 {
  #region 构造函数

  public SocketConnection(Socket socket,SocketServer server)
  {
   _socket = socket;
   _server = server;
  }

  #endregion

  #region 私有成员
  
  private readonly Socket _socket;
  private bool _isRec=true;
  private SocketServer _server = null;
  private bool IsSocketConnected()
  {
   bool part1 = _socket.Poll(1000, SelectMode.SelectRead);
   bool part2 = (_socket.Available == 0);
   if (part1 && part2)
    return false;
   else
    return true;
  }

  #endregion

  #region 外部接口

  /// <summary>
  /// 开始接受客户端消息
  /// </summary>
  public void StartRecMsg()
  {
   try
   {
    byte[] container = new byte[1024 * 1024 * 2];
    _socket.BeginReceive(container, 0, container.Length, SocketFlags.None, asyncResult =>
    {
     try
     {
      int length = _socket.EndReceive(asyncResult);

      //马上进行下一轮接受,增加吞吐量
      if (length > 0 && _isRec && IsSocketConnected())
       StartRecMsg();

      if (length > 0)
      {
       byte[] recBytes = new byte[length];
       Array.Copy(container, 0, recBytes, 0, length);

       //处理消息
       HandleRecMsg?.Invoke(recBytes, this, _server);
      }
      else
       Close();
     }
     catch (Exception ex)
     {
      HandleException?.Invoke(ex);
      Close();
     }
    }, null);
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
    Close();
   }
  }

  /// <summary>
  /// 发送数据
  /// </summary>
  /// <param name="bytes">数据字节</param>
  public void Send(byte[] bytes)
  {
   try
   {
    _socket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, asyncResult =>
    {
     try
     {
      int length = _socket.EndSend(asyncResult);
      HandleSendMsg?.Invoke(bytes, this, _server);
     }
     catch (Exception ex)
     {
      HandleException?.Invoke(ex);
     }
    }, null);
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
   }
  }

  /// <summary>
  /// 发送字符串(默认使用UTF-8编码)
  /// </summary>
  /// <param name="msgStr">字符串</param>
  public void Send(string msgStr)
  {
   Send(Encoding.UTF8.GetBytes(msgStr));
  }

  /// <summary>
  /// 发送字符串(使用自定义编码)
  /// </summary>
  /// <param name="msgStr">字符串消息</param>
  /// <param name="encoding">使用的编码</param>
  public void Send(string msgStr,Encoding encoding)
  {
   Send(encoding.GetBytes(msgStr));
  }

  /// <summary>
  /// 传入自定义属性
  /// </summary>
  public object Property { get; set; }

  /// <summary>
  /// 关闭当前连接
  /// </summary>
  public void Close()
  {
   try
   {
    _isRec = false;
    _socket.Disconnect(false);
    _server.ClientList.Remove(this);
    HandleClientClose?.Invoke(this, _server);
    _socket.Close();
    _socket.Dispose();
    GC.Collect();
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
   }
  }

  #endregion

  #region 事件处理

  /// <summary>
  /// 客户端连接接受新的消息后调用
  /// </summary>
  public Action<byte[], SocketConnection, SocketServer> HandleRecMsg { get; set; }

  /// <summary>
  /// 客户端连接发送消息后回调
  /// </summary>
  public Action<byte[], SocketConnection, SocketServer> HandleSendMsg { get; set; }

  /// <summary>
  /// 客户端连接关闭后回调
  /// </summary>
  public Action<SocketConnection, SocketServer> HandleClientClose { get; set; }

  /// <summary>
  /// 异常处理程序
  /// </summary>
  public Action<Exception> HandleException { get; set; }

  #endregion
 }
}


using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace Coldairarrow.Util.Sockets
{
 /// <summary>
 /// Socket客户端
 /// </summary>
 public class SocketClient
 {
  #region 构造函数

  /// <summary>
  /// 构造函数,连接服务器IP地址默认为本机127.0.0.1
  /// </summary>
  /// <param name="port">监听的端口</param>
  public SocketClient(int port)
  {
   _ip = "127.0.0.1";
   _port = port;
  }

  /// <summary>
  /// 构造函数
  /// </summary>
  /// <param name="ip">监听的IP地址</param>
  /// <param name="port">监听的端口</param>
  public SocketClient(string ip, int port)
  {
   _ip = ip;
   _port = port;
  }

  #endregion

  #region 内部成员

  private Socket _socket = null;
  private string _ip = "";
  private int _port = 0;
  private bool _isRec=true;
  private bool IsSocketConnected()
  {
   bool part1 = _socket.Poll(1000, SelectMode.SelectRead);
   bool part2 = (_socket.Available == 0);
   if (part1 && part2)
    return false;
   else
    return true;
  }

  /// <summary>
  /// 开始接受客户端消息
  /// </summary>
  public void StartRecMsg()
  {
   try
   {
    byte[] container = new byte[1024 * 1024 * 2];
    _socket.BeginReceive(container, 0, container.Length, SocketFlags.None, asyncResult =>
    {
     try
     {
      int length = _socket.EndReceive(asyncResult);

      //马上进行下一轮接受,增加吞吐量
      if (length > 0 && _isRec && IsSocketConnected())
       StartRecMsg();

      if (length > 0)
      {
       byte[] recBytes = new byte[length];
       Array.Copy(container, 0, recBytes, 0, length);

       //处理消息
       HandleRecMsg?.Invoke(recBytes, this);
      }
      else
       Close();
     }
     catch (Exception ex)
     {
      HandleException?.Invoke(ex);
      Close();
     }
    }, null);
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
    Close();
   }
  }

  #endregion

  #region 外部接口

  /// <summary>
  /// 开始服务,连接服务端
  /// </summary>
  public void StartClient()
  {
   try
   {
    //实例化 套接字 (ip4寻址协议,流式传输,TCP协议)
    _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    //创建 ip对象
    IPAddress address = IPAddress.Parse(_ip);
    //创建网络节点对象 包含 ip和port
    IPEndPoint endpoint = new IPEndPoint(address, _port);
    //将 监听套接字 绑定到 对应的IP和端口
    _socket.BeginConnect(endpoint, asyncResult =>
    {
     try
     {
      _socket.EndConnect(asyncResult);
      //开始接受服务器消息
      StartRecMsg();

      HandleClientStarted?.Invoke(this);
     }
     catch (Exception ex)
     {
      HandleException?.Invoke(ex);
     }
    }, null);
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
   }
  }

  /// <summary>
  /// 发送数据
  /// </summary>
  /// <param name="bytes">数据字节</param>
  public void Send(byte[] bytes)
  {
   try
   {
    _socket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, asyncResult =>
    {
     try
     {
      int length = _socket.EndSend(asyncResult);
      HandleSendMsg?.Invoke(bytes, this);
     }
     catch (Exception ex)
     {
      HandleException?.Invoke(ex);
     }
    }, null);
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
   }
  }

  /// <summary>
  /// 发送字符串(默认使用UTF-8编码)
  /// </summary>
  /// <param name="msgStr">字符串</param>
  public void Send(string msgStr)
  {
   Send(Encoding.UTF8.GetBytes(msgStr));
  }

  /// <summary>
  /// 发送字符串(使用自定义编码)
  /// </summary>
  /// <param name="msgStr">字符串消息</param>
  /// <param name="encoding">使用的编码</param>
  public void Send(string msgStr, Encoding encoding)
  {
   Send(encoding.GetBytes(msgStr));
  }

  /// <summary>
  /// 传入自定义属性
  /// </summary>
  public object Property { get; set; }

  /// <summary>
  /// 关闭与服务器的连接
  /// </summary>
  public void Close()
  {
   try
   {
    _isRec = false;
    _socket.Disconnect(false);
    HandleClientClose?.Invoke(this);
   }
   catch (Exception ex)
   {
    HandleException?.Invoke(ex);
   }
  }

  #endregion

  #region 事件处理

  /// <summary>
  /// 客户端连接建立后回调
  /// </summary>
  public Action<SocketClient> HandleClientStarted { get; set; }

  /// <summary>
  /// 处理接受消息的委托
  /// </summary>
  public Action<byte[], SocketClient> HandleRecMsg { get; set; }

  /// <summary>
  /// 客户端连接发送消息后回调
  /// </summary>
  public Action<byte[], SocketClient> HandleSendMsg { get; set; }

  /// <summary>
  /// 客户端连接关闭后回调
  /// </summary>
  public Action<SocketClient> HandleClientClose { get; set; }

  /// <summary>
  /// 异常处理程序
  /// </summary>
  public Action<Exception> HandleException { get; set; }

  #endregion
 }
}

The above is the framework code, which will be introduced next. How to use

First of all, how to use the server:


using Coldairarrow.Util.Sockets;
using System;
using System.Text;

namespace Console_Server
{
 class Program
 {
  static void Main(string[] args)
  {
   //创建服务器对象,默认监听本机0.0.0.0,端口12345
   SocketServer server = new SocketServer(12345);

   //处理从客户端收到的消息
   server.HandleRecMsg = new Action<byte[], SocketConnection, SocketServer>((bytes, client, theServer) =>
   {
    string msg = Encoding.UTF8.GetString(bytes);
    Console.WriteLine($"收到消息:{msg}");
   });

   //处理服务器启动后事件
   server.HandleServerStarted = new Action<SocketServer>(theServer =>
   {
    Console.WriteLine("服务已启动************");
   });

   //处理新的客户端连接后的事件
   server.HandleNewClientConnected = new Action<SocketServer, SocketConnection>((theServer, theCon) =>
   {
    Console.WriteLine($@"一个新的客户端接入,当前连接数:{theServer.ClientList.Count}");
   });

   //处理客户端连接关闭后的事件
   server.HandleClientClose = new Action<SocketConnection, SocketServer>((theCon, theServer) =>
   {
    Console.WriteLine($@"一个客户端关闭,当前连接数为:{theServer.ClientList.Count}");
   });

   //处理异常
   server.HandleException = new Action<Exception>(ex =>
   {
    Console.WriteLine(ex.Message);
   });

   //服务器启动
   server.StartServer();

   while (true)
   {
    Console.WriteLine("输入:quit,关闭服务器");
    string op = Console.ReadLine();
    if (op == "quit")
     break;
   }
  }
 }
}

How to use the client:


##

using Coldairarrow.Util.Sockets;
using System;
using System.Text;

namespace Console_Client
{
 class Program
 {
  static void Main(string[] args)
  {
   //创建客户端对象,默认连接本机127.0.0.1,端口为12345
   SocketClient client = new SocketClient(12345);

   //绑定当收到服务器发送的消息后的处理事件
   client.HandleRecMsg = new Action<byte[], SocketClient>((bytes, theClient) =>
   {
    string msg = Encoding.UTF8.GetString(bytes);
    Console.WriteLine($"收到消息:{msg}");
   });

   //绑定向服务器发送消息后的处理事件
   client.HandleSendMsg = new Action<byte[], SocketClient>((bytes, theClient) =>
   {
    string msg = Encoding.UTF8.GetString(bytes);
    Console.WriteLine($"向服务器发送消息:{msg}");
   });

   //开始运行客户端
   client.StartClient();

   while (true)
   {
    Console.WriteLine("输入:quit关闭客户端,输入其它消息发送到服务器");
    string str = Console.ReadLine();
    if (str == "quit")
    {
     client.Close();
     break;
    }
    else
    {
     client.Send(str);
    }
   }
  }
 }
}

Screenshot of the last running test:

Summary:

Its The most convenient thing is that how to create a connection is encapsulated. Users only need to pay attention to what data is sent after the connection, how to process the data after receiving it, and many other event processing, which mainly relies on the use of anonymous delegation. , the use of Lambda expressions.

The above is the detailed content of Tutorial on using the Socket framework in C#. For more information, please follow other related articles on the PHP Chinese website!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn