How to use sockets

The service side

public static void Proccess()
{
    int port = 2018;
    string host = "127.0.0.1";

    IPAddress ip = IPAddress.Parse(host);
    IPEndPoint ipe = new IPEndPoint(ip, port);

    Socket sSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    sSocket.Bind(ipe);
    sSocket.Listen(0);
    Console.WriteLine("Listening is on. Please wait.");

    // Receive a message to accept a socket link
    Socket serverSocket = sSocket.Accept();
    Console.WriteLine("Connection established...");
    while (true)
    {
        string recStr = "";
        byte[] recByte = new byte[4096];
        int bytes = serverSocket.Receive(recByte, recByte.Length, 0);
        recStr += Encoding.ASCII.GetString(recByte, 0, bytes);
        Console.WriteLine("Server side gets information :{0}", recStr);

        if (recStr.Equals("stop"))
        {
            serverSocket.Close();// Close the socket object
            Console.WriteLine("Close links...");
            break;
        }

        // Send the message back
        Console.WriteLine("Please enter a reply message...");
        string sendStr = Console.ReadLine(); //"send to client :hello world";
        byte[] sendByte = Encoding.ASCII.GetBytes(sendStr);
        serverSocket.Send(sendByte, sendByte.Length, 0);
    }
    sSocket.Close();// Disable server listening
}
Copy the code

The client

static void Main(string[] args)
{
    try
    {
        Console.WriteLine("Start a Socket client link"); 
        int port = 2018;
        string host = "127.0.0.1";// Server IP address
        IPAddress ip = IPAddress.Parse(host);
        IPEndPoint ipe = new IPEndPoint(ip, port); 
        Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        clientSocket.Connect(ipe); // Open the link, the link is long;
        while (true)
        {
            Console.WriteLine("Please enter the information sent to the server:");
            string sendStr = Console.ReadLine();
            if (sendStr == "exit")
                break;

            byte[] sendBytes = Encoding.ASCII.GetBytes(sendStr);
            clientSocket.Send(sendBytes);

            //receive message
            string recStr = "";
            byte[] recBytes = new byte[4096];
            // Monitor incoming messages;
            int bytes = clientSocket.Receive(recBytes, recBytes.Length, 0);
            recStr += Encoding.ASCII.GetString(recBytes, 0, bytes);
            Console.WriteLine($" The server returns:{recStr}");
        }
        clientSocket.Close();
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
    Console.Read();
}
Copy the code

Supersocket. Engine SuperSoket

1. Session: Each user connection is a Session
2. AppServer: indicates the Socket server instance
3. Commands: The set of Commands that a client sends messages to a server

Add the following configuration to the configuration file

<? xml version="1.0" encoding="utf-8"? > <configuration> <configSections> <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine"/>
  </configSections>
  <superSocket>
    <servers>
      <server name="ChatSocket" textEncoding="gb2312"
              serverType="XT.SocketService.AppServer.ChatServer,XT.SocketService"
              ip="Any" port="2020"
              maxConnectionNumber="100"> </server> <! -- Multiple servers can be configured --> </ Servers > </superSocket> <startup> <supportedRuntime version="v4.0" sku=". NETFramework, Version = v4.5. "" />
    </startup>
</configuration>
Copy the code

Example Create a ChatServer service

[AuthorisizeFilter]
public class ChatServer:AppServer<ChatSession>
{
    protected override bool Setup(IRootConfig rootConfig, IServerConfig config)
    {
        Console.WriteLine("Ready to read configuration file...");
        return base.Setup(rootConfig, config);
    }

    protected override void OnStarted()
    {
        Console.WriteLine("Chat service started...");
        base.OnStarted();
    }

    protected override void OnStopped()
    {
        Console.WriteLine("Chat service stopped...");
        base.OnStopped();
    }

    /// <summary>
    ///A new connection
    /// </summary>
    /// <param name="session"></param>
    protected override void OnNewSessionConnected(ChatSession session)
    {
        Console.WriteLine($" new connections added to Chat:{session.LocalEndPoint.Address.ToString()}");
        base.OnNewSessionConnected(session); }}Copy the code

class AuthorisizeFilterAttribute : CommandFilterAttribute
{
    public override void OnCommandExecuting(CommandExecutingContext commandContext)
    {
        ChatSession session = (ChatSession)commandContext.Session;
        string command = commandContext.CurrentCommand.Name;
        if(! session.IsLogin) {if(! command.Equals("Check"))
            {
                session.Send("Please log in first and then operate...");
                commandContext.Cancel = true;// Don't go any further;
            }
            else
            { 
                ///.}}else if (!session.IsOnLine)
        {
            session.LastHbTime = DateTime.Now;
        } 
    }
    public override void OnCommandExecuted(CommandExecutingContext commandContext)
    {
        //throw new NotImplementedException();}}Copy the code

Create a Session service

/// <summary>
///Represents user connection
/// </summary>
//[AuthorisizeFilter]
public class ChatSession : AppSession<ChatSession>
{
    public string Id { get; set; }

    public string PassWord { get; set; }

    public bool IsLogin { get; set; }

    public DateTime LoginTime { get; set; }

    public DateTime LastHbTime { get; set; }

    public bool IsOnline
    { 
        get
        {
            return this.LastHbTime.AddSeconds(10) > DateTime.Now; }}/// <summary>
    ///Message is sent
    /// </summary>
    /// <param name="message"></param>
    public override void Send(string message)
    {
        Console.WriteLine($" ready to send to{this.Id}:{message}");
        base.Send(message.Format());
    }

    protected override void OnSessionStarted()
    {
        this.Send("Welcome to SuperSocket Chat Server");
    }

    protected override void OnInit()
    {
        this.Charset = Encoding.GetEncoding("gb2312");
        base.OnInit();
    }

    protected override void HandleUnknownRequest(StringRequestInfo requestInfo)
    {
        Console.WriteLine("Received orders :" + requestInfo.Key.ToString());
        this.Send("I don't know what to do with it." + requestInfo.Key.ToString() + "Command");
    }

    /// <summary>
    ///Abnormal capture
    /// </summary>
    /// <param name="e"></param>
    protected override void HandleException(Exception e)
    {
        this.Send($"\n\r{ e.Message}");
        //base.HandleException(e);
    }

    /// <summary>
    ///Connection is closed
    /// </summary>
    /// <param name="reason"></param>
    protected override void OnSessionClosed(CloseReason reason)
    {
        Console.WriteLine("Link closed...");
        base.OnSessionClosed(reason); }}Copy the code

The client sends message Commands Check 1 123456 Check indicates the class name, 1 indicates session.id (session ID), 1 indicates session.PassWord (session PassWord)

public class Check : CommandBase<ChatSession.StringRequestInfo>
{
    public override void ExecuteCommand(ChatSession session, StringRequestInfo requestInfo)
    {
        if(requestInfo.Parameters ! =null && requestInfo.Parameters.Length == 2)
        {
            ChatSession oldSession = session.AppServer.GetAllSessions().FirstOrDefault(a => requestInfo.Parameters[0].Equals(a.Id));
            if(oldSession ! =null) // said that a user had logged in with this Id before
            {
                oldSession.Send("Your account has been logged in elsewhere. You have been kicked off.");
                oldSession.Close();
            }

            #regionThis is where you can connect to the database for data validation and login
            ///---------------------
            #endregion
            session.Id = requestInfo.Parameters[0];
            session.PassWord = requestInfo.Parameters[1];
            session.IsLogin = true;
            session.LoginTime = DateTime.Now;

            session.Send("Login successful");

            { // Get the offline message of the current logged-in user
                ChatDataManager.SendLogin(session.Id, c =>
                { 
                    session.Send($"{c.FromId}Send you a message:{c.Message} {c.Id}"); }); }}else
        {
            session.Send("Parameter error"); }}}Copy the code

Classes related to offline message stores

public class ChatDataManager
{
    /// <summary>
    ///Key is the user ID
    ///List All messages for the user
    /// </summary>
    private static Dictionary<string.List<ChatModel>> Dictionary = new Dictionary<string, List<ChatModel>>();

    public static void Add(string userId, ChatModel model)
    {
        if (Dictionary.ContainsKey(userId))
        {
            Dictionary[userId].Add(model);
        }
        else
        {
            Dictionary[userId] = newList<ChatModel>() { model }; }}public static void Remove(string userId, string modelId)
    {
        if (Dictionary.ContainsKey(userId))
        {
            Dictionary[userId] = Dictionary[userId].Where(m => m.Id != modelId).ToList();
        }
    }

    public static void SendLogin(string userId, Action<ChatModel> action)
    {
        if (Dictionary.ContainsKey(userId))
        {
            foreach (var item in Dictionary[userId])
            {
                action.Invoke(item);
                item.State = 1; }}}}Copy the code

/// <summary>
///A record of a message
/// </summary>
public class ChatModel
{
    /// <summary>
    ///Each entry is assigned a unique Id
    /// </summary>
    public string Id { get; set; }
    /// <summary>
    ///Source code
    /// </summary>
    public string FromId { get; set; }
    /// <summary>
    ///The target number
    /// </summary>
    public string ToId { get; set; }
    /// <summary>
    ///The message content
    /// </summary>
    public string Message { get; set; }
    /// <summary>
    ///The message of time
    /// </summary>
    public DateTime CreateTime { get; set; }
    /// <summary>
    ///Message status 0 Unsent 1 Sent to be confirmed 2 Received
    /// </summary>
    public int State { get; set; }}Copy the code

Basic use to get offline messages

public class Chat : CommandBase<ChatSession.StringRequestInfo>
{
   public override void ExecuteCommand(ChatSession session, StringRequestInfo requestInfo)
   {
       // Again, two parameters are passed: 1, to whom to send ToId, 2, message content
       if(requestInfo.Parameters ! =null && requestInfo.Parameters.Length == 2)
       {
           string toId = requestInfo.Parameters[0];
           string message = requestInfo.Parameters[1];
           ChatSession toSession = session.AppServer.GetAllSessions().FirstOrDefault(a => toId.Equals(a.Id));
            
           string modelId = Guid.NewGuid().ToString();
           if(toSession ! =null) // said that a user had logged in with this Id before
           {
               toSession.Send($"{session.Id}Send you a message:{message} {modelId}");
               ChatDataManager.Add(toId, new ChatModel()
               {
                   FromId = session.Id,
                   ToId = toId,
                   Message = message,
                   Id = modelId,
                   State = 1./ / to be confirmed
                   CreateTime = DateTime.Now
               });
           }
           else
           {
               ChatDataManager.Add(toId, new ChatModel()
               {
                   FromId = session.Id,
                   ToId = toId,
                   Message = message,
                   Id = modelId,
                   State = 0./ / not sent
                   CreateTime = DateTime.Now
               }); 
               session.Send("Message was not sent successfully"); }}else
       {
           session.Send("Parameter error"); }}}Copy the code

public class Confirm : CommandBase<ChatSession.StringRequestInfo>
{
    public override void ExecuteCommand(ChatSession session, StringRequestInfo requestInfo)
    { 
        if(requestInfo.Parameters ! =null && requestInfo.Parameters.Length == 1)
        {
            string modelId = requestInfo.Parameters[0]; 
            Console.WriteLine($" user{session.Id}Confirmed. Message received{modelId}");
            ChatDataManager.Remove(session.Id, modelId);
        }
        else
        {
            session.Send("Parameter error"); }}}Copy the code

Heartbeat detection: sends messages periodically and reconnects if no message is received

public class HB : CommandBase<ChatSession.StringRequestInfo>
{
    public override void ExecuteCommand(ChatSession session, StringRequestInfo requestInfo)
    {
        if(requestInfo.Parameters ! =null && requestInfo.Parameters.Length == 1)
        {
            if ("R".Equals(requestInfo.Parameters[0]))
            {
                session.LastHbTime = DateTime.Now;
                session.Send("R");
            }
            else
            {
                session.Send("Parameter error"); }}else
        {
            session.Send("Parameter error"); }}}Copy the code

use

public class SuperSocketMain
    {
         
        //1 SuperSocket is introduced and used
        //2 User login in chatroom & unique login
        //3 Sending an online message & confirming receipt & Offline message
        //4 Heartbeat detection mechanism & disconnection and reconnection
        //5 CommandFilterAttribute AOP mechanism

        public static void Init()
        {
            // Can be configured through the configuration file to run the SuperSocket service;
            // Need to read the configuration file to start the service;
            try
            {
                // The service can be started by reading configuration files
                IBootstrap bootstrap = BootstrapFactory.CreateBootstrap();
                if(! bootstrap.Initialize()) { Console.WriteLine("Initialization failed");
                    Console.ReadKey();
                    return;
                }
                Console.WriteLine("Ready to start service");
                var result = bootstrap.Start();

                foreach (var server in bootstrap.AppServers)
                {
                    if (server.State == ServerState.Running)
                    {
                        Console.WriteLine($"{server.Name}In the operation of the");
                    }
                    else
                    {
                        Console.WriteLine($"{server.Name}Startup failed"); } } } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.Read(); }}Copy the code