一个读取以太网设备的数据的socket

经常需要用socket读取设备的数据，包括现在很多串口转以太网的东西，需要发送数据事先定义好的字节数据，然后等待返回字节数据。发送和接收的数据往往是固定长度，并且短时间要收到回复的。于是就手动做这么一个简单的类。

使用方法很简单，new 一个socketclient同时定义好ip和端口，直接send(数据，超时时间，返回的数据长度)，然后返回RetData，这里表明了返回是否成功，接收到的长度和数据

 

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

namespace Common
{
    public class SocketClient
    {
        public SocketClient(string ip, int port)
        {
            Ip = ip;
            Port = port;
            //定义一个套字节监听  包含3个参数(IP4寻址协议,流式连接,TCP协议)
            socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            result = new RetData();
        }
        //创建 1个客户端套接字 和1个负责监听服务端请求的线程  
        Socket socketClient = null;
        Thread threadClient = null;
        public EventHandler EvenNewData;
        string Ip = "127.0.0.1";
        int Port = 8888;
        public bool Connected { get { return socketClient.Connected; } }
        byte[] DataBuf = new byte[1024 * 1024];
        //定义一个1M的内存缓冲区 用于临时性存储接收到的信息
        public byte[] Data { get { return DataBuf; } }
        //默认为0表示不检测接收数据长度，如果不为0表示数据接收超过这个长度才会触发接收完成事件
        int _rcvDataLength = 0;
        //最大长度1024*1024
        public int FixRcvLength { get { return _rcvDataLength; } set { if (value <= DataBuf.Length) _rcvDataLength = value; } }
        RetData result;
        public bool ConnectToServer()
        {
            //定义一个套字节监听  包含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, Port);
            //这里客户端套接字连接到网络节点(服务端)用的方法是Connect 而不是Bind
            if (!socketClient.Connected)
            {
                try
                {
                    socketClient.Connect(endpoint);
                    //创建一个线程 用于监听服务端发来的消息
                    threadClient = new Thread(RecMsg);
                    //将窗体线程设置为与后台同步
                    threadClient.IsBackground = true;
                    //启动线程
                    threadClient.Start();
                }
                catch (Exception ex)
                {
                    Log.WriteLogs(ex.Message.ToString());
                    return false;
                }
            }
            return socketClient.Connected;
        }
        public void DisconnectFromServer()
        {
            if (socketClient.Connected) socketClient.Disconnect(true);
        }
        /// <summary>
        /// 接收服务端发来信息的方法
        /// </summary>
        private void RecMsg()
        {
            while (true) //持续监听服务端发来的消息
            {
                //将客户端套接字接收到的数据存入内存缓冲区, 并获取其长度
                int length = socketClient.Receive(DataBuf);
                //将数据拷贝，并根据已经接收到的数据数量累加到数据缓存区，
                Buffer.BlockCopy(DataBuf, 0, DataBuf, result.revLength, length);
                //累加已经接收到的数据长度
                result.revLength += length;
                if (result.revLength >= FixRcvLength)
                {//如果累加的数据长度超过指定的长度
                    if (FixRcvLength == 0 || result.revLength == FixRcvLength)
                    {//如果没有指定数据长度，或者累加的数据长度==指定的长度则触发事件，并发送数据，否则丢弃数据
                        byte[] arrData = new byte[result.revLength];
                        Array.Copy(DataBuf, arrData, result.revLength);
                        result.Data = arrData;
                        result.Code = 0;
                        result.Message = "successful";
                        result.IsSuccessful = true;
                    }
                    result.revLength = 0;
                }
            }
        }
        /// <summary>
        /// 发送数据并等待返回数据
        /// </summary>
        /// <param name="sendMsg">发送的字符串数据</param>
        /// <param name="monitorTime">等待的超时毫秒，如果超过时间还没收到返回指定的数据长度，则返回读取错误</param>
        /// <param name="returnBytes">等待返回的数据长度，0表示不管多长都返回</param>
        /// <returns></returns>
        public RetData Send(string sendMsg, int monitorTime, int returnBytes = 0)
        {
            byte[] arrClientSendMsg = Encoding.UTF8.GetBytes(sendMsg);
            return Send(sendMsg, monitorTime, returnBytes);
        }
        /// <summary>
        /// 发送数据并等待返回数据
        /// </summary>
        /// <param name="sendMsg">发送的数据</param>
        /// <param name="monitorTime">等待的超时毫秒，如果超过时间还没收到返回指定的数据长度，则返回读取错误</param>
        /// <param name="returnBytes">等待返回的数据长度，0表示不管多长都返回</param>
        /// <returns></returns>
        public RetData Send(byte[] sendMsg, int monitorTime, int returnBytes = 0)
        {
            result = new RetData();
            MonitorTime = monitorTime;
            FixRcvLength = returnBytes;
            if (socketClient != null)
            {
                if (!Connected)
                {
                    ConnectToServer();
                    Thread.Sleep(500);
                }
                if (Connected)
                {
                    //调用客户端套接字发送字节数组
                    socketClient.Send(sendMsg);
                    //将发送的信息追加到聊天内容文本框中
                }
                else
                {
                    result.Message = "connect to server failure";
                }
                Monitor(MonitorTime);
            }
            else
            {
                result.Message = "socketClient is null";
            }
            return result;
        }
        /// <summary>
        /// 发送数据并等待返回数据
        /// </summary>
        /// <param name="sendMsg">发送的数据</param>
        /// <param name="monitorTime">等待的超时毫秒，如果超过时间还没收到返回指定的数据长度，则返回读取错误</param>
        /// <param name="returnBytes">等待返回的数据长度，0表示不管多长都返回</param>
        /// <returns></returns>
        public Task<RetData> SendAsync(byte[] sendMsg, int monitorTime, int returnBytes = 0)
        {
            return Task.Run(() =>
            {
                return Send(sendMsg, monitorTime, returnBytes) ;
            });
        }
        int MonitorTime = 0;
        private void Monitor(int monitortime)
        {
            int _time = monitortime;
            while (!result.IsSuccessful && _time > 0)
            {
                Thread.Sleep(10);
                _time -= 10;
            }
            result.Message = "time out";
        }
        ~SocketClient()
        {
            socketClient.Disconnect(false);
            socketClient.Dispose();
        }
    }
    [Serializable]
    public class RetData
    {
        public bool IsSuccessful { get; set; } = false;
        public byte[] Data { get; set; }
        public string Message { get; set; }
        public int Code { get; set; } = 0;
        public int revLength { get; set; } = 0;
    }
}