c# TCP实现

1TCP介绍

TCP是TCP/IP体系中非常复杂的一个协议，主要特点有

• 面向连接的运输层协议（好比打电话）
• 每一条TCPl连接只能有两个端点，TCP是点对点通信。
• TCP连接提供可靠交付的服务，通过TCP连接的数据，无差错、不丢失、不重复，并且按序到达。
• TCP提供全双工通信
• 面向字节流

TCP把连接作为最基本的抽象，TCP连接的两个端口是套接字：socket，主义socket有多种不同的意思，注意区别。
socket=(IP地址：端口号)

C#中实现使用TCP连接

分为服务器端，和客户端。

服务器端

 static   Thread thread_listen = null;//负责监听客户端消息的线程
        static Thread thread_send = null;//负责向客户端发送消息的线程
     static    Socket socket_listen = null; //负责监听客户端的套接字

这三个是重要变量，分别起到了注释里写的作用
贴代码把，，注释挺详细的。

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

namespace TCPServer
{
    class Program
    {
     static   Thread thread_listen = null;//负责监听客户端消息的线程
        static Thread thread_send = null;//负责向客户端发送消息的线程
     static    Socket socket_listen = null; //负责监听客户端的套接字
    
       /// <summary>
       /// 用来对客户端进行监听
       /// </summary>
        private static void ListenConnect()
        {
            while (true) //持续不断监听
            {
                try
                {
                    //使用返回的socket客户端做通信
                    Socket client_socket = socket_listen.Accept();
                    Console.WriteLine("一个客户端连接成功");

                 

                    //创建一个通信线程，从客户端接收消息，，
                    var pts = new ParameterizedThreadStart(ReceiveFromClient);
                    Thread thread = new Thread(pts);                
                    thread.IsBackground = true;//后台线程，在主线程退出时退出
                    //启动线程，并将此客户端端口传递给新线程
                    thread.Start(client_socket);

                    //创建一个通信线程，向客户端发送消息，，
                    var send_thread = new ParameterizedThreadStart(SendToClient);
                    Thread thread2 = new Thread(send_thread);
                    thread2.IsBackground = true;
                    thread2.Start(client_socket);

                   
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    break;
                }

            }
        }
        /// <summary>
        /// 用于向客户端发送消息，
        /// </summary>
        /// <param name="socket_client_para">客户端socket</param>
        private static void SendToClient(object socket_client_para)
        {
            Socket client_socket = socket_client_para as Socket;
            while(true)
            {
                try
                {
                    string msg=Console.ReadLine();
                    
                    //对字符串进行编码，得到一个字符串的字节数组
                    byte[] data = Encoding.UTF8.GetBytes(msg);
                    //发送
                    client_socket.Send(data);

                    Console.WriteLine("向客户端发送了一条数据");
                }
                catch(Exception e)
                {
                    Console.WriteLine(e.Message);
                    
                    client_socket.Close();   //关闭当前与服务器通信的客户端
                    Console.WriteLine("客户端" + client_socket.RemoteEndPoint + "中断连接");
                }

            }

        }
        /// <summary>
        /// 从客户端接收消息
        /// </summary>
        /// <param name="socket_client_para">客户端socket</param>
        private static void ReceiveFromClient(object socket_client_para)
        {
            Socket client_socket = socket_client_para as Socket;
            //向客户端发第一条消息
            
            while (true)
            {
                //创建一个内存缓冲区，大小为1M(2的20次)
                byte[] rec_msg_buffer = new byte[1024 * 1024];

                try
                {
                    //接受来自客户端的消息。返回值为消息的长度
                    int length = client_socket.Receive(rec_msg_buffer);
                    if (length != 0)
                    {
                        string Msg = Encoding.UTF8.GetString(rec_msg_buffer,0,length);
                        Console.WriteLine("客户端" + client_socket.RemoteEndPoint + "的消息:" + Msg);

                    }
                        


                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                  
                    client_socket.Close();   //关闭当前与服务器通信的客户端
                    Console.WriteLine("客户端" + client_socket.RemoteEndPoint + "中断连接");
                }
            }
        }

     
        static void Main(string[] args)
        {
           

            //启动服务
            socket_listen = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPAddress ip_address = IPAddress.Parse("xxx.xxx.xxx.xxx");//服务器ip地址
            IPEndPoint end_point = new IPEndPoint(ip_address, 8333);  //服务器终端

            socket_listen.Bind(end_point);//将socket与终端绑定在一起
            socket_listen.Listen(20);//将套接字的监听队列长度限制为20

            
            thread_listen = new Thread(ListenConnect);
//            thread_listen.IsBackground = true;
            thread_listen.Start();  //启动监听线程

           
            Console.WriteLine("开始监听");


        }
    }
}

客户端

		static Thread thread_client_receive = null;//负责监听服务端消息的线程
        static Thread thread_client_send = null;//负责给服务端发消息的线程
         static Socket  socket = null;//1个客户端套接字

以上为三个重要的变量

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

namespace TCPClient
{
    class Program
    {
        static Thread thread_client_receive = null;//负责监听服务端消息的线程
        static Thread thread_client_send = null;//负责给服务端发消息的线程
         static Socket  socket = null;//1个客户端套接字
        static void Main(string[] args)
        {
            string address = ""; //服务器ip地址
            int port = 8333;                            //服务器端口号
            //定义一个套接字监听
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            
            try
            {
                Console.WriteLine( "正在连接服务器" + address +":" +port.ToString());
                socket.Connect(new IPEndPoint(IPAddress.Parse(address), port));
                Console.WriteLine("连接成功");
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message+"\n连接失败");
                return;
            }

         
            //开启接收服务器消息线程
            Console.WriteLine("连接到服务器");
            thread_client_receive = new Thread(RevFromServer);
            //            thread_client_receive.IsBackground = true;
            thread_client_receive.Start();
                        //开启发送消息线程
            thread_client_send = new Thread(SendMsg);
            //            thread_client_send.IsBackground = true;
            thread_client_send.Start();
            
        
        }
        private static void RevFromServer()
        {
            while (socket.Connected)//持续监听服务器发来的消息
            {
                byte[] rev_msg_buffer = new byte[1024];
                try
                {
                    int length = socket.Receive(rev_msg_buffer);
                    if (length != 0)
                    {
                        string Msg = Encoding.UTF8.GetString(rev_msg_buffer, 0, length);
                        Console.WriteLine("服务器端" + socket.RemoteEndPoint + "的消息:" + Msg);

                    }
                }
                catch (Exception e)
                {

                    Console.WriteLine(e.Message + "\n远程服务器中断连接");
                    break;
                }

            }
        }
        private static void SendMsg()
        {
            while (true)
            {
                try
                {
                    string msg=Console.ReadLine();
                    if (msg == "q")
                    {
                        Console.WriteLine("关闭连接");
                        DisConnect();
                        
                        break;
                     }
                    
                    byte[] byte_msg = Encoding.UTF8.GetBytes(msg);
                    socket.Send(byte_msg);
                    Console.WriteLine("已发送");
                }
                catch(Exception e)
                {
                    Console.WriteLine("与服务器通信终端");
                    DisConnect();
                    return;
                }
            }
        }
      
        static void DisConnect()
        {
            socket.Disconnect(true);
            thread_client_receive.Abort();
        }
    }
}

完成咯