C#使用TcpListener进行聊天通信

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

TcpListener是对socket的封装，更容易进行控制，底层依然是socket。

一，服务端

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);