Unity3d 多线程、多并发网络解决方案(C#)

最新推荐文章于 2024-04-25 17:48:14 发布
最新推荐文章于 2024-04-25 17:48:14 发布
阅读量4.5k 收藏 1
点赞数
分类专栏： Unity3D 文章标签： unity3d 网络 多线程 并发
此方案和结构在多线程多并发大吞吐下有绝对的效率优势

以下是服务端 vs2012 C#

using System;
using System.IO;
using System.ComponentModel;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Tools;
using GameDates;
    
namespace TestServer
{
    /// <summary>
    /// MyTcpIpClient 提供在Net TCP_IP 协议上基于消息的服务端 
    /// </summary>
    public class MyTcpIpServer : System.ComponentModel.Component
    {
        private int bufferSize=2048;
        private string tcpIpServerIP="127.0.0.1";
        private int tcpIpServerPort=11000;
        private Socket listener=null;
        private ManualResetEvent allDone = new ManualResetEvent(false);
        private ManualResetEvent sendDone = new ManualResetEvent(false);
        private Thread thread=null;
    
        public static List<StateObject> StateList = new List<StateObject>();
            
        private void StartListening() 
        {
            try
            {
                listener = new Socket(AddressFamily.InterNetwork,
                    SocketType.Stream, ProtocolType.Tcp);
                        
                IPAddress ipAddress;
                if(tcpIpServerIP.Trim()=="")
                {
                    ipAddress=IPAddress.Any;    
                }
                else
                {
                    ipAddress=IPAddress.Parse(tcpIpServerIP);
                }
                IPEndPoint localEndPoint = new IPEndPoint(ipAddress, tcpIpServerPort);
                    
                listener.Bind(localEndPoint);
                listener.Listen(10);
                while (true) 
                {
                    allDone.Reset();
                    listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);
                    allDone.WaitOne();
                }
            } 
            catch (Exception e) 
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e,listener));    
            }
        }
            
        private void ReadCallback(IAsyncResult ar) 
        {
            Socket handler=null;
            try
            {
                lock(ar)
                {
                    StateObject state = (StateObject) ar.AsyncState;
                    handler = state.workSocket;
                        
                    int bytesRead = handler.EndReceive(ar);
                        
                    if (bytesRead > 0) 
                    {
                        int ReadPiont=0;    
                        while(ReadPiont<bytesRead)
                        {    
                            if(state.Cortrol==0 && ReadPiont<bytesRead)
                            {
                                long bi1=state.buffer[ReadPiont];
                                bi1=(bi1<<24)&0xff000000;
                                state.packSize=bi1;
                                ReadPiont++;
                                state.Cortrol=1;
                            }
                            
                            if(state.Cortrol==1 && ReadPiont<bytesRead)
                            {
                                long bi1=state.buffer[ReadPiont];
                                bi1=(bi1<<16)&0x00ff0000;
                                state.packSize=state.packSize+bi1;
                                ReadPiont++;
                                state.Cortrol=2;
                            }
                            
                            if(state.Cortrol==2 && ReadPiont<bytesRead)
                            {
                                long bi1=state.buffer[ReadPiont];
                                bi1=(bi1<<8)&0x0000ff00;
                                state.packSize=state.packSize+bi1;
                                ReadPiont++;
                                state.Cortrol=3;
                            }
                                
                            if(state.Cortrol==3 && ReadPiont<bytesRead)
                            {
                                long bi1=state.buffer[ReadPiont];
                                bi1=bi1&0xff;
                                state.packSize=state.packSize+bi1-4;
                                ReadPiont++;
                                state.Cortrol=4;
                            }
                                
                            if(state.Cortrol==4 && ReadPiont<bytesRead)
                            {
                                long bi1=state.buffer[ReadPiont];
                                bi1=(bi1<<24)&0xff000000;
                                state.residualSize=bi1;
                                ReadPiont++;
                                state.Cortrol=5;
                                state.packSize-=1;
                            }
                                
                            if(state.Cortrol==5 && ReadPiont<bytesRead)
                            {
                                long bi1=state.buffer[ReadPiont];
                                bi1=(bi1<<16)&0x00ff0000;
                                state.residualSize=state.residualSize+bi1;
                                ReadPiont++;
                                state.Cortrol=6;
                                state.packSize-=1;
                            }
                                
                            if(state.Cortrol==6 && ReadPiont<bytesRead)
                            {
                                long bi1=state.buffer[ReadPiont];
                                bi1=(bi1<<8)&0x0000ff00;
                                state.residualSize=state.residualSize+bi1;
                                ReadPiont++;
                                state.Cortrol=7;
                                state.packSize-=1;
                            }
                            if(state.Cortrol==7 && ReadPiont<bytesRead)
                            {
                                long bi1=state.buffer[ReadPiont];
                                bi1=bi1&0xff;
                                state.residualSize=state.residualSize+bi1;
                                state.Datastream.SetLength(0);
                                state.Datastream.Position=0;
                                    
                                ReadPiont++;
                                state.Cortrol=8;
                                state.packSize-=1;
                            }
                                
                            if(state.Cortrol==8 && ReadPiont<bytesRead)
                            {
                                int bi1=bytesRead-ReadPiont;
                                int bi2=(int)(state.residualSize-state.Datastream.Length);
                                if(bi1>=bi2)
                                {
                                    state.Datastream.Write(state.buffer,ReadPiont,bi2);
                                    ReadPiont+=bi2;
                                    OnInceptServerEvent(new InceptServerEventArgs(state.Datastream,state.workSocket,this));
                                    state.Cortrol=9;
                                    state.packSize-=bi2;
                                        
                                        
                                }
                                else
                                {
                                    state.Datastream.Write(state.buffer,ReadPiont,bi1);
                                    ReadPiont+=bi1;
                                    state.packSize-=bi1;
                                }
                            }
                            if(state.Cortrol==9 && ReadPiont<bytesRead)
                            {
                                int bi1=bytesRead-ReadPiont;
                                if(bi1<state.packSize)
                                {
                                    state.packSize=state.packSize-bi1;
                                    ReadPiont+=bi1;
                                }    
                                else
                                {
                                    state.Cortrol=0;
                                    ReadPiont+=(int)state.packSize;
                                }
                            }
                        }
                        if(handler.Connected==true)
                        {
                            //异步读取数据流
                            handler.BeginReceive(state.buffer,0,bufferSize,0,new AsyncCallback(ReadCallback), state);
                            Console.WriteLine("接收字节长度【{0}】", state.buffer.Length);
                            //获取有效数据长度
                            long size = state.residualSize;
    
                            //解析数据....
                        }
                    }
                    else
                    {
                        handler.Shutdown(SocketShutdown.Both);
                        handler.Close();
                        //throw(new Exception("读入的数据小于1bit"));
                    }
                }
            }
            catch (Exception e) 
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e,handler));
                    
            }
        }
            
        private void SendCallback(IAsyncResult ar) 
        {
            Socket client = (Socket) ar.AsyncState;
            try
            {
                int bytesSent = client.EndSend(ar);
            } 
            catch (Exception e) 
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e,client));
            }
            finally
            {
                sendDone.Set();
            }
        }
            
        private void AcceptCallback(IAsyncResult ar) 
        {
            Socket handler=null;
            try
            {
                Socket listener = (Socket) ar.AsyncState;
                handler= listener.EndAccept(ar);
                StateObject state = new StateObject(bufferSize,handler);
                state.workSocket = handler;
                IPEndPoint msg = (IPEndPoint)state.workSocket.RemoteEndPoint;
                state.ip = msg.Address.ToString();
                state.prot = msg.Port;
                StateList.Add(state);
                Console.WriteLine("连接数[{0}],{1}", StateList.Count, state.workSocket.RemoteEndPoint);
                handler.BeginReceive(state.buffer,0,bufferSize,0,new AsyncCallback(ReadCallback), state);
            }
            catch (Exception e) 
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e,handler));
            }
            finally
            {
                allDone.Set();
            }
        }
    
            
        /// <summary>
        /// 析构
        /// </summary>
        /// <param name="disposing">不知道</param>
        protected override void Dispose(bool disposing)
        {
            Abort();
        }
            
        /// <summary>
        /// 引发接收事件
        /// </summary>
        /// <param name="e">数据</param>
        protected virtual void OnInceptServerEvent(InceptServerEventArgs e)
        {
            if (InceptServer != null) 
            {
                InceptServer(this, e);
            }
        }
        /// <summary>
        /// 引发错误事件
        /// </summary>
        /// <param name="e">数据</param>
        protected virtual void OnErrorServerEvent(ErrorServerEventArgs e)
        {
            if (ErrorServer != null) 
            {
                ErrorServer(this, e); 
            }
        }
            
        /// <summary>
        /// 开始监听访问
        /// </summary>
        public void Listening()
        {
            //StartListening();
            thread=new Thread(new ThreadStart(StartListening));
            thread.Name="MyTcpIpServer.Listening";
            thread.Start();
        }
        /// <summary>
        /// 异常中止服务
        /// </summary>
        public void Abort()
        {
            if(thread!=null)
            {
                thread.Abort();
                listener.Close();
            }
        }
            
        /// <summary>
        ///构造 
        /// </summary>
        /// <param name="container">父控件</param>
        public MyTcpIpServer(System.ComponentModel.IContainer container)
        {
            container.Add(this);
            //InitializeComponent();
    
            //
            // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
            //
        }
    
        /// <summary>
        /// 构造
        /// </summary>
        public MyTcpIpServer()
        {
            StartListening();
        }
    
    
    
    
    
        /// <summary>
        /// 要连接的服务器IP地址
        /// </summary>
        public string TcpIpServerIP
        {
            get
            {
                return tcpIpServerIP;
            }
            set
            {
                tcpIpServerIP=value;
            }
        }
    
        /// <summary>
        /// 要连接的服务器所使用的端口
        /// </summary>
        public int TcpIpServerPort
        {
            get
            {
                return tcpIpServerPort;
            }
            set
            {
                tcpIpServerPort=value;
            }
        }
    
        /// <summary>
        /// 缓冲器大小
        /// </summary>
        public int BufferSize
        {
            get
            {
                return bufferSize;
            }
            set
            {
                bufferSize=value;
            }
        }
            
        /// <summary>
        /// 连接的活动状态
        /// </summary>
        public bool Activ
        {
            get
            {
                return listener.Connected;
            }
            //set
            //{
            //    activ=value;
            //}
        }
    
        /// <summary>
        /// 发送一个流数据
        /// </summary>
        public void Send(Socket ClientSocket,Stream Astream)
        {
            try
            {
                if(ClientSocket.Connected==false)
                {
                    throw(new Exception("没有连接客户端不可以发送信息!"));
                }
                Astream.Position=0;
                byte[] byteData=new byte[bufferSize];
                int bi1=(int)((Astream.Length+8)/bufferSize);
                int bi2=(int)Astream.Length;
                if(((Astream.Length+8)%bufferSize)>0)
                {
                    bi1=bi1+1;
                }
                bi1=bi1*bufferSize;
                    
                byteData[0]=System.Convert.ToByte(bi1>>24);
                byteData[1]=System.Convert.ToByte((bi1&0x00ff0000)>>16);
                byteData[2]=System.Convert.ToByte((bi1&0x0000ff00)>>8);
                byteData[3]=System.Convert.ToByte((bi1&0x000000ff));
                    
                byteData[4]=System.Convert.ToByte(bi2>>24);
                byteData[5]=System.Convert.ToByte((bi2&0x00ff0000)>>16);
                byteData[6]=System.Convert.ToByte((bi2&0x0000ff00)>>8);
                byteData[7]=System.Convert.ToByte((bi2&0x000000ff));
                    
                int n = Astream.Read(byteData, 8, byteData.Length-8);
                    
                while (n>0) 
                {
                    ClientSocket.BeginSend(byteData, 0, byteData.Length, 0,    new AsyncCallback(SendCallback), ClientSocket);
                    sendDone.WaitOne();
                    byteData=new byte[bufferSize];
                    n = Astream.Read(byteData,0,byteData.Length);
                }
            } 
            catch (Exception e) 
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e,ClientSocket));
            }
        }
            
        /// <summary>
        /// 接收到数据事件
        /// </summary>
        public event InceptServerEvent InceptServer;
        /// <summary>
        /// 发生错误事件
        /// </summary>
        public event ErrorServerEvent ErrorServer;
    }
    /// <summary>
    /// 状态对象
    /// </summary>
    public class StateObject 
    {
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="bufferSize">缓存</param>
        /// <param name="WorkSocket">工作的插座</param>
        public StateObject(int bufferSize,Socket WorkSocket)
        {
            buffer = new byte[bufferSize];
            workSocket=WorkSocket;
        }
        /// <summary>
        /// 缓存
        /// </summary>
        public byte[] buffer = null;
        /// <summary>
        /// 工作插座
        /// </summary>
        public Socket workSocket = null;              
        /// <summary>
        /// 数据流
        /// </summary>
        public Stream Datastream=new MemoryStream();
        /// <summary>
        /// 剩余大小
        /// </summary>
        public long residualSize=0;
        /// <summary>
        /// 数据包大小
        /// </summary>
        public long packSize=0;
        /// <summary>
        /// 计数器
        /// </summary>
        public int Cortrol=0;
    
        /// <summary>
        /// 客户端端口
        /// </summary>
        public int prot;
    
        /// <summary>
        /// 客户端ip地址
        /// </summary>
        public string ip;
    }
        
    /// <summary>
    /// 接收事件
    /// </summary>
    public class InceptServerEventArgs : EventArgs 
    {  
        private readonly Stream datastream;
        private readonly Socket serverSocket;
        private readonly MyTcpIpServer tcpIpServer;
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="Astream">数据</param>
        /// <param name="ServerSocket">工作插座</param>
        /// <param name="TcpIpServer">提供服务的TCP/IP对象</param>
        public InceptServerEventArgs(Stream Astream,Socket ServerSocket,MyTcpIpServer TcpIpServer) 
        {
            datastream=Astream;
            serverSocket=ServerSocket;
            tcpIpServer=TcpIpServer;
        }
    /// <summary>
    /// 数据
    /// </summary>
        public Stream Astream
        {     
            get { return datastream;}      
        }
        /// <summary>
        /// 工作插座
        /// </summary>
        public Socket ServerSocket
        {     
            get { return serverSocket;}      
        }
        /// <summary>
        /// 提供TCP/IP服务的服务器对象.
        /// </summary>
        public MyTcpIpServer TcpIpServer
        {     
            get { return tcpIpServer;}      
        }
    }
    /// <summary>
    /// 接收数据委托
    /// </summary>
  public delegate void InceptServerEvent(object sender, InceptServerEventArgs e);
    /// <summary>
    /// 错误事件委托
    /// </summary>
    public class ErrorServerEventArgs : EventArgs 
    {  
        private readonly Exception error;
        private readonly Socket serverSocket;
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="Error">数据</param>
        /// <param name="ServerSocket">问题插座</param>
        public ErrorServerEventArgs(Exception Error,Socket ServerSocket) 
        {
            error=Error;
            serverSocket=ServerSocket;
        }
    /// <summary>
    /// 数据
    /// </summary>
        public Exception Error
        {     
            get { return error;}      
        }
        /// <summary>
        /// 问题插座
        /// </summary>
        public Socket ServerSocket
        {     
            get { return serverSocket;}      
        }
    }
    /// <summary>
    ///错误事件委托 
    /// </summary>
  public delegate void ErrorServerEvent(object sender, ErrorServerEventArgs e);
}

客户端部分 Unity3d 4.1.0 C# 

///MainClass.cs
    
using UnityEngine;
using clinet;
public class Index : MonoBehaviour 
{
    void Awake()
     {
        new MyTcpIpClient();
     } 
}
    
    
///GameClient.cs
    
using System;
using System.IO;
using System.ComponentModel;
using System.Collections;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Tools;
using GameDates;
    
namespace clinet
{
    /// <summary>
    /// MyTcpIpClient 提供在Net TCP_IP 协议上基于消息的客户端 
    /// </summary>
    public class MyTcpIpClient : System.ComponentModel.Component
    {
        private int bufferSize = 2048;
        private string tcpIpServerIP = "192.168.1.204";
        private int tcpIpServerPort = 9000;
        private Socket ClientSocket = null;
        private ManualResetEvent connectDone = new ManualResetEvent(false);
        private ManualResetEvent sendDone = new ManualResetEvent(false);
    
        private void ConnectCallback(IAsyncResult ar)
        {
            try
            {
                Socket client = (Socket)ar.AsyncState;
                client.EndConnect(ar);
    
            }
            catch (Exception e)
            {
                OnErrorEvent(new ErrorEventArgs(e));
            }
            finally
            {
                connectDone.Set();
            }
        }
        private void SendCallback(IAsyncResult ar)
        {
            try
            {
                Socket client = (Socket)ar.AsyncState;
                int bytesSent = client.EndSend(ar);
            }
            catch (Exception e)
            {
                OnErrorEvent(new ErrorEventArgs(e));
            }
            finally
            {
                sendDone.Set();
            }
        }
    
        /// <summary>
        /// 数据接收处理
        /// </summary>
        /// <param name="ar"></param>
        private void ReceiveCallback(IAsyncResult ar)
        {
            Socket handler = null;
            try
            {
                lock (ar)
                {
                    StateObject state = (StateObject)ar.AsyncState;
                    handler = state.workSocket;
    
                    int bytesRead = handler.EndReceive(ar);
    
                    if (bytesRead > 0)
                    {
                        int ReadPiont = 0;
                        while (ReadPiont < bytesRead)
                        {
                            if (state.Cortrol == 0 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 24) & 0xff000000;
                                state.packSize = bi1;
                                ReadPiont++;
                                state.Cortrol = 1;
                            }
    
                            if (state.Cortrol == 1 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 16) & 0x00ff0000;
                                state.packSize = state.packSize + bi1;
                                ReadPiont++;
                                state.Cortrol = 2;
                            }
    
                            if (state.Cortrol == 2 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 8) & 0x0000ff00;
                                state.packSize = state.packSize + bi1;
                                ReadPiont++;
                                state.Cortrol = 3;
                            }
    
                            if (state.Cortrol == 3 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = bi1 & 0xff;
                                state.packSize = state.packSize + bi1 - 4;
                                ReadPiont++;
                                state.Cortrol = 4;
                            }
    
                            if (state.Cortrol == 4 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 24) & 0xff000000;
                                state.residualSize = bi1;
                                ReadPiont++;
                                state.Cortrol = 5;
                                state.packSize -= 1;
                            }
    
                            if (state.Cortrol == 5 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 16) & 0x00ff0000;
                                state.residualSize = state.residualSize + bi1;
                                ReadPiont++;
                                state.Cortrol = 6;
                                state.packSize -= 1;
                            }
    
                            if (state.Cortrol == 6 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 8) & 0x0000ff00;
                                state.residualSize = state.residualSize + bi1;
                                ReadPiont++;
                                state.Cortrol = 7;
                                state.packSize -= 1;
                            }
                            if (state.Cortrol == 7 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = bi1 & 0xff;
                                state.residualSize = state.residualSize + bi1;
                                state.Datastream.SetLength(0);
                                state.Datastream.Position = 0;
    
                                ReadPiont++;
                                state.Cortrol = 8;
                                state.packSize -= 1;
                            }
    
                            if (state.Cortrol == 8 && ReadPiont < bytesRead)
                            {
                                int bi1 = bytesRead - ReadPiont;
                                int bi2 = (int)(state.residualSize - state.Datastream.Length);
                                if (bi1 >= bi2)
                                {
                                    state.Datastream.Write(state.buffer, ReadPiont, bi2);
                                    ReadPiont += bi2;
                                    OnInceptEvent(new InceptEventArgs(state.Datastream, handler));
                                    state.Cortrol = 9;
                                    state.packSize -= bi2;
                                }
                                else
                                {
                                    state.Datastream.Write(state.buffer, ReadPiont, bi1);
                                    ReadPiont += bi1;
                                    state.packSize -= bi1;
                                }
                            }
                            if (state.Cortrol == 9 && ReadPiont < bytesRead)
                            {
                                int bi1 = bytesRead - ReadPiont;
                                if (bi1 < state.packSize)
                                {
                                    state.packSize = state.packSize - bi1;
                                    ReadPiont += bi1;
                                }
                                else
                                {
                                    state.Cortrol = 0;
                                    ReadPiont += (int)state.packSize;
                                }
                            }
                        }
                    }
                    else
                    {
                        throw (new Exception("读入的数据小于1bit"));
                    }
                    if (handler.Connected == true)
                    {
                        handler.BeginReceive(state.buffer, 0, bufferSize, 0, new AsyncCallback(ReceiveCallback), state);
                        Console.WriteLine("接收字节长度【{0}】", state.buffer.Length);
                        long size = state.residualSize;
                    }
                }
            }
            catch (Exception e)
            {
                OnErrorEvent(new ErrorEventArgs(e));
    
            }
        }
    
        /// <summary>
        /// 连接服务器
        /// </summary>
        public void Conn()
        {
            try
            {
                ClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPAddress ipAddress = IPAddress.Parse(tcpIpServerIP);
                IPEndPoint remoteEP = new IPEndPoint(ipAddress, tcpIpServerPort);
                connectDone.Reset();
                ClientSocket.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), ClientSocket);
            }
            catch (Exception e)
            {
                OnErrorEvent(new ErrorEventArgs(e));
            }
    
        }
        /// <summary>
        /// 断开连接
        /// </summary>
        public void Close()
        {
            try
            {
                if (ClientSocket.Connected == true)
                {
                    ClientSocket.Shutdown(SocketShutdown.Both);
                    ClientSocket.Close();
                }
            }
            catch (Exception e)
            {
                OnErrorEvent(new ErrorEventArgs(e));
            }
    
        }
        /// <summary>
        /// 发送一个流数据
        /// </summary>
        /// <param name="Astream">数据流</param>
        public void Send(Stream Astream)
        {
            try
            {
                if (ClientSocket.Connected == false)
                {
                    throw (new Exception("没有连接服务器不可以发送信息!"));
                }
                Astream.Position = 0;
                byte[] byteData = new byte[bufferSize];
                int bi1 = (int)((Astream.Length + 8) / bufferSize);
                int bi2 = (int)Astream.Length;
                if (((Astream.Length + 8) % bufferSize) > 0)
                {
                    bi1 = bi1 + 1;
                }
                bi1 = bi1 * bufferSize;
    
                byteData[0] = System.Convert.ToByte(bi1 >> 24);
                byteData[1] = System.Convert.ToByte((bi1 & 0x00ff0000) >> 16);
                byteData[2] = System.Convert.ToByte((bi1 & 0x0000ff00) >> 8);
                byteData[3] = System.Convert.ToByte((bi1 & 0x000000ff));
    
                byteData[4] = System.Convert.ToByte(bi2 >> 24);
                byteData[5] = System.Convert.ToByte((bi2 & 0x00ff0000) >> 16);
                byteData[6] = System.Convert.ToByte((bi2 & 0x0000ff00) >> 8);
                byteData[7] = System.Convert.ToByte((bi2 & 0x000000ff));
    
                int n = Astream.Read(byteData, 8, byteData.Length - 8);
    
                while (n > 0)
                {
                    ClientSocket.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), ClientSocket);
                    Console.WriteLine("发送字节长度【{0}】", byteData.Length);
                    sendDone.WaitOne();
                    byteData = new byte[bufferSize];
                    n = Astream.Read(byteData, 0, byteData.Length);
                }
            }
            catch (Exception e)
            {
                OnErrorEvent(new ErrorEventArgs(e));
            }
        }
    
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="container">父控件</param>
        public MyTcpIpClient(System.ComponentModel.IContainer container)
        {
            container.Add(this);
            //InitializeComponent();
    
            //
            // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
            //
        }
        /// <summary>
        /// 构造
        /// </summary>
        public MyTcpIpClient()
        {
            Conn();
    
            //连接完成后开始循环接收服务端返回数据
            while (true)
            {
                connectDone.WaitOne();
                StateObject Cstate = new StateObject(bufferSize, ClientSocket);
                ClientSocket.BeginReceive(Cstate.buffer, 0, bufferSize, 0,
                    new AsyncCallback(ReceiveCallback), Cstate);
                Thread.Sleep(100);
            }
        }
    
        //#region Component Designer generated code
        / <summary>
        / 设计器支持所需的方法 - 不要使用代码编辑器修改
        / 此方法的内容。
        / </summary>
        //private void InitializeComponent()
        //{
        //    Conn();
        //}
        //#endregion
    
    
    
        /// <summary>
        /// 要连接的服务器IP地址
        /// </summary>
        public string TcpIpServerIP
        {
            get
            {
                return tcpIpServerIP;
            }
            set
            {
                tcpIpServerIP = value;
            }
        }
    
        /// <summary>
        /// 要连接的服务器所使用的端口
        /// </summary>
        public int TcpIpServerPort
        {
            get
            {
                return tcpIpServerPort;
            }
            set
            {
                tcpIpServerPort = value;
            }
        }
    
        /// <summary>
        /// 缓冲器大小
        /// </summary>
        public int BufferSize
        {
            get
            {
                return bufferSize;
            }
            set
            {
                bufferSize = value;
            }
        }
    
        /// <summary>
        /// 连接的活动状态
        /// </summary>
        public bool Activ
        {
            get
            {
                if (ClientSocket == null)
                {
                    return false;
                }
                return ClientSocket.Connected;
            }
        }
        /// <summary>
        /// 接收到数据引发的事件
        /// </summary>
        public event InceptEvent Incept;
        /// <summary>
        /// 引发接收数据事件
        /// </summary>
        /// <param name="e">接收数据</param>
        protected virtual void OnInceptEvent(InceptEventArgs e)
        {
            if (Incept != null)
            {
                Incept(this, e);
            }
        }
        /// <summary>
        /// 发生错误引发的事件
        /// </summary>
        public event ErrorEvent Error;
        /// <summary>
        /// 引发错误事件
        /// </summary>
        /// <param name="e">错误数据</param>
        protected virtual void OnErrorEvent(ErrorEventArgs e)
        {
            if (Error != null)
            {
                Error(this, e);
            }
        }
    
    }
    
    /// <summary>
    /// 状态对象
    /// </summary>
    public class StateObject
    {
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="bufferSize">缓存</param>
        /// <param name="WorkSocket">工作的插座</param>
        public StateObject(int bufferSize, Socket WorkSocket)
        {
            buffer = new byte[bufferSize];
            workSocket = WorkSocket;
        }
        /// <summary>
        /// 缓存
        /// </summary>
        public byte[] buffer = null;
        /// <summary>
        /// 工作插座
        /// </summary>
        public Socket workSocket = null;
        /// <summary>
        /// 数据流
        /// </summary>
        public Stream Datastream = new MemoryStream();
        /// <summary>
        /// 剩余大小
        /// </summary>
        public long residualSize = 0;
        /// <summary>
        /// 数据包大小
        /// </summary>
        public long packSize = 0;
        /// <summary>
        /// 计数器
        /// </summary>
        public int Cortrol = 0;
    }
    
    /// <summary>
    /// 接收数据事件
    /// </summary>
    public class InceptEventArgs : EventArgs
    {
        private readonly Stream datastream;
        private readonly Socket clientSocket;
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="Astream">接收到的数据</param>
        /// <param name="ClientSocket">接收的插座</param>
        public InceptEventArgs(Stream Astream, Socket ClientSocket)
        {
            datastream = Astream;
            clientSocket = ClientSocket;
        }
        /// <summary>
        /// 接受的数据流
        /// </summary>
        public Stream Astream
        {
            get { return datastream; }
        }
        /// <summary>
        /// 接收的插座
        /// </summary>
        public Socket ClientSocket
        {
            get { return clientSocket; }
        }
    }
    /// <summary>
    /// 定义接收委托
    /// </summary>
    public delegate void InceptEvent(object sender, InceptEventArgs e);
    /// <summary>
    /// 错处事件
    /// </summary>
    public class ErrorEventArgs : EventArgs
    {
        private readonly Exception error;
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="Error">错误信息对象</param>
        public ErrorEventArgs(Exception Error)
        {
            error = Error;
        }
        /// <summary>
        /// 错误信息对象
        /// </summary>
        public Exception Error
        {
            get { return error; }
        }
    }
    /// <summary>
    /// 错误委托
    /// </summary>
    public delegate void ErrorEvent(object sender, ErrorEventArgs e);
    
    
    
}

原文地址：http://game.ceeger.com/forum/read.php?tid=9921&fid=24

张倬胜
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Unity3D 中 Socket 与 线程通信 浅谈
凉白开
07-08 1733
Socket 在unity中实现网络功能往往需要使用socket，而socket是阻塞的，如果直接在start或者update里new出来了一个socket来用，那么在使用它的过程中当它阻塞的时候(比如accept) 整个程序就是锁死的 。 为了不产生这种影响，就需要使用非阻塞的Socket。 官方提供了一些非阻塞的方案来选择，但是这些方案都带来的相同的新问题，那就是它们都不在Unity的主线程中...
Unity3D 异步Socket 网络编程
whibalck的博客
11-01 2159
简单的异步socket示例 简单过一下主要使用到的相关API: public class Socket : IDisposable { public Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType); // 连接指定地址&端口 public void Connect(EndPoint remoteEP); // 异步接收， 指定callback函数处理到来的函数(自动创建线
《Unity 3D游戏客户端基础框架》多线程异步 Socket 框架构建
linshuhe1的专栏
08-02 1万+
引言：之前写过一个 demo 案例大致讲解了 Socket 通信的过程，并和自建的服务器完成连接和简单的数据通信，详细的内容可以查看 Unity3D —— Socket通信(C#)。但是在实际项目应用的过程中，这个 demo 的实现方式显得异常简陋，而且对应多个业务同时发起 Socket 通信请求的处理能力也是有限，总不能每个请求都创建一个线程去监听返回结果，所以有必要进一步优化一番，例如加入线程池
如何在Unity中实现多线程编程
最新发布
lcfengokok的博客
04-25 739
在Unity中实现多线程编程主要依赖于C# Job System、Tasks和Threads等机制。这些机制可以帮助你在不阻塞主线程的情况下执行耗时的操作，从而提高应用程序的性能和响应性。
Unity协程和线程的区别深入理解(附实验展示)
iiiiiiimp的博客
04-11 2680
前几天被问到线程和协程的区别，发现网上主要是从理论上来讲两者的区别理解起来很抽象，所以我下来做了几个实验来体现线程与协程的区别。
Unity3D网络游戏实战——深入了解TCP，解决暗藏问题
白小飞
11-04 1969
前言 这一章基本属于科普章节，相信看到这篇文章的人也学习过计算机网络，所以很多基础知识，比如三握四挥这些就不多说了。 5.3常用TCP参数 5.3.1ReceiveBufferSize 指定了操作系统读缓冲区的大小，默认值8192。缓冲区满了，发送端会暂停发送数据，较大的缓冲区可以减少发送短暂停的概率，提高效率。 5.3.2SendBufferSize 指定操作系统写缓冲区的大小，默认值也是8192，设定的大一点也比较好~ 5.3.3NoDelay 默认情况TCP会使用Nagle算法发送数据，因为TCP/I
Unity3D 常见问题
biezhihua的专栏
02-22 4435
error CS0103: The name `Analytics’ does not exist in the current contextResult
Unity3D-NativeWebSocket
05-31
Unity3D是一个强大的跨平台游戏开发引擎，广泛用于创建2D和3D的互动体验，包括游戏、虚拟现实（VR）和增强现实（AR）...无论是多人在线游戏、实时聊天应用还是数据同步服务，这个插件都能提供稳定、高效的解决方案。
一套完整的Unity框架方案，包含 UI，热更新，资源管理，多线程、数据处理等功能完备的工具集.zip
01-03
Unity原生支持C#的多线程，但需要注意的是，由于Unity引擎的主要渲染循环是单线程的，因此在多线程编程时需要特别注意同步问题。此框架可能包含了线程安全的工具和最佳实践，帮助开发者避免并发问题。 数据处理部分...
C#中文离线手册
02-15
C#文档部分可能包含.NET框架的详细内容，如.NET基础类库、垃圾回收机制、并发与多线程，以及ASP.NET Web开发等。这些内容对深入理解和运用C#语言至关重要。 作为一本离线手册，它的便利性在于可以随时查阅，不受...
20个C#项目实战开发及项目全部源码
08-08
19. **游戏开发**：C#与Unity引擎的结合，使你可以进行游戏开发，涵盖2D、3D图形、物理引擎、网络通信等多个方面。 20. **持续集成与自动化部署**：理解Git版本控制、CI/CD工具如Jenkins或Azure DevOps，能提升项目...
unityC#双端实时音视频源码项目
11-20
Unity C#双端实时音视频源码项目是一个个人制作的高效解决方案，旨在简化Unity客户端与远程服务器之间的实时音频和视频交互。在这个项目中，开发者仅使用了四个C#代码文件，实现了服务器和客户端的全部功能，这展示...
Unity3d 要放弃WWW,看看新的网络请求方式UnityWebRequest
热门推荐
游戏路上的小学生
10-12 3万+
Unity将要逐步放弃www网络请求api，新的api请求方式来临：UnityWebRequestThe旧的  www ：https://docs.unity3d.com/ScriptReference/WWW.html  新的 UnityWebRequestThe ：https:/
Unity3D开发之延迟函数
Jay W的博客
04-19 8441
    这个东西是我在16年的时候记录在新浪博客上的，后来弃用新浪了。原因很简单，新浪编辑器界面格式我不喜欢。哈哈。。下面说下，项目中，我们经常会遇到一些要求延迟一两秒后执行某个函数的需求。通常MonoBehaviour提供的Invoke方法可以满足大部分需求，但是缺陷就是不能给含有参数的函数传参。而且如果逻辑很多的脚本中有十多个延迟函数的需求，我们要写十多个函数来被调用，显得脚本很臃肿。所以，这...
【Unity】网络通信（TCP&UDP）
DevFrank的博客
10-20 9389
Socket 接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，用以开发TCP/IP网络上的应用程序。也就是说Socket是TCP/UDP通讯的实现方式。TCP和UDP是传输层协议，使用IP协议从一个网络传送数据包到另一个网络。把IP想像成一种高速公路，它允许其它协议在上面行驶并找到到其它电脑的出口。两者的不同是：TCP能提供有保证的数据传输，而UDP不提供，即UDP的数据容易丢失。
最简单的Unity多线程解决方案
Thewen
06-20 3123
接入一些sdk，有时候需要线程操作，推介一个 using UnityEngine; using System.Collections.Generic; using System; using System.Threading; public class ThreadHelper : MonoBehaviour { private static ThreadHelper Current...
Unity如何使用多线程处理 UnityEngine相关的内容
plaxbsga的专栏
12-07 3866
介绍一个插件Loom可以让你在Unity使用多线程处理UnityEngine的逻辑（包含Unity的API）。 Unity中的线程不能使用Unity的对象，但可以使用Unity的值类型变量，如Vector3等。这样就使得线程在Unity中显的很鸡肋和蹩脚，因为很多函数很都是UnityEngine类或函数的调用的，对于哪些是可以在多线程使用，如下总结： 1. 变量(
unity 3d网络游戏实战(全).pdf_设计Unity网络模块，该用异步还是多路复用？
weixin_39790760的博客
11-19 871
开发Unity网络模块时，一般会有异步（多线程同理）、多路复用两种方法。它们分别是什么，以及孰优孰劣呢？在《Unity3D网络游戏实战（第2版）》的网络模块中，客户端使用了异步，服务端使用了多路复用。有读者问到为什么这么做，为什么不在客户端使用多路复用？这个问题很多人会遇到，决定写一篇文章说明这个问题。先简单看看异步和多路复用是什么样子。异步异步程序的写法如下，会调用.net网络编程的API，使用...
Java多线程-解决单例模式中的懒汉式的线程安全问题
02-01
- 懒汉式在第一次请求时才创建单例对象，这在多线程环境下可能会出现问题，因为多个线程可能会并发地尝试创建对象，如果没有适当的同步措施，会导致多个对象实例。 **解决线程安全问题的方式：** - **方式1：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值