直接使用socket_TCP进行网络游戏开发

最新推荐文章于 2024-07-09 19:25:43 发布

cchoop

最新推荐文章于 2024-07-09 19:25:43 发布

阅读量1.2k

点赞数 2

分类专栏： c# Unity3D 文章标签： c# unity

本文链接：https://blog.csdn.net/qq_34937637/article/details/79533846

版权

Unity3D 同时被 2 个专栏收录

39 篇文章 15 订阅

订阅专栏

14 篇文章 1 订阅

订阅专栏

创建服务器端Socket并绑定IP和端口号

1.引入命名空间：
using System.Net.Sockets;
using System.Net;
2.创建TCP套接字
Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
3.绑定IP和端口号
（IPAddress.Parse(“127.0.0.1”);将字符串转化为IP地址）
IPAddress ipAddress = IPAddress.Parse(“127.0.0.1”);
IPEndPoint point = new IPEndPoint(ipAddress, 8888);
serverSocket.Bind(point); //绑定IP和端口号

代码：

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


namespace TCP服务器端
{
    class Program
    {
        static void Main(string[] args)
        {
            //TCP 数据传输方式：流模式
            Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);

            IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
            IPEndPoint point = new IPEndPoint(ipAddress, 8888);

            serverSocket.Bind(point);   //绑定IP和端口号
        }
    }
}

开发服务器端的发送数据和接收数据

1.开始监听端口号监听不超过10个
serverSocket.Listen(10);
2.接收一个客户端的链接，返回一个客户端套接字
Socket clientSocket = serverSocket.Accept();
3.向客户端发送（字节数组类型）数据
string msg = “hello,你好啊！”;
Byte[] dataBuffer = Encoding.UTF8.GetBytes(msg);
clientSocket.Send(dataBuffer);
4.接收客户端数据,使用字节数组接收，count为接收字节的长度
byte[] receiveBuffer = new byte[1024];
int count = clientSocket.Receive(receiveBuffer);
string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
5.关闭和客户端的链接，关闭服务器端
clientSocket.Close();
serverSocket.Close();
代码：

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


namespace TCP服务器端
{
    class Program
    {
        static void Main(string[] args)
        {
            //TCP 数据传输方式：流模式
            Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);

            IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
            IPEndPoint point = new IPEndPoint(ipAddress, 8888);

            serverSocket.Bind(point);   //绑定IP和端口号

            //开始监听端口号 监听不超过10个
            serverSocket.Listen(10);      

            //接收一个客户端的链接
            Socket clientSocket = serverSocket.Accept();

            //向客户端发送数据
            string msgSend = "hello,你好啊！";
            byte[] sendBuffer = Encoding.UTF8.GetBytes(msg);
            clientSocket.Send(sendBuffer);

            //接收客户端数据
            byte[] receiveBuffer = new byte[1024];
            int count = clientSocket.Receive(receiveBuffer);
            string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);

            //关闭和客户端的链接，关闭服务器端
            clientSocket.Close();
            serverSocket.Close();
        }
    }
}

开发TCP客户端的接收数据和发送数据

1.创建客户端套接字
2.与服务器端建立连接
clientSocket.Connect(new IPEndPoint(IPAddress.Parse(“127.0.0.1”),8888));
3.接收从服务器端发过来的消息
4.向服务器端发送一条消息

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

namespace TCP客户端
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建客户端套接字
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            //与服务器端建立连接
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"),8888));

            //接收从服务器端发过来的消息
            byte[] dataReceive = new byte[1024];
            int count = clientSocket.Receive(dataReceive);
            string msgReceive = Encoding.UTF8.GetString(dataReceive, 0, count);
            Console.WriteLine(msgReceive);

            //向服务器端发送一条消息
            string str = Console.ReadLine();
            byte[] dataSend = Encoding.UTF8.GetBytes(str);
            clientSocket.Send(dataSend);

            //关闭客户端套接字的连接
            clientSocket.Close();

            Console.ReadLine();
        }
    }
}

实现服务器端异步的消息接收

异步接收消息：
开始接收：
clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
ReceiveCallBack为异步接收的回调函数
结束接收（返回接收的字节长度）：
int count = clientSocket.EndReceive(ar);

服务器端代码：

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


namespace TCP服务器端
{
    class Program
    {
        private static byte[] receiveBuffer = new byte[1024];

        static void Main(string[] args)
        {
            StartServerAyync();
            Console.ReadLine();
        }

        static void StartServerAyync()
        {
            //TCP 数据传输方式：流模式
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
            IPEndPoint point = new IPEndPoint(ipAddress, 8888);

            serverSocket.Bind(point);   //绑定IP和端口号

            //开始监听端口号 监听不超过10个
            serverSocket.Listen(10);

            //接收一个客户端的链接
            Socket clientSocket = serverSocket.Accept();

            //向客户端发送数据
            string msgSend = "hello,你好啊！";
            byte[] sendBuffer = Encoding.UTF8.GetBytes(msgSend);
            clientSocket.Send(sendBuffer);

            //接收客户端数据
            clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);

        }

        static void ReceiveCallBack(IAsyncResult ar)
        {
            Socket clientSocket = ar.AsyncState as Socket;
            int count = clientSocket.EndReceive(ar);
            string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
            Console.WriteLine(msgReceive);
            //继续开始接收客户端发送的消息
            clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
        }
    }
}

客户端代码：

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

namespace TCP客户端
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建客户端套接字
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            //与服务器端建立连接
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888));

            //接收从服务器端发过来的消息
            byte[] dataReceive = new byte[1024];
            int count = clientSocket.Receive(dataReceive);
            string msgReceive = Encoding.UTF8.GetString(dataReceive, 0, count);
            Console.WriteLine(msgReceive);

            string str = Console.ReadLine();
            //向服务器端发送一条消息
            while (true)
            {
                byte[] dataSend = Encoding.UTF8.GetBytes(str);
                clientSocket.Send(dataSend);
                str = Console.ReadLine();
                if(str.Equals("exit"))
                {
                    break;
                }
            }
            //关闭客户端套接字的连接
            clientSocket.Close();

            Console.ReadLine();
        }
    }
}

修改服务器端开启异步处理客户端链接请求

1开始异步接收客户端的连接：
serverSocket.BeginAccept(AcceptCallBack, serverSocket);
获取与客户端连接的套接字：
Socket clientSocket = serverSocket.EndAccept(ar);
2.当客户端非正常关闭时服务器端会抛出异常，使用try…catch处理异常;当客户端正常关闭时，服务器端不会停止对客户端接收数据，应该对接收数据的字节长度count进行判断，若为0，则客户端正常关闭，即关闭与客户端连接的套接字。

服务器端代码：

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


namespace TCP服务器端
{
    class Program
    {
        private static int clientCount = 0;
        private static byte[] receiveBuffer = new byte[1024];

        static void Main(string[] args)
        {
            StartServerAyync();
            Console.ReadLine();
        }

        static void StartServerAyync()
        {
            //TCP 数据传输方式：流模式
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
            IPEndPoint point = new IPEndPoint(ipAddress, 8888);

            serverSocket.Bind(point);   //绑定IP和端口号

            //开始监听端口号 监听不超过10个
            //serverSocket.Listen(10);
            serverSocket.Listen(0);

            //接收一个客户端的连接
            //Socket clientSocket = serverSocket.Accept();

            //异步接收客户端的连接
            serverSocket.BeginAccept(AcceptCallBack, serverSocket);


        }

        //异步等待客户端连接的回调函数
        static void AcceptCallBack(IAsyncResult ar)
        {
            clientCount++;
            Console.WriteLine("一个客户端连接上了本服务器,当前连接的客户端数：" + clientCount);
            Socket serverSocket = ar.AsyncState as Socket;
            Socket clientSocket = serverSocket.EndAccept(ar);
            //向客户端发送数据
            string msgSend = "hello,你好啊！";
            byte[] sendBuffer = Encoding.UTF8.GetBytes(msgSend);
            clientSocket.Send(sendBuffer);

            //接收客户端数据
            clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);

            //继续异步接收客户端的连接
            serverSocket.BeginAccept(AcceptCallBack, serverSocket);
        }

        //异步接收客户端数据的回调函数
        static void ReceiveCallBack(IAsyncResult ar)
        {
            Socket clientSocket = null;
            try
            {
                clientSocket = ar.AsyncState as Socket;
                int count = clientSocket.EndReceive(ar);

                //客户端发送的消息为空
                if(count == 0)
                {
                    clientCount--;
                    Console.WriteLine("一个客户端关闭了连接,当前连接的客户端数：" + clientCount);
                    if (clientSocket != null)
                    {
                        clientSocket.Close();
                    }
                    return;
                }

                string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
                Console.WriteLine("客户端消息：" + msgReceive);
                clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
            }
            catch (Exception e)
            {
                clientCount--;
                Console.WriteLine("一个客户端关闭了连接,当前连接的客户端数：" + clientCount);
                if (clientSocket != null)
                {
                    clientSocket.Close();
                }
            }
        }

        static void StartServerSync()
        {
            //TCP 数据传输方式：流模式
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
            IPEndPoint point = new IPEndPoint(ipAddress, 8888);

            serverSocket.Bind(point);   //绑定IP和端口号

            //开始监听端口号 监听不超过10个
            serverSocket.Listen(10);

            //接收一个客户端的链接
            Socket clientSocket = serverSocket.Accept();

            //向客户端发送数据
            string msgSend = "hello,你好啊！";
            byte[] sendBuffer = Encoding.UTF8.GetBytes(msgSend);
            clientSocket.Send(sendBuffer);

            //接收客户端数据
            byte[] receiveBuffer = new byte[1024];
            int count = clientSocket.Receive(receiveBuffer);
            string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
            Console.WriteLine("客户端：" + msgReceive);

            //关闭和客户端的链接，关闭服务器端
            clientSocket.Close();
            serverSocket.Close();
        }
    }
}

客户端代码：

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

namespace TCP客户端
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建客户端套接字
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            //与服务器端建立连接
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888));

            //接收从服务器端发过来的消息
            byte[] dataReceive = new byte[1024];
            int count = clientSocket.Receive(dataReceive);            
            string msgReceive = Encoding.UTF8.GetString(dataReceive, 0, count);
            Console.WriteLine(msgReceive);

            string str = Console.ReadLine();
            //向服务器端发送一条消息
            while (true)
            {
                byte[] dataSend = Encoding.UTF8.GetBytes(str);
                clientSocket.Send(dataSend);
                str = Console.ReadLine();
                if(str.Equals("exit"))
                {
                    break;
                }
            }


            //关闭客户端套接字的连接
            clientSocket.Close();

            Console.ReadLine();
        }
    }
}

粘包与分包问题

粘包和分包是利用Socket在TCP协议下内部的优化机制
1，什么是粘包
由于TCP协议本身的机制（面向连接的可靠地协议-三次握手机制）客户端与服务器会维持一个连接（Channel），数据在连接不断开的情况下，可以持续不断地将多个数据包发往服务器，但是如果发送的网络数据包太小，那么他本身会启用Nagle算法（可配置是否启用）对较小的数据包进行合并（基于此，TCP的网络延迟要UDP的高些）然后再发送（超时或者包大小足够）。那么这样的话，服务器在接收到消息（数据流）的时候就无法区分哪些数据包是客户端自己分开发送的，这样产生了粘包.

for(int i = 0;i < 100; i ++ )
{
    byte[] dataSend = Encoding.UTF8.GetBytes(i.ToString());
    clientSocket.Send(dataSend);
}

客户端发送了100条消息，服务器端合并消息后只接收了两次：

2，什么是分包
分包产生的原因：可能是IP分片传输导致的，也可能是传输过程中丢失部分包导致出现的半包，还有可能就是一个包可能被分成了两次传输，在取数据的时候，先取到了一部分（还可能与接收的缓冲区大小有关系），总之就是一个数据包被分成了多次接收。
客户端发1条消息，服务器端分条接收：

解决粘包与分包问题

解决方法：消息定长，比如定一个100，那么读取端每次读取数据就截取100个长度的数据，然后交给业务层去做解析
=>客户端Message：将发送的消息转化为一个字节数组byteData，在将byteData的长度转化为一个字节数组byteLength，然后连接byteLength+byteData=newByte，将newByte交给服务器端去解析

using System;
using System.Text;

namespace TCP客户端
{
    class Message
    {
        public static byte[] GetBytes(string data)
        {
            byte[] dataBytes = Encoding.UTF8.GetBytes(data);
            int dataLength = dataBytes.Length;
            byte[] lengthBytes = BitConverter.GetBytes(dataLength);
            byte[] newBytes = lengthBytes.Concat(dataBytes).ToArray();
            return newBytes;
        }
    }
}

=>服务器端接收到客户端发来的字节数组后，对该字节数组进行解析，读取数据：

using System;
using System.Text;

namespace TCP服务器端
{
    class Message
    {
        private byte[] data = new byte[1024];
        private int startIndex = 0;

        public byte[] Data
        {
            get
            {
                return this.data;
            }
        }

        public int StartIndex
        {
            get
            {
                return this.startIndex;
            }
        }

        public void AddCount(int count)
        {
            this.startIndex += count;
        }


        //剩余的空间
        public int RemainSize()
        {
            return data.Length - startIndex;
        }

        //读取数据
        public void ReadMessage()
        {
            while (true)
            {
                if(startIndex <= 4)
                {
                    return;
                }
                int count = BitConverter.ToInt32(data, 0);

                Console.WriteLine(count);

                if (startIndex - 4 >= count)
                {
                    String str = Encoding.UTF8.GetString(data, 4, count);

                    Console.WriteLine("解析出一条数据：" + str);
                    Array.Copy(data, count + 4, data, 0, startIndex - count - 4);
                    startIndex -= (count + 4);
                }
                else
                {
                    break;
                }
            }

        }
    }
}

cchoop

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
2
评论
直接使用socket_TCP进行网络游戏开发

创建服务器端Socket并绑定IP和端口号1.引入命名空间： using System.Net.Sockets; using System.Net; 2.创建TCP套接字 Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp); 3.绑定IP和...
复制链接

扫一扫