C# Socket编程 TCP/UDP简单示例（多线程与异步两种方法）

#多线程去处理消息的接收，发送
##TCP协议，未封装过的Socket接口
这部分是服务端的代码，其实客户端的代码在逻辑上与之类似，通过多线程实现了同时处理

class Client
    {
        public Socket clientSocket;
        private Thread t;
        private byte[]mybyte=new byte[1024];
        public Client(Socket s)
        {
            clientSocket = s;
            t = new Thread(ReceiveMessage);
            t.Start();
        }
        void ReceiveMessage()
        {
            while(true)
            {
                if(clientSocket.Poll(15,SelectMode.SelectRead))
                {
                    clientSocket.Close();
                    break;
                }
                int length = clientSocket.Receive(mybyte);
                string res = Encoding.UTF8.GetString(mybyte, 0, length);
                //将消息分发到所有客户端
                Program.SendToAllClient(res);
                Console.WriteLine(res);
            }
        }
        
    }
    class Program
    {
        public static List<Client> clientList = new List<Client>();
        public static void SendToAllClient(string e)
        {
            var UnconnectedList = new List<Client>();
            foreach (var temp in Program.clientList)
            {
                if (temp.clientSocket.Connected)
                {
                    //Console.WriteLine("开始发送消息");
                    temp.clientSocket.Send(Encoding.UTF8.GetBytes(e));
                } 
                else UnconnectedList.Add(temp);
            }
            foreach (var temp in UnconnectedList)
            {
                Program.clientList.Remove(temp);
            }
        }
        static void Main(string[] args)
        {
            //创建
            Socket tcpServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //绑定端口以及IP
            IPAddress ipaddr = new IPAddress(new byte[] { 192, 168, 0, 100 });
            EndPoint point = new IPEndPoint(ipaddr,7878);//对于ip+端口的一个封装
            tcpServer.Bind(point);
            //开始监听
            tcpServer.Listen(100);//参数是最大连接数
            while(true)
            {
                Socket returnSocket = tcpServer.Accept();//等待连接，直到连接时进行下面的语句
                Console.WriteLine("一个客户端连接了过来");
                Client c = new Client(returnSocket);
                clientList.Add(c);
            }
            

            string mass = "你好，欢迎！";
            byte[]str=Encoding.UTF8.GetBytes(mass);
            
        }
    }

##UDP协议的简单示例
单次通讯，UDP相对TCP结构简单一些，如果要保证其可靠性，就需要应用层做工作了。

class Program
    {
        static void Main(string[] args)
        {
            //创建 UDP协议相对TCP不需要连接（它不是面向连接的，因而也不保证可靠性），相对比较简单
            Socket udpServer = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            //绑定
            udpServer.Bind(new IPEndPoint(IPAddress.Parse("192.168.0.100"), 7878));
            //接受数据
            byte[] data = new byte[1024];
            EndPoint ip = new IPEndPoint(IPAddress.Any, 0);
            int length = udpServer.ReceiveFrom(data, ref ip);//对于客户端，不需要绑定，在发送时会自动分配端口号，使用SendTo想服务器发送消息
            string res = Encoding.UTF8.GetString(data, 0, length);

            Console.WriteLine("从IP：" + (ip as IPEndPoint).Address.ToString() + ":" + (ip as IPEndPoint).Port.ToString() + "获得了数据：" + res);

            udpServer.Close();
        }
    }

##封装过后的TCP协议示例

class Program
    {
        static void Main(string[] args)
        {
            //创建
            TcpListener listener = new TcpListener(IPAddress.Parse("192.168.0.100"), 7878);
            //开始监听
            listener.Start();
            //等待客户端连接
            TcpClient client = listener.AcceptTcpClient();
            //取得数据,
            NetworkStream stream = client.GetStream();

            byte[] data = new byte[1024];
            int length = stream.Read(data, 0, 1024);//0指的是开始存储的data索引位置，1024指读取到数据的最大索引，超过这个索引就需要多次传输了
            string message = Encoding.UTF8.GetString(data, 0, length);
            Console.WriteLine(message);

            stream.Close();//流的关闭不会影响socket接口
            client.Close();//关闭客户端连接，当前服务器上属于这个客户端的socket会被关闭，连接被切断,但服务器仍然可以正常接收新的连接
            listener.Stop();//关闭服务器socket接口

            //对于客户端的创建，流程类似，当创建一个客户端TCPClient时会自动连接相应的服务器
        }
    }

##封装过后的UDP示例
UDP本质上不分客户端和服务器端，因此写法类似

 class Program
    {
        static void Main(string[] args)
        {
            //创建UDPClient，udp以数据报的形式发送数据，没有连接过程，所以客户端与服务器端的写法类似
            UdpClient client = new UdpClient(new IPEndPoint( IPAddress.Parse("192.168.0.100"), 7878));


            IPEndPoint ip = new IPEndPoint(IPAddress.Any, 0);//UDP发送都会附加一条IP信息，通过这个信息可以去向另一端发送信息
            byte[] data = client.Receive(ref ip);//client通过send、receive发送接收消息
            string message = Encoding.UTF8.GetString(data, 0, data.Length);
        }
    }

#使用异步的方法去接收消息与发送
##服务器端

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

namespace MyServer
{
    class Program
    {
        static byte[] dataBuffer = new byte[1024];
         static void Main(string[] args)
        {
            StartServerAsync();
            Console.ReadKey();



        }
        static void StartServerAsync()
        {
            //创建
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //绑定端口以及IP
            IPAddress ipaddr = new IPAddress(new byte[] { 192, 168, 0, 100 });
            //IPAddress ipaddrs = IPAddress.Parse("192.168.0.100");这种方法也是可以的
            EndPoint point = new IPEndPoint(ipaddr, 7878);//对于ip+端口的一个封装
            serverSocket.Bind(point);
            //开始监听
            serverSocket.Listen(0);//参数是最大连接数
            //Socket clientSocket = serverSocket.Accept();
            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) { clientSocket.Close();return; }//count为0，说明客户端已经断开连接，此时断开
                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();
                }
            }

            
        }
        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket serverSocket = ar.AsyncState as Socket;
            Socket clientSocket = serverSocket.EndAccept(ar);//结束异步，此时收到客户端连接
            //向客户端发送消息
            string msg = "Hello client!";
            byte[] data = Encoding.UTF8.GetBytes(msg);
            clientSocket.Send(data);//向客户端发送消息
            clientSocket.BeginReceive(dataBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);//开始异步接收消息
            serverSocket.BeginAccept(AcceptCallBack, serverSocket);//再次异步接收连接
        }

    }
}

##客户端

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

namespace MyClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            clientSocket.Connect(new IPEndPoint(IPAddress.Parse("192.168.0.100"), 7878));
            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 == "close") { clientSocket.Close();return; }//输入close，关闭连接
                clientSocket.Send(Encoding.UTF8.GetBytes(s));
            }
            Console.ReadKey();
            clientSocket.Close();
        }
    }
}