Socket/TCP/unity5.6

已于 2022-11-02 17:21:15 修改
阅读量818 收藏 1
点赞数
分类专栏： TCP 文章标签： tcp/ip 网络 服务器
于 2019-09-02 09:32:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34035956/article/details/80723432
版权

TCP/IP

端口号

TCP的三次握手四次挥手

TCP服务器端和客户端接收数据和发送数据（同步）

TCPServer.cs

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

namespace TCPServer
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //10.110.101.57

            //IPAddress xx.xx.xx.xx IpEndPoint xx.xx.xx.xx:port
            //IPAddress iPAddress = new IPAddress(new byte[] { 10,110,101,57 });
            IPAddress iPAddress = IPAddress.Parse("10.110.101.57");//IP地址
            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);//IP地址和端口号

            serverSocket.Bind(iPEndPoint);//绑定IP和端口号
            serverSocket.Listen(0);//开始监听端口号  处理连接队列个数 0-无数个 50-50个

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

            //向客户端发送一条消息
            string msg = "Hello client!您好...";
            //把字符串编码成byte数组，因为在网络中传递的信息都是用0和1
            byte[] data = System.Text.Encoding.UTF8.GetBytes(msg);
            clidenSocket.Send(data);

            //接收客户端的一条消息
            byte[] dataBuffer = new byte[1024];//声明byte数组作缓存
            //接收客户端的内容存到dataBuffer  count存储接收长度
            int count = clidenSocket.Receive(dataBuffer);
            //把byte转为string
            string msgReceive = System.Text.Encoding.UTF8.GetString(dataBuffer, 0, count);
            Console.WriteLine(msgReceive);

            Console.ReadKey();
            clidenSocket.Close();//关闭与客户端连接
            serverSocket.Close();//关闭服务器端

        }
    }
}

TCpClient.cs

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

namespace TCPClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("10.110.101.57"),88));//连接到客户端

            byte[] data = new byte[1024];
            int count = clientSocket.Receive(data);//接收
            string msg = Encoding.UTF8.GetString(data, 0, count);
            Console.WriteLine(msg);

            string s = Console.ReadLine();
            //把string转为byte数组后发送
            clientSocket.Send(Encoding.UTF8.GetBytes(s));

            Console.ReadKey();
            clientSocket.Close();//关闭客户端
        }
    }
}

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

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

namespace TCPServer
{
    class Program
    {
        static void Main(string[] args)
        {
            StartServerAsync();
            Console.ReadKey();
        }

        //异步消息接收
        static void StartServerAsync()
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //10.110.101.57

            //IPAddress xx.xx.xx.xx IpEndPoint xx.xx.xx.xx:port
            //IPAddress iPAddress = new IPAddress(new byte[] { 10,110,101,57 });
            IPAddress iPAddress = IPAddress.Parse("10.110.101.57");//IP地址
            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);//IP地址和端口号

            serverSocket.Bind(iPEndPoint);//绑定IP和端口号
            serverSocket.Listen(0);//开始监听端口号  处理连接队列个数 0-无数个 50-50个

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

            //向客户端发送一条消息
            string msg = "Hello client!您好...";
            //把字符串编码成byte数组，因为在网络中传递的信息都是用0和1
            byte[] data = System.Text.Encoding.UTF8.GetBytes(msg);
            clientSocket.Send(data);

            //开始接收
            clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
        }
        static byte[] dataBuffer = new byte[1024];
        static void ReceiveCallBack(IAsyncResult ar)//回调函数
        {
            Socket clientSocket = ar.AsyncState as Socket;
            int count = clientSocket.EndReceive(ar);//结束接收
            string msg = Encoding.UTF8.GetString(dataBuffer, 0, count);
            Console.WriteLine("从客户端接收到数据："+msg);
            //回调
            clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
        }

        /// <summary>
        /// 同步
        /// </summary>
        void StartServerSync()
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //10.110.101.57

            //IPAddress xx.xx.xx.xx IpEndPoint xx.xx.xx.xx:port
            //IPAddress iPAddress = new IPAddress(new byte[] { 10,110,101,57 });
            IPAddress iPAddress = IPAddress.Parse("10.110.101.57");//IP地址
            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);//IP地址和端口号

            serverSocket.Bind(iPEndPoint);//绑定IP和端口号
            serverSocket.Listen(0);//开始监听端口号  处理连接队列个数 0-无数个 50-50个

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

            //向客户端发送一条消息
            string msg = "Hello client!您好...";
            //把字符串编码成byte数组，因为在网络中传递的信息都是用0和1
            byte[] data = System.Text.Encoding.UTF8.GetBytes(msg);
            clidenSocket.Send(data);

            //接收客户端的一条消息
            byte[] dataBuffer = new byte[1024];//声明byte数组作缓存
            //接收客户端的内容存到dataBuffer  count存储接收长度
            int count = clidenSocket.Receive(dataBuffer);
            //把byte转为string
            string msgReceive = System.Text.Encoding.UTF8.GetString(dataBuffer, 0, count);
            Console.WriteLine(msgReceive);

            Console.ReadKey();
            clidenSocket.Close();//关闭与客户端连接
            serverSocket.Close();//关闭服务器端
        }
    }
}

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

namespace TCPClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("10.110.101.57"),88));//连接到客户端

            byte[] data = new byte[1024];
            int count = clientSocket.Receive(data);//接收
            string msg = Encoding.UTF8.GetString(data, 0, count);
            Console.WriteLine(msg);

            while (true)
            {
                string s = Console.ReadLine();
                //把string转为byte数组后发送
                clientSocket.Send(Encoding.UTF8.GetBytes(s));
            }

            Console.ReadKey();
            clientSocket.Close();//关闭客户端
        }
    }
}

服务器端开启异步处理客户端链接请求--可以接收多个客户端

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

namespace TCPServer
{
    class Program
    {
        static void Main(string[] args)
        {
            StartServerAsync();
            Console.ReadKey();
        }

        //异步消息接收
        static void StartServerAsync()
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //10.110.101.57

            //IPAddress xx.xx.xx.xx IpEndPoint xx.xx.xx.xx:port
            //IPAddress iPAddress = new IPAddress(new byte[] { 10,110,101,57 });
            IPAddress iPAddress = IPAddress.Parse("10.110.101.57");//IP地址
            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);//IP地址和端口号

            serverSocket.Bind(iPEndPoint);//绑定IP和端口号
            serverSocket.Listen(0);//开始监听端口号  处理连接队列个数 0-无数个 50-50个

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

        }

        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket serverSocket = ar.AsyncState as Socket;
            Socket clientSocket = serverSocket.EndAccept(ar);

            //向客户端发送一条消息
            string msg = "Hello client!您好...";
            byte[] data = System.Text.Encoding.UTF8.GetBytes(msg);//把字符串编码成byte数组，因为在网络中传递的信息都是用0和1
            clientSocket.Send(data);
            
            clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);//开始接收

            serverSocket.BeginAccept(AcceptCallBack, serverSocket);//处理下一个客户端连接
        }

        static byte[] dataBuffer = new byte[1024];
        static void ReceiveCallBack(IAsyncResult ar)//回调函数
        {
            Socket clientSocket = ar.AsyncState as Socket;
            int count = clientSocket.EndReceive(ar);//结束接收
            string msg = Encoding.UTF8.GetString(dataBuffer, 0, count);
            Console.WriteLine("从客户端接收到数据："+msg);
            //回调
            clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
        }

        /// <summary>
        /// 同步
        /// </summary>
        void StartServerSync()
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //10.110.101.57

            //IPAddress xx.xx.xx.xx IpEndPoint xx.xx.xx.xx:port
            //IPAddress iPAddress = new IPAddress(new byte[] { 10,110,101,57 });
            IPAddress iPAddress = IPAddress.Parse("10.110.101.57");//IP地址
            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);//IP地址和端口号

            serverSocket.Bind(iPEndPoint);//绑定IP和端口号
            serverSocket.Listen(0);//开始监听端口号  处理连接队列个数 0-无数个 50-50个

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

            //向客户端发送一条消息
            string msg = "Hello client!您好...";
            //把字符串编码成byte数组，因为在网络中传递的信息都是用0和1
            byte[] data = System.Text.Encoding.UTF8.GetBytes(msg);
            clidenSocket.Send(data);

            //接收客户端的一条消息
            byte[] dataBuffer = new byte[1024];//声明byte数组作缓存
            //接收客户端的内容存到dataBuffer  count存储接收长度
            int count = clidenSocket.Receive(dataBuffer);
            //把byte转为string
            string msgReceive = System.Text.Encoding.UTF8.GetString(dataBuffer, 0, count);
            Console.WriteLine(msgReceive);

            Console.ReadKey();
            clidenSocket.Close();//关闭与客户端连接
            serverSocket.Close();//关闭服务器端
        }
    }
}

最终版代码：（处理正常关闭和非正常关闭）

1，同步方式
    Accept Connect
    Receive
2，异步方式
    BeginAccept EndAccept Connect
    BeginReceive EndReceive

TCPServer

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

namespace TCPServer
{
    class Program
    {
        static void Main(string[] args)
        {
            StartServerAsync();
            Console.ReadKey();
        }

        /// <summary>
        /// 异步消息接收
        /// </summary>
        static void StartServerAsync()
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //10.110.101.57

            //IPAddress xx.xx.xx.xx IpEndPoint xx.xx.xx.xx:port
            //IPAddress iPAddress = new IPAddress(new byte[] { 10,110,101,57 });
            IPAddress iPAddress = IPAddress.Parse("10.110.101.57");
            //IP地址

            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);
            //IP地址和端口号

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

            serverSocket.Listen(0);
            //开始监听端口号  处理连接队列个数 0-无数个 50-50个

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

        /// <summary>
        /// BeginAccept的异步接收的回调方法
        /// </summary>
        /// <param name="ar"></param>
        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket serverSocket = ar.AsyncState as Socket;
            Socket clientSocket = serverSocket.EndAccept(ar);

            //向客户端发送一条消息
            string msg = "Hello client!您好...";
            byte[] data = System.Text.Encoding.UTF8.GetBytes(msg);
            //把字符串编码成byte数组，因为在网络中传递的信息都是用0和1

            clientSocket.Send(data);
            
            clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
            //开始接收

            serverSocket.BeginAccept(AcceptCallBack, serverSocket);
            //处理下一个客户端连接
        }
        static byte[] dataBuffer = new byte[1024];
        //外部声明dataBuffer作为缓存区

        /// <summary>
        /// 回调函数
        /// </summary>
        /// <param name="ar"></param>
        static void ReceiveCallBack(IAsyncResult ar)
        {
            Socket clientSocket = null;
            try
            {
                clientSocket = ar.AsyncState as Socket;
                int count = clientSocket.EndReceive(ar);
                //结束接收

                //正常关闭的处理
                if (count == 0)
                {
                    clientSocket.Close();
                    return;
                }
                string msg = Encoding.UTF8.GetString(dataBuffer, 0, count);
                Console.WriteLine("从客户端接收到数据：" + msg);
                
                clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
                //回调
            }
            catch (Exception e)
            {
                Console.WriteLine(e);

                //非正常关闭的处理
                if (clientSocket != null)
                {
                    clientSocket.Close();
                }
            }

            
        }

        /// <summary>
        /// 同步
        /// </summary>
        void StartServerSync()
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //10.110.101.57

            //IPAddress xx.xx.xx.xx IpEndPoint xx.xx.xx.xx:port
            //IPAddress iPAddress = new IPAddress(new byte[] { 10,110,101,57 });
            IPAddress iPAddress = IPAddress.Parse("10.110.101.57");//IP地址
            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);//IP地址和端口号

            serverSocket.Bind(iPEndPoint);//绑定IP和端口号
            serverSocket.Listen(0);//开始监听端口号  处理连接队列个数 0-无数个 50-50个

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

            //向客户端发送一条消息
            string msg = "Hello client!您好...";
            //把字符串编码成byte数组，因为在网络中传递的信息都是用0和1
            byte[] data = System.Text.Encoding.UTF8.GetBytes(msg);
            clidenSocket.Send(data);

            //接收客户端的一条消息
            byte[] dataBuffer = new byte[1024];//声明byte数组作缓存
            //接收客户端的内容存到dataBuffer  count存储接收长度
            int count = clidenSocket.Receive(dataBuffer);
            //把byte转为string
            string msgReceive = System.Text.Encoding.UTF8.GetString(dataBuffer, 0, count);
            Console.WriteLine(msgReceive);

            Console.ReadKey();
            clidenSocket.Close();//关闭与客户端连接
            serverSocket.Close();//关闭服务器端
        }
    }
}

TCPClient

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

namespace TCPClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("10.110.101.57"),88));//连接到客户端

            byte[] data = new byte[1024];
            int count = clientSocket.Receive(data);//接收
            string msg = Encoding.UTF8.GetString(data, 0, count);
            Console.WriteLine(msg);

            while (true)
            {
                string s = Console.ReadLine();
                if (s == "c")
                {
                    clientSocket.Close();
                    return;
                }
                //把string转为byte数组后发送
                clientSocket.Send(Encoding.UTF8.GetBytes(s));
            }

            Console.ReadKey();
            clientSocket.Close();//关闭客户端
        }
    }
}

粘包分包问题
粘包和分包是利用Socket在TCP协议下内部的优化机制
1，什么是粘包（发送消息小而且多，发送端粘包）
      发送频繁，消息小
2，什么是分包（接收端发现接收的数据很大，分包接收）

       消息很大

粘包和分包问题的解决方案：

字节转换
1，字符串转成字节数组 System.Text.Encoding.UTF8.GetBytes    占用的字节数不固定，所以不符合要求
                                                                                    .GetString
2，Int32转成字节数组BitConverter.GetBytes    值类型，默认占四个字节
                                                        .ToXX
代码部分：带数据长度，数据的发送和接收
TCPServer

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

namespace TCPServer
{
    class Message
    {
        private byte[] data = new byte[1024];//存储位置
        private int startIndex = 0;//我们存储了多少个字节的数据在数组里面

        public void AddCount(int count)
        {
            startIndex += count;
        }
        public byte[] Data
        {
            get { return data; }
        }
        public int StartIndex
        {
            get { return startIndex; }
        }
        public int RemainSize   //数组剩余长度
        {
            get { return data.Length - startIndex; }
        }
        /// <summary>
        /// 解析数据或者叫做读取数据
        /// </summary>
        public void ReadMessage()
        {
            while (true)
            {
                if (startIndex <= 4) return;
                //长度小于4个字节，不处理，直接返回

                int count = BitConverter.ToInt32(data, 0);
                //获取消息长度

                if ((startIndex - 4) >= count)//如果消息长度-4个字节的消息头，则解析
                {
                    string s = Encoding.UTF8.GetString(data, 4, count);
                    //从第4个字节开始解析count个

                    Console.WriteLine("解析出来一条数据：" + s);
                    Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                    //把已经解析出来的数据去除
                    startIndex -=(count + 4);
                }
                else
                {
                    break;
                }
            }
        }
    }
}

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

namespace TCPServer
{
    class Program
    {
        static void Main(string[] args)
        {
            StartServerAsync();
            Console.ReadKey();
        }

        /// <summary>
        /// 异步消息接收
        /// </summary>
        static void StartServerAsync()
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //10.110.101.57

            //IPAddress xx.xx.xx.xx IpEndPoint xx.xx.xx.xx:port
            //IPAddress iPAddress = new IPAddress(new byte[] { 10,110,101,57 });
            IPAddress iPAddress = IPAddress.Parse("10.110.101.57");
            //IP地址

            IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, 88);
            //IP地址和端口号

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

            serverSocket.Listen(0);
            //开始监听端口号  处理连接队列个数 0-无数个 50-50个

            serverSocket.BeginAccept(AcceptCallBack, serverSocket);
            //Socket clientSocket = serverSocket.Accept();//接收一个客户端的链接
        }
        static Message msg = new Message();
        /// <summary>
        /// BeginAccept的异步接收的回调方法
        /// </summary>
        /// <param name="ar"></param>
        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket serverSocket = ar.AsyncState as Socket;
            Socket clientSocket = serverSocket.EndAccept(ar);

            //向客户端发送一条消息
            string msgStr = "Hello client!您好...";
            byte[] data = System.Text.Encoding.UTF8.GetBytes(msgStr);
            //把字符串编码成byte数组，因为在网络中传递的信息都是用0和1

            clientSocket.Send(data);
            
            clientSocket.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, clientSocket);
            //开始接收

            serverSocket.BeginAccept(AcceptCallBack, serverSocket);
            //处理下一个客户端连接
        }
        static byte[] dataBuffer = new byte[102400];
        //外部声明dataBuffer作为缓存区

        /// <summary>
        /// 回调函数
        /// </summary>
        /// <param name="ar"></param>
        static void ReceiveCallBack(IAsyncResult ar)
        {
            Socket clientSocket = null;
            try
            {
                clientSocket = ar.AsyncState as Socket;
                int count = clientSocket.EndReceive(ar);
                //结束接收

                //正常关闭的处理
                if (count == 0)
                {
                    clientSocket.Close();
                    return;
                }
                msg.AddCount(count);
                //string msgStr = Encoding.UTF8.GetString(dataBuffer, 0, count);
                //Console.WriteLine("从客户端接收到数据：" + msgStr);
                msg.ReadMessage();
                //clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
                clientSocket.BeginReceive(msg.Data, msg.StartIndex, msg.RemainSize, SocketFlags.None, ReceiveCallBack, clientSocket);
                //回调
            }
            catch (Exception e)
            {
                Console.WriteLine(e);

                //非正常关闭的处理
                if (clientSocket != null)
                {
                    clientSocket.Close();
                }
            }
        }
    }
}

TCPClient
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TCPClient
{
    /// <summary>
    /// 在客户端发送数据的时候加上数据长度
    /// </summary>
    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.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace TCPClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("10.110.101.57"),88));//连接到客户端

            byte[] data = new byte[1024];
            int count = clientSocket.Receive(data);//接收
            string msg = Encoding.UTF8.GetString(data, 0, count);
            Console.WriteLine(msg);

            //while (true)
            //{
            //    string s = Console.ReadLine();
            //    if (s == "c")
            //    {
            //        clientSocket.Close();
            //        return;
            //    }
            //    //把string转为byte数组后发送
            //    clientSocket.Send(Encoding.UTF8.GetBytes(s));
            //}

            for (int i = 0; i < 100; i++)
            {
                clientSocket.Send(Message.GetBytes(i.ToString() + "长度"));
            }

            Console.ReadKey();
            clientSocket.Close();//关闭客户端
        }
    }
}

数据库的连接操作
数据库版本MySQL5.7 确保数据库的服务已经启动
引入MySql.Data.dll
使用c#连接MySQL数据库
对数据库进行增删改查
查询数据库信息

using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MySQLDB
{
    class Program
    {
        static void Main(string[] args)
        {
            string connStr = "Database=test007;Data Source=127.0.0.1;port=3306;User Id=root;Password=HKW112233";
            //连接字符串

            MySqlConnection conn = new MySqlConnection(connStr);
            //创建连接

            conn.Open();
            //打开连接

            MySqlCommand cmd = new MySqlCommand("select * from user", conn);
            //连接sql语句

            MySqlDataReader reader = cmd.ExecuteReader();
            //声明reader为执行读取

            while (reader.Read())//当有行读取
            {
                string username = reader.GetString("username");
                string password = reader.GetString("password");
                Console.WriteLine(username+":"+password);
            }

            reader.Close();
            conn.Close();
            Console.ReadKey();
        }
    }
}

代码整理：数据库的增删改查

using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MySQLDB
{
    class Program
    {
        static void Main(string[] args)
        {
            string connStr = "Database=test007;Data Source=127.0.0.1;port=3306;User Id=root;Password=HKW112233";
            //连接字符串

            MySqlConnection conn = new MySqlConnection(connStr);
            //创建连接

            conn.Open();
            //打开连接

            #region 查询
            //MySqlCommand cmd = new MySqlCommand("select * from user", conn);
            连接sql语句

            //MySqlDataReader reader = cmd.ExecuteReader();
            声明reader为执行读取

            //while (reader.Read())//当有行读取
            //{
            //    string username = reader.GetString("username");
            //    string password = reader.GetString("password");
            //    Console.WriteLine(username+":"+password);
            //}

            //reader.Close();
            #endregion
            
            #region 插入
            //string username = "cwer";string password = "lcker';delete from user;";
            sql注入语句

            MySqlCommand cmd = new MySqlCommand("insert into user set username ='" + username + "'" + ",password='" + password + "'", conn);
            //MySqlCommand cmd = new MySqlCommand("insert into user set username=@un , password = @pwd", conn);

            用字符串组拼的方式解决sql注入的问题
            //cmd.Parameters.AddWithValue("un", username);
            //cmd.Parameters.AddWithValue("pwd", password);

            //cmd.ExecuteNonQuery();
            #endregion

            #region 删除
            //MySqlCommand cmd = new MySqlCommand("delete from user where id = @id", conn);
            //cmd.Parameters.AddWithValue("id", 18);

            //cmd.ExecuteNonQuery();
            #endregion

            #region 更新
            MySqlCommand cmd = new MySqlCommand("update user set password = @pwd where id = 2", conn);
            cmd.Parameters.AddWithValue("pwd", "kerven");

            cmd.ExecuteNonQuery();
            #endregion

            conn.Close();
            Console.ReadKey();
        }
    }
}

游戏服务器端开发
1、Server—TCP、Socket监听客户端
2、ConnHelper—连接数据库
3、Controller—客户端请求
4、Model—与数据库表对应

5、DAO—操作数据库

服务器端架构

服务器端和客户端通信流程

Unity客户端的开发
1，游戏逻辑开发
    人物控制，摄像机跟随，攻击
2，游戏UI开发
    登录界面
    注册界面
    房间列表

    创建房间

UI框架的导入
1、导入SKUIFramework.unitypackage
游戏客户端架构图

修改：客户端的面板功能自己写

数据库设计
1,第一张表用户信息
User  id  username  password
2,数据表，用来存放玩家的战绩
Result id userid totalCount winCount

 

Kerven_HKW
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Kerven_HKW

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值