Unity网络通讯学习

---部分截图来自 siki学院Unity网络通讯课程

Socket 

网络上的两个程序通过一个双向的通信连接实现数据交换，这个连接的一端称为一个 Socket ，Socket 包含了网络通信必须的五种信息

Socket 例子{ 

协议： TCP

本地： IP ，端口

远程： IP ，端口

}

可以通过ipconfig，netstat   -ano 查看 Ip 和端口

创建客户端连接服务端

客户端代码：

using System;
using System.Net.Sockets;

namespace wangluo
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建一个Socket 需要using System.Net.Sockets;
            Socket tempClient = new Socket(AddressFamily.InterNetwork,
                  SocketType.Stream, ProtocolType.Tcp);
            tempClient.Connect("127.0.0.1", 8888);
        }
    }
}

服务端代码：

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

namespace Server
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket tempServer = new Socket(AddressFamily.InterNetwork, 
                 SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint tempEndPoint = 
                  new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888);  
                   //using System.Net;
            tempServer.Bind(tempEndPoint);  //绑定端口
            tempServer.Listen(0);  //监听，0表示挂起的队列无限长
            Console.WriteLine("服务端启动成功");

            Socket tempConnectClient = tempServer.Accept();
            Console.WriteLine("客户端连接成功:" + tempConnectClient);
        }
    }
}

先开启服务端再开启客户端 

客户端服务端互发信息

客户端代码：

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

namespace wangluo
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建一个Socket 需要using System.Net.Sockets;
            Socket tempClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            tempClient.Connect("127.0.0.1", 8888);

            //客户端向服务端发信息
            string tempSendInfo = Console.ReadLine();
            //将字符串转换成 buffer
            byte[] tempSendData = Encoding.UTF8.GetBytes(tempSendInfo);
            //发送信息
            tempClient.Send(tempSendData);
            
            //接收来自服务端的信息
            byte[] tempReadBuffer = new byte[1024];
            tempClient.Receive(tempReadBuffer);
            string tempReadString = Encoding.UTF8.GetString(tempReadBuffer);
            Console.WriteLine("接收到服务端信息：" + tempReadString);
        }
    }
}

服务端代码：

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

namespace Server
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket tempServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint tempEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888);  //using System.Net;
            tempServer.Bind(tempEndPoint);  //绑定端口
            tempServer.Listen(0);  //监听，0表示挂起的队列无限长
            Console.WriteLine("服务端启动成功");

            Socket tempConnectClient = tempServer.Accept();
            Console.WriteLine("客户端连接成功:" + tempConnectClient);

            byte[] tempReadBuffer = new byte[1024];
            tempConnectClient.Receive(tempReadBuffer);
            //将 byte 转换成字符串
            string tempReadString = Encoding.UTF8.GetString(tempReadBuffer);
            Console.WriteLine("接收到客户端信息：" + tempReadString);

            //服务端向客户端发信息
            string tempSendInfo = Console.ReadLine();
            byte[] tempSendData = Encoding.UTF8.GetBytes(tempSendInfo);
            tempConnectClient.Send(tempSendData);
        }
    }
}

封装一下代码：

客户端：

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

namespace wangluo
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建一个Socket 需要using System.Net.Sockets;
            Socket tempClient = CreateSocket();

            tempClient.Connect("127.0.0.1", 8888);

            Send(tempClient);

            Receive(tempClient);
            
        }

        static Socket CreateSocket()
        {
            return new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

        static void Send(Socket tempClient)
        {
            //客户端向服务端发信息
            string tempSendInfo = Console.ReadLine();
            //将字符串转换成 buffer
            byte[] tempSendData = Encoding.UTF8.GetBytes(tempSendInfo);
            //发送信息
            tempClient.Send(tempSendData);
        }

        static void Receive(Socket tempClient)
        {
            //接收来自服务端的信息
            byte[] tempReadBuffer = new byte[1024];
            tempClient.Receive(tempReadBuffer);
            string tempReadString = Encoding.UTF8.GetString(tempReadBuffer);
            Console.WriteLine("接收到服务端信息：" + tempReadString);
        }
    }
}

 服务端：

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

namespace Server
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket tempServer = CreateSocket();
            BindAndListen(tempServer);

            Socket tempConnectClient = Accept(tempServer);

            Receive(tempConnectClient);

            Send(tempConnectClient);
        }

        static Socket CreateSocket()
        {
            return new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

        static void BindAndListen(Socket pSocket)
        {
            IPEndPoint tempEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888);  //using System.Net;
            pSocket.Bind(tempEndPoint);  //绑定端口
            pSocket.Listen(0);  //监听，0表示挂起的队列无限长
            Console.WriteLine("服务端启动成功");
        }

        static Socket Accept(Socket pSocket)
        {
            Socket tempConnectClient = pSocket.Accept();
            Console.WriteLine("客户端连接成功:" + tempConnectClient);
            return tempConnectClient;
        }

        static void Receive(Socket pSocket)
        {
            byte[] tempReadBuffer = new byte[1024];
            pSocket.Receive(tempReadBuffer);
            //将 byte 转换成字符串
            string tempReadString = Encoding.UTF8.GetString(tempReadBuffer);
            Console.WriteLine("接收到客户端信息：" + tempReadString);
        }

        static void Send(Socket pSocket)
        {
            //服务端向客户端发信息
            string tempSendInfo = Console.ReadLine();
            byte[] tempSendData = Encoding.UTF8.GetBytes(tempSendInfo);
            pSocket.Send(tempSendData);
        }
    }
}

Socket 代码解析：

AddressFamily: InterNetwork 使用IPv4    InterNetworkV6 使用IPv6

SocketType：

异步

客户端：异步 Connect

// Main
tempClient.BeginConnect("127.0.0.1", 8888, ConnectCallback, tempClient);

static void ConnectCallback(IAsyncResult ar)
        {
            //beginconnect函数中最后一个参数就是用来作为callback的参数使用
            //将其由 object 类型强制转换成 socket 类型
            Socket tempSocket = (Socket)ar.AsyncState;
            //与 BeginConnect 配套的 EndConnect
            //异步的结束
            tempSocket.EndConnect(ar);
            Console.WriteLine("连接服务器成功");

            Send(tempSocket);

            Receive(tempSocket);

            Close(tempSocket);
        }

异步 Receive

//接收来自服务端的信息  调用 Receive 的地方
            tempSocket.BeginReceive(tempReadBuffer, 0, 1024,
               SocketFlags.None, ReceiveCallback, tempSocket);


static void ReceiveCallback(IAsyncResult ar)
        {        
            Socket tempSocket = (Socket)ar.AsyncState;
            tempSocket.EndReceive(ar);
            string tempReadString = Encoding.UTF8.GetString(tempReadBuffer);
            Console.WriteLine("接收到服务端信息：" + tempReadString);

            Close(tempSocket);
        }

异常处理：

static void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                Socket tempSocket = (Socket)ar.AsyncState;
                tempSocket.EndReceive(ar);
                string tempReadString = Encoding.UTF8.GetString(tempReadBuffer);
                Console.WriteLine("接收到服务端信息：" + tempReadString);

                Close(tempSocket);
            }
            catch (Exception ex)
            {
                Console.WriteLine("连接异常" + ex.ToString());
                
            }
            
        }

异步send

tempClient.BeginSend(tempSendData,0,tempSendData.Length,
    SocketFlags.None, SendCallback, tempClient);

static void SendCallback(IAsyncResult ar)
        {
            try
            {
                Socket tempSocket = (Socket)ar.AsyncState;
                tempSocket.EndSend(ar);
                Console.WriteLine("发送数据成功");
            }
            catch (Exception ex)
            {
                Console.WriteLine("发送异常");
            }

总览：

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

namespace wangluo
{
    class Program
    {
        static private byte[] tempReadBuffer = new byte[1024];

        static void Main(string[] args)
        {
            //创建一个Socket 需要using System.Net.Sockets;
            Socket tempClient = CreateSocket();

            tempClient.BeginConnect("127.0.0.1", 8888, ConnectCallback, tempClient);

            System.Threading.Thread.Sleep(1000);
        }

        static Socket CreateSocket()
        {
            return new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

        static void Send(Socket tempClient)
        {
            //客户端向服务端发信息
            string tempSendInfo = Console.ReadLine();
            //将字符串转换成 buffer
            byte[] tempSendData = Encoding.UTF8.GetBytes(tempSendInfo);
            //发送信息
            tempClient.BeginSend(tempSendData,0,tempSendData.Length,SocketFlags.None, SendCallback, tempClient);
        }

        static void Close(Socket pSocket)
        {
            pSocket.Close();
        }

        static void ConnectCallback(IAsyncResult ar)
        {
            //beginconnect函数中最后一个参数就是用来作为callback的参数使用
            //将其由 object 类型强制转换成 socket 类型
            Socket tempSocket = (Socket)ar.AsyncState;
            //与 BeginConnect 配套的 EndConnect
            //异步的结束
            tempSocket.EndConnect(ar);
            Console.WriteLine("连接服务器成功");

            Send(tempSocket);

            //接收来自服务端的信息
            tempSocket.BeginReceive(tempReadBuffer, 0, 1024, SocketFlags.None, ReceiveCallback, tempSocket);
        }

        static void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                Socket tempSocket = (Socket)ar.AsyncState;
                tempSocket.EndReceive(ar);
                string tempReadString = Encoding.UTF8.GetString(tempReadBuffer);
                Console.WriteLine("接收到服务端信息：" + tempReadString);

                Close(tempSocket);
            }
            catch (Exception ex)
            {
                Console.WriteLine("接收失败" + ex.ToString());
                
            }
            
        }

        static void SendCallback(IAsyncResult ar)
        {
            try
            {
                Socket tempSocket = (Socket)ar.AsyncState;
                tempSocket.EndSend(ar);
                Console.WriteLine("发送数据成功");
            }
            catch (Exception ex)
            {
                Console.WriteLine("发送异常");
            }
        }
    }
}

服务端：异步 Accept

//main
tempServer.BeginAccept(AcceptCallback, tempServer);

static void AcceptCallback(IAsyncResult ar)
        {
            try
            {
                Socket tempSeverSocket = (Socket)ar.AsyncState;
                Socket tempClientSocket = tempSeverSocket.EndAccept(ar);

                Console.WriteLine("客户端接收成功：" + ((IPEndPoint)tempClientSocket.RemoteEndPoint));

                Receive(tempClientSocket);

                Send(tempClientSocket);
            }
            catch (Exception ex)
            {
                Console.WriteLine("接收客户端失败");
            }
        }

服务端：异步Send和异步Receive

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

namespace Server
{
    class Program
    {
        static byte[] readBuffer = new byte[1024];

        static void Main(string[] args)
        {
            Socket tempServer = CreateSocket();
            BindAndListen(tempServer);

            tempServer.BeginAccept(AcceptCallback, tempServer);

            System.Threading.Thread.Sleep(1000);
        }

        static Socket CreateSocket()
        {
            return new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

        static void BindAndListen(Socket pSocket)
        {
            IPEndPoint tempEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888);  //using System.Net;
            pSocket.Bind(tempEndPoint);  //绑定端口
            pSocket.Listen(0);  //监听，0表示挂起的队列无限长
            Console.WriteLine("服务端启动成功");
        }

        static void Send(Socket pSocket)
        {
            //服务端向客户端发信息
            string tempSendInfo = Console.ReadLine();
            byte[] tempSendData = Encoding.UTF8.GetBytes(tempSendInfo);
            pSocket.BeginSend(tempSendData, 0, tempSendData.Length, SocketFlags.None, SendCallback, pSocket);
        }

        static void Close(Socket pSocket)
        {
            pSocket.Close();
        }

        static void AcceptCallback(IAsyncResult ar)
        {
            try
            {
                Socket tempSeverSocket = (Socket)ar.AsyncState;
                Socket tempClientSocket = tempSeverSocket.EndAccept(ar);

                Console.WriteLine("客户端接收成功：" + ((IPEndPoint)tempClientSocket.RemoteEndPoint));

                tempClientSocket.BeginReceive(readBuffer, 0, 1024, SocketFlags.None,
                    ReceiveCallback, tempClientSocket);

                Send(tempClientSocket);
            }
            catch (Exception ex)
            {
                Console.WriteLine("接收客户端失败");
            }
        }

        static void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                Socket tempSocket = (Socket)ar.AsyncState;
                tempSocket.EndReceive(ar);
                string tempReadString = Encoding.UTF8.GetString(readBuffer);
                Console.WriteLine("接收到客户端信息：" + tempReadString);

                Close(tempSocket);
            }
            catch (Exception ex)
            {
                Console.WriteLine("接收失败" + ex.ToString());

            }
        }

        static void SendCallback(IAsyncResult ar)
        {
            try
            {
                Socket tempSocket = (Socket)ar.AsyncState;
                tempSocket.EndSend(ar);
                Console.WriteLine("发送数据成功");
            }
            catch (Exception ex)
            {
                Console.WriteLine("发送异常");
            }
        }
    }
}

让服务端支持多个客户端连接

//用来存放连接到的客户端
        private static List clientList = new List();

static void AcceptCallback(IAsyncResult ar)
        {
            Socket tempSeverSocket = (Socket)ar.AsyncState;
                Socket tempClientSocket = tempSeverSocket.EndAccept(ar);

                Console.WriteLine("客户端接收成功：" + ((IPEndPoint)tempClientSocket.RemoteEndPoint));

                tempClientSocket.BeginReceive(readBuffer, 0, 1024, SocketFlags.None,
                    ReceiveCallback, tempClientSocket);
                tempSeverSocket.BeginAccept(AcceptCallback, tempSeverSocket);
                clientList.Add(tempClientSocket);

                Send(tempClientSocket);;
            
        }

HTTP协议

C#使用 http 协议的示例： 

private static void Get()
        {
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create("http://www.metools.info");
            request.Method = "GET";
            //request.Accept
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            response.GetResponseStream();
            Stream responseStream = response.GetResponseStream();
            string result = new StreamReader(responseStream).ReadToEnd();
            Console.WriteLine(result);
        }

FTP 协议