C#使用TCP进行聊天通信（详细解析）

故里2130

已于 2023-10-07 22:29:03 修改

阅读量1.3w

点赞数 12

分类专栏： C# 文章标签： tcp/ip 网络服务器

于 2022-06-28 16:09:36 首次发布

分享的越多，得到的越多。记录的越多，忘记的越少。----故里2130

本文链接：https://blog.csdn.net/u012563853/article/details/125367492

版权

C# 专栏收录该内容

27 篇文章 14 订阅

订阅专栏

TCP通信可以使用Socket和TcpListene进行通信，TcpListene是Socket的一个封装，可以更好的操作Socket，底层依然是socket。

进行通信分为2部分，一个是服务端，一个是客户端。

一，服务端

1.使用TcpListener实例化，得到服务器的ip和端口

myListener = new TcpListener(IPAddress.Parse(textBox1.Text), Convert.ToInt32(textBox2.Text));

2.启动TcpListener

myListener.Start();

3.创建一个线程

Thread myThread = new Thread(ListenClientConnect);

4.让这个线程，不停的监听客户端的请求

newClient = myListener.AcceptTcpClient();

5.从网络流中获得客户端的消息

receiveString = user.br.ReadString();

6.把流写入给user

user.bw.Write(message); user.bw.Flush();

7. 停止监听

myListener.Stop();

二，客户端

1.实例化

client = new TcpClient();

2.连接服务器

client.Connect(IPAddress.Parse(textBox3.Text), Convert.ToInt32(textBox2.Text));

3.获取网络流

NetworkStream networkStream = client.GetStream();

4.将网络流作为二进制读写对象

br = new BinaryReader(networkStream);bw = new BinaryWriter(networkStream);

5.读取服务器的流，接收消息

receiveString = br.ReadString();

6.向服务器写流，发送消息

bw.Write(message);

7.释放资源，关闭连接

br.Close();

bw.Close();

client.Close();

信息传递的流程：

客户端登录
服务器监听
客户端发送消息
服务器收到消息

服务器收到消息后，把消息发给客户端
服务器又监听了（消息空了）

客户端收到消息
客户端又监听了

拓展核心代码：

使用NetworkStream类，把流分别给BinaryReader读，BinaryWriter写。

必须按顺序写流

必须按顺序读流

服务器

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

namespace ConsoleApp2
{
    /// <summary>
    /// 服务端监听客户端信息，一旦有发送过来的信息，便立即处理
    /// </summary>
    class Program
    {
        //全局TcpClient
        static TcpClient client;
        //文件流建立到磁盘上的读写流
        static FileStream fs = new FileStream(@"D:\demo\6.jpg", FileMode.Create);
        //buffer
        static int bufferlength = 200;
        static byte[] buffer = new byte[bufferlength];
        //网络流
        static NetworkStream ns;
         static BinaryReader br;
       
        static void Main(string[] args)
        {
            ConnectAndListen();
        }

        static void ConnectAndListen()
        {
            //服务端监听任何IP 但是端口号是80的连接
            TcpListener listener = new TcpListener(IPAddress.Any, 8083);
            //监听对象开始监听
            listener.Start();
            while (true)
            {
                Console.WriteLine("等待连接");
                //线程会挂在这里，直到客户端发来连接请求
                client = listener.AcceptTcpClient();
                Console.WriteLine("已经连接");
                //得到从客户端传来的网络流
                ns = client.GetStream();

                br = new BinaryReader(ns);
                //如果网络流中有数据
                if (ns.DataAvailable)
                {
                    //同步读取网络流中的byte信息
                    //do
                    //{
                    //    ns.Read(buffer, 0, bufferlength);
                    //} while (ns.Length > 0);
                    string s = br.ReadString();
                    bool b = br.ReadBoolean();


                    // byte[] dataArray = br.ReadBytes(100000); //这里长度不对的话，会报错。


                    br.BaseStream.BeginRead(buffer, 0, bufferlength, ReadAsyncCallBack, null);

                    //byte[] dataArray = br.ReadBytes(br.BaseStream.ReadByte()); //这里长度不对的话，会报错。

                    //string sb = Encoding.Default.GetString(dataArray, 0, dataArray.Length);
                    //异步读取网络流中的byte信息
                    //ns.BeginRead(buffer, 0, bufferlength, ReadAsyncCallBack, null);
                }
            }
        }

        /// <summary>
        /// 异步读取
        /// </summary>
        /// <param name="result"></param>
        static void ReadAsyncCallBack(IAsyncResult result)
        {
            int readCount;
            //获得每次异步读取数量
            readCount = client.GetStream().EndRead(result);
            //如果全部读完退出，垃圾回收
            if (readCount < 1)
            {
                client.Close();
                ns.Dispose();
                fs.Dispose();
                return;
            }
            //将网络流中的图片数据片段顺序写入本地
            fs.Write(buffer, 0, 200);
            //再次异步读取
            //ns.BeginRead(buffer, 0, 200, ReadAsyncCallBack, null);

            br.BaseStream.BeginRead(buffer, 0, 200, ReadAsyncCallBack, null);
        }
    }
}

客户端：

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

namespace ConsoleApp1
{
    class Program
    {
        /// <summary>
        /// 客户端
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            SendImageToServer(@"D:\demo\1\1.jpg");
        }

        static void SendImageToServer(string imgURl)
        {
            if (!File.Exists(imgURl)) return;
            //创建一个文件流打开图片
            FileStream fs = File.Open(imgURl, FileMode.Open);
            //声明一个byte数组接受图片byte信息
            byte[] fileBytes = new byte[fs.Length];
            using (fs)
            {
                //将图片byte信息读入byte数组中
                fs.Read(fileBytes, 0, fileBytes.Length);
                fs.Close();
            }
            //找到服务器的IP地址
            IPAddress address = IPAddress.Parse("127.0.0.1");
            //创建TcpClient对象实现与服务器的连接
            TcpClient client = new TcpClient();
            //连接服务器
            client.Connect(address, 8083);
            using (client)
            {
                //连接完服务器后便在客户端和服务端之间产生一个流的通道
                NetworkStream ns = client.GetStream();
                 BinaryWriter bw;
                using (ns)
                {
                    bw = new BinaryWriter(ns);
                    //通过此通道将图片数据写入网络流，传向服务器端接收
                    bw.Write("123");
                    bw.Write(false);


                    //StringBuilder sb1 = new StringBuilder();
                    //sb1.Append("456");
                    //byte[] dataArray = Encoding.Default.GetBytes(sb1.ToString());
                    //bw.Write(dataArray,0, dataArray.Length);

                    bw.Write(fileBytes, 0, fileBytes.Length);
                    //ns.Write(fileBytes, 0, fileBytes.Length);
                    //ns.Write("123");
                }
            }
        }
    }
}

文字使用br.ReadString()传递。

图片使用数组字节传递

 byte[] data = ImageToByte(pictureBox1.Image);

                //对原始的数据数组加上协议的头部字节
                byte[] result = new byte[data.Length + 1];

                //设置当前的协议头部字节是1：代表字符串
                result[0] = 3;                                      //发送

                //把原始的数据放到最终的字节数组里去
                Buffer.BlockCopy(data, 0, result, 1, data.Length);

                ClientSocekt.Send(result, 0, result.Length, SocketFlags.None);

拓展

上面可能有些复杂，下面使用简易方式分别表示TcpListene和TCP

TcpListene进行通信

服务端

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

namespace tcplistener服务端
{
    class Program
    {
        static void Main(string[] args)
        {
            //1,TcpListener对socket进行了一层封装，这个类里面自己会去创建socket对象
            TcpListener listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 7788);

            //2,开始进行监听
            listener.Start();

            //3,等待客户端连接过来
            TcpClient client = listener.AcceptTcpClient();

            //4,取得客户端发送过来的数据
            NetworkStream stream = client.GetStream();//得到了一个网络流  从这个网络流可以取得客户端发送过来的数据

            byte[] data = new byte[1024];//创建一个数据的容器，用来承接数据,此处有大小限制

            Thread t1 = new Thread(()=>ReadMsg(stream, data));    //开启线程读取消息
            t1.Start();

            Thread t2 = new Thread(()=>SendMsg(stream));    //开始线程发送消息
            t2.Start();


            //stream.Close();
            //client.Close();
            //listener.Stop();//停止监听
            //Console.ReadKey();


        }

        private static void SendMsg(NetworkStream stream)
        {
            while (true)
            {
                string message = Console.ReadLine();
                byte[] data = Encoding.UTF8.GetBytes(message);
                stream.Write(data, 0, data.Length);
            }
        }

        private static void ReadMsg(NetworkStream stream, byte[] data)
        {
            while (true)
            {
                //0 表示从数组的哪个索引开始存放数据
                //1024表示最大读取的字节数
                int length =   stream.Read(data, 0, 1024);//读取数据
                string message = Encoding.UTF8.GetString(data, 0, length);
                Console.WriteLine("收到了消息:" + message);
            }
        }
    }
}

客户端

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

namespace tcplistener客户端
{
    class Program
    {
        static void Main(string[] args)
        {
            //当我们创建tcpclient对象的时候，就会跟server去建立连接
            TcpClient client = new TcpClient("127.0.0.1", 7788);

            NetworkStream stream = client.GetStream();//通过网络流进行数据的交换
            //ReadLine用来读取数据，write用来写入数据其实就是发送数据
            //利用一个死循环，重复向服务器端发送数据
            Thread thread = new Thread(()=>SendMsg(stream));    //开启发送消息
            thread.Start( );

            byte[] data = new byte[1024];//创建一个数据的容器，用来承接数据
            Thread t1 = new Thread(() => ReadMsg(stream, data));    //开启读取消息
            t1.Start();


            //stream.Close();
            //client.Close();
            //Console.ReadKey();

        }

        private static void ReadMsg(NetworkStream stream, byte[] data)
        {
            while (true)
            {
                //0 表示从数组的哪个索引开始存放数据
                //1024表示最大读取的字节数
                int length = stream.Read(data, 0, 1024);//读取数据
                string message = Encoding.UTF8.GetString(data, 0, length);
                Console.WriteLine("收到了消息:" + message);
            }
        }

        private static void SendMsg(NetworkStream stream)
        {
            while (true)
            {
                string message = Console.ReadLine();
                byte[] data = Encoding.UTF8.GetBytes(message);
                stream.Write(data, 0, data.Length);
            }
        }
    }
}

效果

TCP进行通信

服务端

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

namespace ConsoleApp4
{
    class Program
    {
        static void Main(string[] args)
        {
            //1、创建socket
            Socket tcpServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //2、绑定ip跟端口号 127.0.0.1
            IPAddress ipaddress = IPAddress.Parse("127.0.0.1");
            //ipendpoint是对ip+端口做了一层封装的类
            EndPoint point = new IPEndPoint(ipaddress, 8090);
            //3、向操作系统申请一个可用的ip跟端口号 用来做通信
            tcpServer.Bind(point);
            //4、开始监听 （等待客户端连接）
            tcpServer.Listen(100);//参数是最大连接数
            Console.WriteLine("开始监听");

            //暂停当前线程，直到有一个客户端连接过来，之后进行下面的代码
            Socket clientSocket = tcpServer.Accept();
            //Console.WriteLine("一个客户端连接过来了");
            //使用返回的socket跟客户端做通信
            //string message = "hello 欢迎你";
            //byte[] data = Encoding.UTF8.GetBytes(message);//对字符串做编码，得到一个字符串的字节数组
            //clientSocket.Send(data);
            //Console.WriteLine("向客户端发送了一跳数据");

            byte[] data2 = new byte[1024];//创建一个字节数组用来当做容器，去承接客户端发送过来的数据

            Thread t1 = new Thread(() => ReadMsg(clientSocket, data2));    //开启线程读取消息
            t1.Start();

            Thread t2 = new Thread(() => SendMsg(clientSocket ));    //开启线程读取消息
            t2.Start();

            //int length = clientSocket.Receive(data2);
            //string message2 = Encoding.UTF8.GetString(data2, 0, length);//把字节数据转化成 一个字符串
            //Console.WriteLine("接收到了一个从客户端发送过来的消息:" + message2);

            //Console.ReadKey();


        }

        private static void SendMsg(Socket clientSocket )
        {
            while (true)
            {
                string message = Console.ReadLine();//读取用户的输入 把输入发送到服务器端
                byte[] data = Encoding.UTF8.GetBytes(message);//对字符串做编码，得到一个字符串的字节数组
                clientSocket.Send(data);
                //Console.WriteLine("向客户端发送了一跳数据");
            }
        }

        private static void ReadMsg(Socket clientSocket, byte[] data2)
        {
            while (true)
            {
                int length = clientSocket.Receive(data2);
                string message2 = Encoding.UTF8.GetString(data2, 0, length);//把字节数据转化成 一个字符串
                Console.WriteLine("收到了消息:" + message2);
            }
        }
    }
}

客户端

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

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //1,创建socket
            Socket tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            //2,发起建立连接的请求
            IPAddress ipaddress = IPAddress.Parse("127.0.0.1");//可以把一个字符串的ip地址转化成一个ipaddress的对象
            EndPoint point = new IPEndPoint(ipaddress, 8090);
            tcpClient.Connect(point);//通过ip：端口号 定位一个要连接到的服务器端

            byte[] data = new byte[1024];
            //int length = tcpClient.Receive(data);//这里传递一个byte数组，实际上这个data数组用来接收数据
            length返回值表示接收了多少字节的数据
            //string message = Encoding.UTF8.GetString(data, 0, length);//只把接收到的数据做一个转化
            //Console.WriteLine(message);

            Thread thread = new Thread(() => SendMsg(tcpClient));    //开启发送消息
            thread.Start();

            Thread t1 = new Thread(() => ReadMsg(tcpClient, data));    //开启线程读取消息
            t1.Start();


            //Console.ReadKey();

        }

        private static void ReadMsg(Socket tcpClient, byte[] data2)
        {
            while (true)
            {
                int length = tcpClient.Receive(data2);
                string message2 = Encoding.UTF8.GetString(data2, 0, length);//把字节数据转化成 一个字符串
                Console.WriteLine("收到了消息:"+message2);
            }
        }

        private static void SendMsg(Socket tcpClient)
        {
            while (true)
            {
                //向服务器端发送消息
                string message2 = Console.ReadLine();//读取用户的输入 把输入发送到服务器端
                tcpClient.Send(Encoding.UTF8.GetBytes(message2));//把字符串转化成字节数组，然后发送到服务器端
            }
        }
    }
}

效果