TCPIP通信

最近在开发TCPIP通信，封装了3个类，望各位大神指点指点。

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

namespace HY_RFID
{
    public class MyTCPServer
    {
        public bool isExit = false;
        private TcpListener listener;
        public TcpClient readClient;
        List<ReadWriteObject> rws = new List<ReadWriteObject>();
        public List<TCPIP> ips = new List<TCPIP>();

        #region 创建事件
        //声明事件参数
        public class TcpClientArgs : EventArgs
        {
            public readonly TcpClient client;
            public TcpClientArgs(TcpClient client)
            {
                this.client = client;
            }
        }
        public class BackMsgArgs : EventArgs
        {
            public readonly string backMsg;
            public BackMsgArgs(string backMsg)
            {
                this.backMsg = backMsg;
            }
        }
        public class BackByteArgs : EventArgs
        {
            public readonly byte[] backByte;
            public BackByteArgs(byte[] backByte)
            {
                this.backByte = backByte;
            }
        }
        public delegate void WaitConnectEventHandler(object sender,EventArgs e);
        public event WaitConnectEventHandler OnWaitConnect;
        protected virtual void WaitConnect()
        {
            if (OnWaitConnect != null)// 如果有对象注册
            {
                OnWaitConnect(this, null);// 调用所有注册对象的方法
            }
        }
        //声明委托
        public delegate void SuccessConnectEventHandler(object sender, TcpClientArgs e);
        //声明事件
        public event SuccessConnectEventHandler OnSuccessConnect;
        //触发方法
        protected virtual void SuccessConnect(TcpClientArgs e)
        {
            if (OnSuccessConnect != null)// 如果有对象注册
            {
                OnSuccessConnect(this, e);// 调用所有注册对象的方法
            }
        }
        public delegate void ReadCallBackMsgEventHandler(object sender, BackByteArgs e);
        public event ReadCallBackMsgEventHandler OnReadCallBack;
        protected virtual void ReadCallBackMsg(BackByteArgs e)
        {
            if (OnReadCallBack != null)// 如果有对象注册
            {
                OnReadCallBack(this, e);// 调用所有注册对象的方法
            }
        }
        public delegate void ReadErrorCallBackMsgEventHandler(object sender, BackMsgArgs e);
        public event ReadErrorCallBackMsgEventHandler OnReadErrorCallBack;
        protected virtual void ReadErrorCallBackMsg(BackMsgArgs e)
        {
            if (OnReadErrorCallBack != null)// 如果有对象注册
            {
                OnReadErrorCallBack(this, e);// 调用所有注册对象的方法
            }
        }
        #endregion

        //用于线程同步，初始状态设为非终止状态，使用手动重置方式
        private EventWaitHandle allDone = new EventWaitHandle(false, EventResetMode.ManualReset);
        //服务端监听方法
        public void ServerListen(int port)
        {
            //由于服务器要为多个客户服务，所以需要创建一个线程监听客户端连接请求
            isExit = false;
            if (!PortInUse(port))
            {
                Thread myThread = new Thread(new ParameterizedThreadStart(AcceptConnect));
                myThread.Start(port);
            }
            else
            {
                throw new Exception("当前端口已被占用！");
            }
        }
        /// <summary>
        /// 检测但钱端口是否被占用
        /// </summary>
        /// <param name="port"></param>
        /// <returns></returns>
        private bool PortInUse(int port)
        {
            bool inUse = false;
            //获取所有的监听连接
            IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();
            IPEndPoint[] ipEndPoints = ipProperties.GetActiveTcpListeners();
            foreach (IPEndPoint endPoint in ipEndPoints)
            {
                if (endPoint.Port == port)
                {
                    inUse = true;
                    break;
                }
            }
            return inUse;
        }
        //与客户机取得连接
        private void AcceptConnect(object o)
        {
            try
            {
                if (o == null) return;
                IPAddress ip4 = GetLocalIpv4() as IPAddress; 
                listener = new TcpListener(ip4, Convert.ToInt32(o));
                listener.Start();
                //引用在异步操作完成时调用的回调方法
                AsyncCallback callback = new AsyncCallback(AcceptTcpClientCallback);
                while (!isExit)
                {

                    //将事件的状态设为非终止
                    allDone.Reset();
                    //触发等待事件
                    WaitConnect();
                    //开始一个异步操作接受传入的连接尝试
                    listener.BeginAcceptTcpClient(callback, listener);
                    //阻塞当前线程，直到收到客户连接信号
                    allDone.WaitOne();
                    Thread.Sleep(100);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        //获取本机IP
        public object GetLocalIpv4()
        {
            //获取本机所有IP地址 
            try
            {
                IPAddress[] localips = Dns.GetHostAddresses(Dns.GetHostName());
                foreach (IPAddress ip in localips)
                {
                    //找到本地所有IP地址符合IPV4协议的IP地址
                    if (ip.AddressFamily == AddressFamily.InterNetwork)
                    {
                        return ip;
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return null;
        }
        // 连接客户端的回调函数
        //ar是IAsyncResult类型的接口，表示异步操作的状态是由listener.BeginAcceptTcpClient(callback, listener)传递过来的
        private void AcceptTcpClientCallback(IAsyncResult ar)
        {
            lock (this)
            {
                try
                {
                    if (isExit) return;
                    //将事件状态设为终止状态，允许一个或多个等待线程继续
                    allDone.Set();
                    TcpListener myListener = (TcpListener)ar.AsyncState;
                    //异步接收传入的连接，并创建新的TcpClient对象处理远程主机通信
                    TcpClient client = myListener.EndAcceptTcpClient(ar);
                    //已接受客户连接
                    TcpClientArgs e = new TcpClientArgs(client);
                    ReadWriteObject readWriteObject = new ReadWriteObject(client);
                    rws.Add(readWriteObject);
                    string[] strs=client.Client.RemoteEndPoint.ToString().Split(':');
                    ips.RemoveAll(c => c.TargetIP == strs[0]);
                    ips.Add(new TCPIP(strs[0], strs[1], DateTime.Now));
                    //触发客户端连接成功事件
                    SuccessConnect(e);
                    readWriteObject.netStream.BeginRead(readWriteObject.readBytes, 0, readWriteObject.readBytes.Length, ReadCallback, readWriteObject);
                }
                catch (Exception ex)
                {
                    throw ex;
                } 
            }
        }
        private void ReadCallback(IAsyncResult ar)
        {
            try
            {
                ReadWriteObject readWriteObject = (ReadWriteObject)ar.AsyncState;
                readClient=readWriteObject.client;
                if (readClient.Client.Poll(10, SelectMode.SelectRead) && (readClient.Client.Available == 0) | readClient.Client.Connected)
                {
                    throw new Exception(readWriteObject.client.Client.RemoteEndPoint + "【断开】");
                }
                int length = readWriteObject.netStream.EndRead(ar);
                if (length == 0) return;
                List<byte> _byteData = new List<byte>();
                for (int i = 0; i < length; i++)
                {
                    _byteData.Add(readWriteObject.readBytes[i]);
                }
                ReadCallBackMsg(new BackByteArgs(_byteData.ToArray()));
                if (isExit == false)
                {
                    readWriteObject.InitReadArray();
                    readWriteObject.netStream.BeginRead(readWriteObject.readBytes, 0, readWriteObject.readBytes.Length, ReadCallback, readWriteObject);
                }
            }
            catch (Exception ex)
            {
                ReadErrorCallBackMsg(new BackMsgArgs(ex.Message));
            }
        }
        public void SendString(string remoteEndPoint, string str)
        {
            try
            {
                ReadWriteObject readWriteObject = rws.Where(c => c.client.Client.RemoteEndPoint.ToString() == remoteEndPoint).FirstOrDefault();
                if (readWriteObject.client.Client.Poll(10, SelectMode.SelectRead) && (readWriteObject.client.Client.Available == 0) || !readWriteObject.client.Client.Connected)
                {
                    throw new Exception(remoteEndPoint + "【断开】");
                }
                if (readWriteObject != null)
                {
                    readWriteObject.write = MyHelper.HexToByte(str);
                    readWriteObject.netStream.BeginWrite(readWriteObject.write, 0, readWriteObject.write.Length, new AsyncCallback(SendCallBack), readWriteObject);
                    readWriteObject.netStream.Flush();
                    
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        private void SendCallBack(IAsyncResult ar)
        {
            ReadWriteObject readWriteObject = (ReadWriteObject)ar.AsyncState;
            try
            {
                readWriteObject.netStream.EndWrite(ar);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 停止服务
        /// </summary>
        public void StopServer()
        {
            isExit = true;
            allDone.Set();
            if (listener != null)
                listener.Stop();
        }
    }
}

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

namespace HY_RFID
{
    public class MyTcpClient
    {
        #region 创建事件
        public class RecMsgArgs : EventArgs
        {
            public readonly string recMsg;
            public RecMsgArgs(string recMsg)
            {
                this.recMsg = recMsg;
            }
        }
        public class RecErrArgs : EventArgs
        {
            public readonly string recErr;
            public RecErrArgs(string recErr)
            {
                this.recErr = recErr;
            }
        }
        public delegate void ReceivedMsgEventHandler(object sender, RecMsgArgs e);
        public event ReceivedMsgEventHandler OnReceived;
        protected virtual void ReceivedMsg(RecMsgArgs e)
        {
            if (OnReceived != null)// 如果有对象注册
            {
                OnReceived(this, e);// 调用所有注册对象的方法
            }
        }
        public delegate void ReceivedErrorEventHandler(object sender, RecErrArgs e);
        public event ReceivedErrorEventHandler OnReceivedErr;
        protected virtual void ReceivedError(RecErrArgs e)
        {
            if (OnReceivedErr != null)// 如果有对象注册
            {
                OnReceivedErr(this, e);// 调用所有注册对象的方法
            }
        }
        #endregion
        private bool isExit;
        private Socket socketClient = null;
        //连接服务端方法
        public void ClientConnect(string IP, string Port)
        {
            isExit = false;
            //定义一个套字节监听  包含3个参数(IP4寻址协议,流式连接,TCP协议)
            socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //需要获取文本框中的IP地址
            IPAddress ipaddress = IPAddress.Parse(IP);
            //将获取的ip地址和端口号绑定到网络节点endpoint上
            IPEndPoint endpoint = new IPEndPoint(ipaddress, int.Parse(Port));
            //这里客户端套接字连接到网络节点(服务端)用的方法是Connect 而不是Bind
            socketClient.Connect(endpoint);
            //创建一个线程 用于监听服务端发来的消息
            Thread threadClient = new Thread(RecMsg);
            //将窗体线程设置为与后台同步
            threadClient.IsBackground = true;
            //启动线程
            threadClient.Start();
        }
        // 发送节目全屏byte串信息到服务端的方法
        public void ClientSendMsg(string msg)
        {
            try
            {
                if (socketClient.Poll(10, SelectMode.SelectRead) && (socketClient.Available == 0) || !socketClient.Connected)
                {
                    throw new Exception(socketClient.RemoteEndPoint + "已断开！");
                }
                Byte[] data = System.Text.Encoding.Default.GetBytes(msg);
                socketClient.Send(data, data.Length, SocketFlags.None);//发送信息
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }
        //接收服务端发来信息的方法
        public void RecMsg()
        {

            while (!isExit) //持续监听服务端发来的消息
            {
                try
                {
                    bool o = socketClient.Poll(10, SelectMode.SelectRead);
                    if (o) break;
                    //定义一个1024*200的内存缓冲区 用于临时性存储接收到的信息
                    byte[] arrRecMsg = new byte[1024 * 200];
                    //将客户端套接字接收到的数据存入内存缓冲区, 并获取其长度
                    int length = socketClient.Receive(arrRecMsg);
                    if (length == 0) return;
                    string recMsg = Encoding.Default.GetString(arrRecMsg, 0, length);
                    ReceivedMsg(new RecMsgArgs(recMsg));
                }
                catch (SocketException ex)
                {
                    ReceivedError(new RecErrArgs(ex.Message));
                }
            }
        }
        /// <summary>
        /// 断开链接
        /// </summary>
        public void StopConnect()
        {
            if (socketClient != null)
            {
                socketClient.Close();
                isExit = true;
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;

namespace HY_RFID
{
    public class ReadWriteObject
    {
        public TcpClient client;
        public NetworkStream netStream;
        public byte[] readBytes;
        public byte[] write;
        public ReadWriteObject(TcpClient client)
        {
            this.client = client;
            netStream = client.GetStream();
            readBytes = new byte[client.ReceiveBufferSize];
            write=new byte[client.SendBufferSize];
        }
        public void InitReadArray()
        {
            readBytes = new byte[client.ReceiveBufferSize];
        }
        public void InitWriteArray()
        { 
            write=new byte[client.SendBufferSize];
        }
    }
}