C#网络连接：TCP/IP模式下的网络连接与同步

news2024/9/9 0:52:44

1，目的

为了测试局域网的消息同步，简单写了下TCP/IP模式的同步，参考这个帖子。

2，核心库部分

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
    }
}
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

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 * 6];
                _socket.BeginReceive(container, 0, container.Length, SocketFlags.None, asyncResult =>
                {
                    try
                    {
                        int length = _socket.EndReceive(asyncResult);
                        ///asyncResult.AsyncWaitHandle.Close();
                        //马上进行下一轮接受，增加吞吐量
                        if (length > 0 && _isRec && IsSocketConnected())
                            StartRecMsg();

                        if (length > 0)
                        {
                            byte[] recBytes = new byte[length];
                            Array.Copy(container, 0, recBytes, 0, length);
                            string msgJson = Encoding.UTF8.GetString(recBytes);
                            if (msgJson.Contains("¤€") && msgJson.Contains("€¤"))
                            {
                                string[] arrymsg = msgJson.Replace("¤€", "卍").Split('卍');
                                foreach (string msgitem in arrymsg)
                                {
                                    if (string.IsNullOrEmpty(msgitem))
                                        continue;
                                    if (msgitem.Substring(msgitem.Length - 2, 2) == "€¤")
                                    {
                                        string msgitemjson = msgitem.Substring(0, msgitem.Length - 2);
                                        //处理消息
                                        HandleRecMsg?.Invoke(msgitemjson, this, _server);
                                    }
                                }
                            }
                            else
                            {
                                HandleException?.Invoke(new Exception($"接收到错误指令，具体指令为：{msgJson}"));
                            }
                        }
                        else
                            Close();
                    }
                    catch (Exception ex)
                    {
                        HandleException?.Invoke(ex);
                        Close();
                    }
                }, null);
            }
            catch (Exception ex)
            {
                HandleException?.Invoke(ex);
                Close();
            }
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="bytes">数据字节</param>
        private 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);
                        UnityEngine.Debug.Log("发送成功");
                    }
                    catch (Exception ex)
                    {                        
                        HandleSendException?.Invoke(ex);
                        UnityEngine.Debug.Log("发送"+ex);
                    }
                }, null);
            }
            catch (Exception ex)
            {
                HandleSendException?.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<string, 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; }


        /// <summary>
        /// 发送消息到客户端异常
        /// </summary>
        public Action<Exception> HandleSendException { get; set; }


        #endregion
    }
}
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace Coldairarrow.Util.Sockets
{
    /// <summary>
    /// Socket服务端
    /// </summary>
    public class SocketServer
    {
        private static string ipAddressStr = "127.0.0.1";//IP地址字符串
        private static int port = 5500;//端口

        #region 内部成员

        private Socket _socket = null;

        private bool _isListen = true;
        public static ManualResetEvent allDone = new ManualResetEvent(false);
        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<string, 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),
                            HandleSendException = HandleSendException == null ? null : new Action<Exception>(HandleSendException)
                        };

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

                        HandleNewClientConnected?.Invoke(this, newClient);
                    }
                    catch (Exception ex)
                    {
                        //UnityEngine.Debug.LogError(ex);
                        HandleException?.Invoke(ex);
                    }
                }, null);
            }
            catch (Exception ex)
            {
                //UnityEngine.Debug.LogError(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(ipAddressStr);
                //创建网络节点对象包含ip和port
                IPEndPoint endpoint = new IPEndPoint(address, port);
                //将 监听套接字绑定到 对应的IP和端口
                _socket.Bind(endpoint);
                //设置监听队列长度为Int32最大值(同时能够处理连接请求数量)
                _socket.Listen(int.MaxValue);
                //开始监听客户端
                StartListen();
                HandleServerStarted?.Invoke(this);
            }
            catch (Exception ex)
            {
                StartException?.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; }

        /// <summary>
        /// 发送消息异常处理程序
        /// </summary>
        public Action<Exception> HandleSendException { get; set; }

        /// <summary>
        /// 启动异常程序
        /// </summary>
        public Action<Exception> StartException { 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<string, 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
    }
}

3，服务器测试部分

using Coldairarrow.Util.Sockets;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class MySever : MonoBehaviour
{

    private System.Object obj=new System.Object();

    private class ParamEntity
    {
        public string ParamFace;
        public SocketConnection socketClient;
    }

    private List<ParamEntity> paramList=new List<ParamEntity> ();

    private bool IsRun = false;

    SocketServer server;

    void Start()
    {
        //创建服务器对象，默认监听本机0.0.0.0，端口12345
        server = new SocketServer();

        //处理从客户端收到的消息
        server.HandleRecMsg = new Action<string, SocketConnection, SocketServer>((msg, client, theServer) =>
        {
            Debug.Log($"调用次数");
            lock (obj)
            {
                paramList.Add(new ParamEntity() { ParamFace = msg, socketClient = client });
                if (IsRun == false)
                {
                    IsRun = true;
                    HandleMsg();
                }
            }
        });

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

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

        //处理客户端连接关闭后的事件
        server.HandleClientClose = new Action<SocketConnection, SocketServer>((theCon, theServer) =>
        {
            Debug.Log($@"一个客户端关闭，当前连接数为：{theServer.ClientList.Count}");
        });
        //处理异常
        server.HandleException = new Action<Exception>(ex =>
        {
            Debug.Log("Socket处理异常：" + ex.Message);
        });
        //处理异常
        server.HandleSendException = new Action<Exception>(ex =>
        {
            Debug.Log("Socket发送消息处理异常：" + ex.Message);
        });
        ///启动异常
        server.StartException = new Action<Exception>(ex =>
        {
            Debug.Log("Socket服务启动失败：" + ex.Message);
        });


        //服务器启动
        server.StartServer();
        Debug.Log("启动Socket通信服务端完成。");
    }

    void HandleMsg()
    {
        Debug.LogError("HandleMsg");
        var _p = paramList[0];
        Debug.Log(_p.ParamFace);

        //方法1：返回给所有人（可以做挑选）
        var _list= server.ClientList;
        foreach (var _item in _list)
        {
            _item.Send("收到转发:" + _p.ParamFace);
        }
       

        //方法2：仅返回给对应用户
        //_p.socketClient.Send(_p.ParamFace);

        paramList.Clear();
        IsRun = false;
    }



    // Update is called once per frame
    void Update()
    {

    }
}

*这里要注意，如果只需要返回给需要的客户端，用方法2即可

4，客户端测试部分

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Face.SocketClient
{
    /// <summary>
    /// Socket客户端
    /// </summary>
    public class SocketClient
    {
        private string ipAddressStr = "127.0.0.1";//IP地址字符串
        private int port = 5500;//端口


        #region 内部成员

        private Socket _socket = null;

        private bool _isRec = true;
        private bool _IsRun = false;
        public bool IsRun { get { return _IsRun; } }
        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);

                            string msgJson = Encoding.UTF8.GetString(recBytes);
                            if (msgJson.Contains("¤€") && msgJson.Contains("€¤"))
                            {
                                string[] arrymsg = msgJson.Replace("¤€", "卍").Split('卍');
                                foreach (string msgitem in arrymsg)
                                {
                                    if (string.IsNullOrEmpty(msgitem))
                                        continue;
                                    if (msgitem.Substring(msgitem.Length - 2, 2) == "€¤")
                                    {
                                        string msgitemjson = msgitem.Substring(0, msgitem.Length - 2);
                                        //处理消息
                                        HandleRecMsg?.Invoke(msgitemjson, this);
                                    }
                                }
                            }
                            else
                            {
                                HandleException?.Invoke(new Exception($"接收到错误指令，具体指令为：{msgJson}"));
                            }
                        }
                        else
                            Close();
                    }
                    catch (Exception ex)
                    {
                        if (ex.Message.Contains("远程主机强迫关闭"))
                        {
                            _IsRun = false;
                        }
                        HandleException?.Invoke(ex);
                        Close();
                    }
                }, null);
            }
            catch (Exception ex)
            {
                if (ex.Message.Contains("远程主机强迫关闭"))
                {
                    _IsRun = false;
                }
                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(ipAddressStr);
                //创建网络节点对象 包含 ip和port
                IPEndPoint endpoint = new IPEndPoint(address, port);

                //将 监听套接字  绑定到 对应的IP和端口
                _socket.BeginConnect(endpoint, asyncResult =>
                {
                    try
                    {
                        _socket.EndConnect(asyncResult);
                        //开始接受服务器消息
                        StartRecMsg();
                        _IsRun = true;
                        HandleClientStarted?.Invoke(this);

                    }
                    catch (Exception ex)
                    {
                        _IsRun = false;
                        StartException?.Invoke(ex);
                    }
                }, null);
            }
            catch (Exception ex)
            {
                _IsRun = false;
                StartException?.Invoke(ex);
            }
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="bytes">数据字节</param>
        private void Send(byte[] bytes)
        {
            try
            {
                //Thread.Sleep(250);
                _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<string, 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> StartException { get; set; }
        /// <summary>
        /// 异常处理程序
        /// </summary>
        public Action<Exception> HandleException { get; set; }

        #endregion
    }

}
using Coldairarrow.Util.Sockets;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class MyClient : MonoBehaviour
{

    private SocketClient client;

    public string test = "hellow222";

    // Start is called before the first frame update
    void Start()
    {
        client = new SocketClient() ;
        client.StartClient();
        client.Send(test);
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

5，测试结果

服务器：

客户端1：

客户端2：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1958745.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【React】useEffect 钩子详解

【React】useEffect 钩子详解

文章目录 一、useEffect 概念二、useEffect 的基本用法1. 无依赖项2. 空依赖项数组3. 带依赖项的 useEffect 三、useEffect 的常见应用场景1. 数据获取2. 订阅与清除3. 动画与定时器 四、useEffect 的进阶用法1. 多个 useEffect2. 条件执行副作用 五、注意事项 useEffect 是 Re…
阅读更多...
playbooks 分布式部署 LNMP

playbooks 分布式部署 LNMP

1、环境配置 ansible 服务器 192.168.10.10nginx 服务器 192.168.10.20mysql 服务器 192.168.10.21php 服务器 192.168.10.22 2、安装 ansble #192.168.10.10节点 yum install -y epel-release #先安装 epel 源 yum install -y ansible配置主机清单 …
阅读更多...
Vue 动态改变css文件

Vue 动态改变css文件

theme: smartblue 一、背景需求 现有 Vue3 项目&#xff0c;要求点击按钮后&#xff0c;会动态加载css文件内容 二、实现过程 2.1 相关代码 假设有 blue.css 和 red.css,要求点击加载对应文件 若想切换为原版样式&#xff0c;点击 back 回退到初始样式 this is a simple text …
阅读更多...
76.SAP ME - 归档

76.SAP ME - 归档

目录 1.归档 2.系统设置维护 3.后台处理执行 1.归档 可使用此功能将某一特定已完成产品的相关记录从活动的“在制品”(WIP) 数据库移动到归档数据库&#xff0c;这样可改进生产记录的检索。在一段时间内&#xff0c;WIP 数据库中的记录数量将增加。当系统在大量记录中进行搜…
阅读更多...
c++ 内存管理（newdeletedelete[]）

c++ 内存管理（newdeletedelete[]）

因为在c里面新增了类&#xff0c;所以我们在有时候会用malloc来创建类&#xff0c;但是这种创建只是单纯的开辟空间&#xff0c;没有什么默认构造的。同时free也是free的表面&#xff0c;如果类里面带有指针指向堆区的成员变量就会free不干净。 所以我们c增加了new delete和de…
阅读更多...
pdf太大怎么压缩大小？这几种压缩方法操作起来很简单！

pdf太大怎么压缩大小？这几种压缩方法操作起来很简单！

pdf太大怎么压缩大小&#xff1f;在数字化洪流席卷的当下&#xff0c;PDF文件的“臃肿”难题如同巨石般横亘于高效办公之路&#xff0c;它们不仅贪婪地吞噬着宝贵的存储空间&#xff0c;更如沉重的枷锁&#xff0c;拖曳着我们的工作进度&#xff0c;步入迟缓之境&#xff0c;试…
阅读更多...
油管125万粉丝顶级交易员授课#2-1

油管125万粉丝顶级交易员授课#2-1

#
阅读更多...
06 内置的整数、实数与复数

06 内置的整数、实数与复数

在 Python 中&#xff0c;内置的数字类型有整数、实数和复数&#xff0c;借助于标准库 fractions 中的 Fraction 对象可以实现分数及其运算&#xff0c;而 fractions 中的 Decimal 类则实现了更高精度的运算。 Python 支持任意大的数字&#xff0c;具体可以大到什么程度仅受内…
阅读更多...
电阻液冷 可提升 3.3kV 中压负载-EAK水冷电阻器

电阻液冷 可提升 3.3kV 中压负载-EAK水冷电阻器

电阻液冷 可提升 3.3kV 中压负载-EAK水冷电阻器 在工业和海洋应用中&#xff0c;水冷在削减电阻器封装方面至关重要的地方 在起重机、升降机、升降机和输送机等电机驱动应用中&#xff0c;风冷电阻器很常见&#xff0c;但在中压、高功率应用中&#xff0c;液体冷却胜出。 使…
阅读更多...
IDEA项目的依赖(pom.xml文件)导入问题及解决

IDEA项目的依赖(pom.xml文件)导入问题及解决

前言&#xff1a;该文章为转载&#xff0c;没有仔细的看 IDEA新建项目和pom.xml文件被修改时&#xff0c;右下角都会出现 Maven projects need to be imported&#xff08;项目需要导入依赖&#xff09; 如下&#xff0c;点击 Import Changes导入后&#xff0c;有时会一直处于…
阅读更多...
【基础篇】Docker 概览 ONE

【基础篇】Docker 概览 ONE

嗨&#xff0c;大家好&#xff01;我是小竹笋&#xff0c;一名热爱创作的工程师。今天我将带领大家一起踏上探索 Docker 的奇妙之旅。我们先从 Docker 的历史和发展说起&#xff0c;然后再看看 Docker 和虚拟机之间的区别&#xff0c;最后了解一下 Docker 在各行各业的应用情况…
阅读更多...
数据结构算法经典题目刨析（c语言）返回单链表的倒数第 k 个节点

数据结构算法经典题目刨析（c语言）返回单链表的倒数第 k 个节点

&#x1f493; 博客主页&#xff1a;C-SDN花园GGbond ⏩ 文章专栏&#xff1a;数据结构经典题目刨析(c语言) 一.题目描述 二.解题思路 方法一:计数器方式 先遍历链表&#xff0c;求出链表长度count倒数第k个节点&#xff0c;就是正数第count-k1个节点&#xff08;下标为count…
阅读更多...
《系统架构设计师教程（第2版）》第13章-层次式架构设计理论与实践-02-表现层框架设计

《系统架构设计师教程（第2版）》第13章-层次式架构设计理论与实践-02-表现层框架设计

文章目录 1. 表现层设计模式1.1 MVC模式1.1.1 三个核心模块1&#xff09;控制器 (Controller)2&#xff09;模型 (Model)3&#xff09;视图 (View): 1.1.2 过程1.1.3 优点1.1.4 应用 1.2 MVP模式1.3 MVVM模式 2. 使用XML设计表现层统一Web Form与 Windows Form的外观3. 表现层中…
阅读更多...
⚠️ Buffer Overflow: 安全编码必备知识 ️

⚠️ Buffer Overflow: 安全编码必备知识 ️

⚠️ Buffer Overflow: 安全编码必备知识 &#x1f6e1;️ ⚠️ Buffer Overflow: 安全编码必备知识 &#x1f6e1;️摘要引言正文内容一、缓冲区溢出基本概念 &#x1f9e9;二、常见场景及实际案例 &#x1f6e0;️2.1 利用不安全的函数2.2 堆溢出攻击 三、调试技巧 &#x1f…
阅读更多...
算法入门：Java实现排序、查找算法

算法入门：Java实现排序、查找算法

链接&#xff1a;算法入门&#xff1a;Java实现排序、查找算法 (qq.com) 冒泡/选择/插入/希尔排序代码 (qq.com) 快排/归并/堆排/基数排序代码 (qq.com)
阅读更多...
Python酷库之旅-第三方库Pandas(053)

Python酷库之旅-第三方库Pandas(053)

目录 一、用法精讲 196、pandas.Series.first方法 196-1、语法 196-2、参数 196-3、功能 196-4、返回值 196-5、说明 196-6、用法 196-6-1、数据准备 196-6-2、代码示例 196-6-3、结果输出 197、pandas.Series.head方法 197-1、语法 197-2、参数 197-3、功能 1…
阅读更多...
【C++题解】1069. 字符图形5-星号梯形

【C++题解】1069. 字符图形5-星号梯形

问题&#xff1a;1069. 字符图形5-星号梯形 类型&#xff1a;嵌套循环、图形输出 题目描述&#xff1a; 打印字符图形。 输入&#xff1a; 一个整数&#xff08; 0<n<10 &#xff09;。 输出&#xff1a; 一个字符图形。 样例&#xff1a; 输入&#xff1a; 3输…
阅读更多...
卷积神经网络（三）---案例分析

卷积神经网络（三）---案例分析

上面部分介绍了 PyTorch 中的卷积模块&#xff0c;接下来将会介绍几个卷积神经网络的案例&#xff0c;通过案例入手来介绍卷积神经网络的结构设计。 1. LeNet LeNet 是整个卷积神经网络的开山之作&#xff0c;1998年由 LeCun 提出&#xff0c;它的结构特别简单&#xff0c;我们…
阅读更多...
看懂循环队列

看懂循环队列

循环队列的设计过程 1.循环队列2.设计循环队列的逻辑过程2.1 定义循环队列的数据结构2.2 初始化队列2.3 入队操作2.4. 出队操作2.5 判断队列状态2.5 获取队头和队尾的元素力扣相关题目完整代码 1.循环队列 循环队列是使用有限数组来模拟队列&#xff0c;与普通的队列不同的是&…
阅读更多...
文献综述在确定先前研究中使用的方法学方法方面发挥什么作用

文献综述在确定先前研究中使用的方法学方法方面发挥什么作用

VersaBot一键生成文献综述 文献综述在确定先前研究中使用的方法学方法方面发挥着至关重要的作用&#xff0c;可以作为设计自己的方法论并证明其重要性的基础。就是这样; 1. 揭示现有方法&#xff1a; 通过探索与您的主题相关的研究&#xff0c;您将发现其他研究人员采用的不同…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023