C# 通讯设备基类（串口和网络通讯）

最新推荐文章于 2024-05-24 09:39:05 发布
最新推荐文章于 2024-05-24 09:39:05 发布
阅读量229 收藏
点赞数
分类专栏： c# 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_42417134/article/details/134990908
版权
本文介绍了两个通信接口：IDeviceConnect用于连接设备，支持数据监控和状态管理。SocketConnectionDevice和SerialPortConnectionDevice分别基于Socket和串口进行设备连接，提供发送/接收数据的方法和异常处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

using Prism.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CommonLib.Communication
{
    /// <summary>
    /// 可连接设备接口
    /// </summary>
    public interface IDeviceConnect : IDisposable
    {
        /// <summary>
        /// 数据监控委托。参数1为数据传输方向"Send"/"Receive",参数2为数据字节数组。
        /// </summary>
        Action<string, byte[]> DataMonitor { get; set; }

        /// <summary>
        /// 连接状态，"Connected"-已连接、"UnConnected"-未连接 等等其它状态。
        /// </summary>
        string ConnectState { get; set; }

        /// <summary>
        /// 设置通参数
        /// </summary>
        /// <param name="parameters">通讯参数接口对象(具体参数详见实现类)</param>
        void SetCommunicationParameters(IParameters parameters);

        /// <summary>
        /// 连接设备
        /// </summary>
        /// <returns></returns>
        bool Connect();

        /// <summary>
        /// 断开设备
        /// </summary>
        void Disconnect();

        /// <summary>
        /// 发送并读取数据(读取指定长度)，可单发，也可单读。
        /// </summary>
        /// <param name="sendBytes">发送字节集合，如果为null或者长度为零表示不发送只读取。</param>
        /// <param name="readDelay">回读数据前延时时间，如果小于等于零表示不延时。</param>
        /// <param name="readLength">读取长度，如果小于等于令表示不读取。</param>
        /// <param name="readTimeout">读取超时时间，单位毫秒。</param>
        /// <returns></returns>
        List<byte> SRBytes(List<byte> sendBytes, int readDelay, int readLength, int readTimeout);

        /// <summary>
        /// 发送并读取数据(读取串口缓冲区所有数据)，必需有读回送。
        /// </summary>
        /// <param name="sendBytes">发送字节集合，如果为null或者长度为零表示不发送只读取。</param>
        /// <param name="readDelay">回读数据前延时时间，如果小于等于零表示不延时。</param>
        /// <param name="readTimeout">读取超时时间，单位毫秒。</param>
        /// <returns></returns>
        List<byte> SRBytes(List<byte> sendBytes, int readDelay, int readTimeout);

        /// <summary>
        /// 终止读写数据
        /// </summary>
        void AbortSRBytes();

    }
}

SocketCommunication

using CommonLib.Communication.SerialPortCommunication;
using CommonLib.Timer;
using Prism.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace CommonLib.Communication.SocketCommunication
{
    public abstract class SocketConnectionDeveice : IDeviceConnect, IDisposable
    {
        public virtual Action<string, byte[]> DataMonitor { get; set; }

        public virtual string ConnectState { get; set; } = "UnConnected";

        protected virtual SocketConnectionParameters ConnectionParameters { get; set; }

        /// <summary>
        /// 线程取消信号源对象
        /// </summary>
        protected virtual CancellationTokenSource CTS { get; set; }

        /// <summary>
        /// 初始线程取消信息源对象
        /// </summary>
        protected virtual void InitCTS()
        {
            if (CTS == null || CTS.IsCancellationRequested)
            {
                CTS = new CancellationTokenSource();
                //CTS.Token.Register(CancelCallBack);//线程取消回调函数
            }
        }

        /// <summary>
        /// Socket对象
        /// </summary>
        protected virtual Socket Socket { get; set; }

        /// <summary>
        /// 打开Socket连接
        /// </summary>
        /// <returns></returns>
        protected virtual bool OpenSocket()
        {
            if (this.Socket == null) return false;
            if (!this.Socket.Connected)
            {
                var result = this.Socket.BeginConnect(this.ConnectionParameters.IP, this.ConnectionParameters.Port, null, null);
                result.AsyncWaitHandle.WaitOne(2000);
                if (!result.IsCompleted)
                {
                    this.Socket.Close();
                }
            }
            return this.Socket.Connected;
        }

        public virtual void AbortSRBytes()
        {
            CTS.Cancel();
        }

        public virtual bool Connect()
        {
            InitSocket(ConnectionParameters.IP, ConnectionParameters.Port);
            return OpenSocket();
        }

        public virtual void Disconnect()
        {
            Socket?.Close();
            Socket = null;
        }

        public virtual void Dispose()
        {
            Disconnect();
        }

        public virtual void SetCommunicationParameters(IParameters parameters)
        {
            this.ConnectionParameters = parameters as SocketConnectionParameters;
            InitSocket(ConnectionParameters.IP, ConnectionParameters.Port);
        }

        public virtual List<byte> SRBytes(List<byte> sendBytes, int readDelay, int readLength, int readTimeout)
        {
            InitCTS();
            Exception err = null;
            var ls = Task.Run(async () =>
            {
                try
                {
                    if (!OpenSocket()) throw new Exception("Socket connect failed!");
                    if (sendBytes != null && sendBytes.Count > 0)
                    {
                        var data = sendBytes.ToArray();
                        this.Socket.Send(data);
                        DataMonitor?.Invoke("Send", data);//监听发送数据
                    }
                    if (readLength <= 0) return null;// 判断是否需要回读
                    if (readDelay > 0)
                    {
                        await Task.Delay(readDelay, CTS.Token);
                    }
                    this.Socket.ReceiveTimeout = readTimeout;
                    byte[] buff = new byte[1024];
                    int iRet = this.Socket.Receive(buff);
                    if (iRet == readLength)
                    {
                        var retData = buff.Take(iRet).ToArray();
                        DataMonitor?.Invoke("Receive", retData);//监听回读数据
                        return retData.ToList();
                    }
                    else
                    {
                        throw new Exception("Reading socket data timeout!");
                    }
                }
                catch (Exception ex)
                {
                    err = ex;
                    return null;
                }
            }, CTS.Token).Result;
            if (err != null) throw err;
            return ls;
        }

        public virtual List<byte> SRBytes(List<byte> sendBytes, int readDelay, int readTimeout)
        {
            InitCTS();
            Exception err = null;
            var ls = Task.Run(async () =>
            {
                try
                {
                    if (!OpenSocket()) throw new Exception("Socket connect failed!");
                    if (sendBytes != null && sendBytes.Count > 0)
                    {
                        var data = sendBytes.ToArray();
                        this.Socket.Send(data);
                        DataMonitor?.Invoke("Send", data);//监听发送数据
                    }
                    if (readDelay > 0)
                    {
                        await Task.Delay(readDelay, CTS.Token);
                    }
                    this.Socket.ReceiveTimeout = readTimeout;
                    byte[] buff = new byte[1024];
                    int iRet = this.Socket.Receive(buff);
                    if (iRet > 0)
                    {
                        var retData = buff.Take(iRet).ToArray();
                        DataMonitor?.Invoke("Receive", retData);//监听回读数据
                        return retData.ToList();
                    }
                    else
                    {
                        throw new Exception("Reading socket data timeout!");
                    }
                }
                catch (Exception ex)
                {
                    err = ex;
                    return null;
                }
            }, CTS.Token).Result;
            if (err != null) throw err;
            return ls;
        }

        /// <summary>
        /// 初始化Socket对象
        /// </summary>
        /// <param name="ip">ip地址</param>
        /// <param name="port">端口</param>
        /// <param name="pt">socket支持的协议</param>
        protected virtual void InitSocket(string ip, int port, ProtocolType pt = ProtocolType.Tcp)
        {
            if (Socket != null && Socket.Connected) Socket.Close();
            Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, pt);
        }
    }
}



using Prism.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;

namespace CommonLib.Communication.SocketCommunication
{
    public class SocketConnectionParameters : ParametersBase, IParameters
    {
        public string IP => GetPropertyValue<string>();

        public int Port => GetPropertyValue<int>();

        protected T GetPropertyValue<T>([CallerMemberName] string properityName = "")
        {
            return GetValue<T>(properityName);
        }
    }
}

SerialPortCommunication

using CommonLib.LogUtils.Log4net;
using CommonLib.Timer;
using Prism.Common;
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace CommonLib.Communication.SerialPortCommunication
{
    /// <summary>
    /// 串口通讯设备基类
    /// </summary>
    public abstract class SerialPortConnectionDeveice : Log4Base, IDeviceConnect, IDisposable
    {
        public virtual Action<string, byte[]> DataMonitor { get; set; }

        public virtual string ConnectState { get; set; } = "UnConnected";

        /// <summary>
        /// 线程锁对象
        /// </summary>
        protected readonly object lockObj = new object();

        /// <summary>
        /// 线程取消信号源对象
        /// </summary>
        protected virtual CancellationTokenSource CTS { get; set; }

        /// <summary>
        /// 初始线程取消信息源对象
        /// </summary>
        protected virtual void InitCTS()
        {
            if (CTS == null || CTS.IsCancellationRequested)
            {
                CTS = new CancellationTokenSource();
                //CTS.Token.Register(CancelCallBack);//线程取消回调函数
            }
        }

        /// <summary>
        /// 串口对象
        /// </summary>
        protected virtual SerialPort ComPort { get; set; }

        /// <summary>
        /// 初始化串口
        /// </summary>
        /// <param name="portName">串口名称</param>
        /// <param name="baudRate">波特率</param>
        protected virtual void InitComPort(string portName, int baudRate)
        {
            if (ComPort != null)
            {
                if (ComPort.IsOpen) ComPort.Close();
                ComPort.PortName = portName;
                ComPort.BaudRate = baudRate;
            }
            else
            {
                ComPort = new SerialPort(portName, baudRate);
            }
        }

        protected virtual bool OpenComPort()
        {
            if (ComPort == null) return false;
            if (!ComPort.IsOpen) ComPort.Open();
            return ComPort.IsOpen;
        }

        protected virtual void ClosePort()
        {
            if (ComPort != null && ComPort.IsOpen) ComPort.Close();
        }

        public virtual void SetCommunicationParameters(IParameters parameters)
        {
            var objConnectionParameters = parameters as SerialPortConnectionParameters;
            if (objConnectionParameters.ContainsKey("SerialPort"))
            {
                this.ComPort = objConnectionParameters.GetValue<SerialPort>("SerialPort");
            }
            else
            {
                InitComPort(objConnectionParameters.PortName, objConnectionParameters.BaudRate);
            }
        }

        public virtual bool Connect()
        {
            return OpenComPort();
        }

        public virtual void Disconnect()
        {
            ClosePort();
        }

        public virtual List<byte> SRBytes(List<byte> sendBytes, int readDelay, int readLength, int readTimeout)
        {
            InitCTS();
            Exception err = null;
            var ls = Task.Run(() =>
            {
                try
                {
                    lock (lockObj)
                    {
                        if (!OpenComPort()) throw new Exception("Serial port opening failed!");
                        if (sendBytes != null && sendBytes.Count > 0)
                        {
                            var data = sendBytes.ToArray();
                            this.ComPort.Write(data, 0, data.Length);
                            DataMonitor?.Invoke("Send", data);//监听发送数据
                        }
                        if (readLength <= 0) return null;// 判断是否需要回读
                        if (readDelay > 0)
                        {
                            Task.Delay(readDelay, CTS.Token).Wait();
                        }
                        MyTimer timer = new MyTimer() { AbortFun = () => CTS.IsCancellationRequested };
                        var bRet = timer.WaitingBusinessTrue(() => this.ComPort.BytesToRead >= readLength, readTimeout);
                        if (bRet)
                        {
                            byte[] buff = new byte[readLength];
                            int iRet = this.ComPort.Read(buff, 0, buff.Length);
                            var retData = buff.Take(iRet).ToArray();
                            DataMonitor?.Invoke("Receive", retData);//监听回读数据
                            return retData.ToList();
                        }
                        else
                        {
                            throw new Exception("Reading serial port data timeout!");
                        }
                    }
                }
                catch (Exception ex)
                {
                    err = ex;
                    return null;
                }
            }, CTS.Token).Result;
            if (err != null) throw err;
            return ls;
        }

        public virtual List<byte> SRBytes(List<byte> sendBytes, int readDelay, int readTimeout)
        {
            InitCTS();
            Exception err = null;
            var ls = Task.Run(() =>
            {
                try
                {
                    lock (lockObj)
                    {
                        if (!OpenComPort()) throw new Exception("Serial port opening failed!");
                        if (sendBytes != null && sendBytes.Count > 0)
                        {
                            var data = sendBytes.ToArray();
                            this.ComPort.Write(data, 0, data.Length);
                            DataMonitor?.Invoke("Send", data);//监听发送数据
                        }
                        if (readDelay > 0)
                        {
                            Task.Delay(readDelay, CTS.Token).Wait();
                        }
                        MyTimer timer = new MyTimer() { AbortFun = () => CTS.IsCancellationRequested };
                        var bRet = timer.WaitingBusinessTrue(() => this.ComPort.BytesToRead > 0, readTimeout);
                        if (bRet)
                        {
                            int buffBytesCount = this.ComPort.BytesToRead;
                            byte[] buff = new byte[buffBytesCount];
                            int iRet = this.ComPort.Read(buff, 0, buff.Length);
                            var retData = buff.Take(iRet).ToArray();
                            DataMonitor?.Invoke("Receive", retData);//监听回读数据
                            return retData.ToList();
                        }
                        else
                        {
                            throw new Exception("Reading serial port data timeout!");
                        }
                    }
                }
                catch (Exception ex)
                {
                    err = ex;
                    return null;
                }
            }, CTS.Token).Result;
            if (err != null) throw err;
            return ls;
        }

        public virtual void AbortSRBytes()
        {
            CTS.Cancel();
        }

        public virtual void Dispose()
        {
            Disconnect();
        }
    }
}


using Prism.Common;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;

namespace CommonLib.Communication.SerialPortCommunication
{
    /// <summary>
    /// 串口通讯参数访问实现类
    /// </summary>
    public class SerialPortConnectionParameters : ParametersBase, IParameters
    {
        /// <summary>
        /// 串口名称
        /// </summary>
        public string PortName => GetPropertyValue<string>();

        public int BaudRate => GetPropertyValue<int>();

        protected T GetPropertyValue<T>([CallerMemberName] string properityName = "")
        {
            return GetValue<T>(properityName);
        }


    }
}
c#串口通讯基类
qq_20410891的博客
06-04 516
public class SerialPortUtil    {       /// &lt;summary&gt;        /// 接收事件是否有效 false表示有效        /// &lt;/summary&gt;        public bool ReceiveEventFlag = false;        /// &lt;summary&gt;        /// ...
C#实现串口通讯功能
最新发布
weixin_43626218的博客
04-23 1138
自动获取本地串口。根据传入串口基本属性参数打开串口。串口数据的发送接收功能（ASCII和HEX格式）。ASCII和HEX相互转换。[Category[ Category("UserProperty") ] [ Description("轮廓半径") ] public int Radius {set {if(radius!= value) {
使用C#进行点对点通讯和文件传输（通讯基类部分）
长弓三石
08-03 2189
最近一个项目要用到点对点文件传输，俺就到处找资料写程序，最后终于完成了，为了让别人少走些弯路，俺决定将俺程序中最重要的部分贡献出来，希望对大家有所帮助。 俺的程序分三部分，包括发送部分、接受部分和一个两者共享的通讯基类，这个基类才是俺心血的结晶：） 一、通讯基类using System;using System.Net.Sockets;using System.Net ;using System.
C#串口通讯 基类
qq_39467811的博客
11-16 271
#region 指令基类 //协议：帧头 数据长度 指令编号 指令参数 校验和 帧尾 // 0x55 XXX XXX XXX XX 0xAA //数据个数：指令编号+ 指令参数 //校验和： （指令编号+ 指令参数）累加和，取低八位 public abstract class CEntityBase { [Category("通信协议")] [..
[导入][转]用C#实现基于TCP协议的网络通讯
weixin_30746117的博客
08-13 132
　　TCP协议是一个基本的网络协议，基本上所有的网络服务都是基于TCP协议的，如HTTP,FTP等等，所以要了解网络编程就必须了解基于TCP协议的编程。然而TCP协议是一个庞杂的体系，要彻底的弄清楚它的实现不是一天两天的功夫，所幸的是在.net framework环境下，我们不必要去追究TCP协议底层的实现，一样可以很方便的编写出基于TCP协议进行网络通讯的程序。 　　要进行基于TCP协议...
用于与串口设备通讯的.NET基类CommBase.docx
11-14
【标题】：“用于与串口设备通讯的.NET基类CommBase.docx” 【描述】：本文档介绍如何在.NET环境中创建一个基类库，用于与RS232串口通信，利用C#语言和Platform Invocation Services（P/Invoke）直接调用Win32 API...
【C#上位机应用开发实战】—— 通信模块的基础与实践
IT一技之长，认真写博文，让知识沉淀下来
05-24 1080
通过本文的介绍，相信大家对C#开发上位机应用的通信模块有了更深入的了解。在实际开发中，我们还需要根据具体需求进行灵活调整和优化。希望本文的内容能为大家提供一些有益的参考和启示！
PLC通讯实现-C#实现西门子PLC串口通讯W95_S7（四）
分享技术，传播知识!
11-08 3895
PLC通讯实现-C#实现西门子PLC串口通讯W95_S7（四）背景抽象设计西门子串口通讯实现W95_S7 背景 本人近十年的工作都与工业软件相关、其中工控系统开发过程中有一个必要环节就是跟各大厂商的PLC进行通讯，而对于从互联网行业跨入工业互联网行业的从业人员来说要实现各型号PLC通讯还是需要一个过程的，本人在此对主流型号PLC通讯实现进行总结以便大家参考。 抽象设计 首先我们要进行一下抽象设计，...
PLC通讯实现-C#实现AB5000 PLC串口通讯DTL32（七）
分享技术，传播知识!
11-08 2682
PLC通讯实现-C#实现AB5000 PLC串口通讯DTL32（七）背景抽象设计AB串口通讯实现DTL32 背景 本人近十年的工作都与工业软件相关、其中工控系统开发过程中有一个必要环节就是跟各大厂商的PLC进行通讯，而对于从互联网行业跨入工业互联网行业的从业人员来说要实现各型号PLC通讯还是需要一个过程的，本人在此对主流型号PLC通讯实现进行总结以便大家参考。 抽象设计 首先我们要进行一下抽象设计...
CommonCodes C# 类库(串口通讯,.Net Remoting FtpCS)
04-10
串口通讯是计算机通过串行端口与其他设备进行数据传输的一种方式。在C#中，`System.IO.Ports`命名空间提供了`SerialPort`类来处理串口操作。`SerialPort`类支持设置波特率、数据位、停止位、校验位等参数，并且提供...
c# 写的通讯框架类
01-10
c# 写的通讯框架类 本类里 用到了三个线程 ，分别处理 数据的接受，数据存储，客户端的管理。已经过测试，可支持上千个客户端
c#常用模块通信类
09-16
压力温度张力ph等仪器仪表c#模块通信类
C#串口通讯类
11-28
C#串口通讯类，基于System.IO.SerialPort类。内部默认处理了对串口操作中涉及的串口同步读取，按照协议解析数据等
C#串口通讯类和例程
06-07
包含一个CommPort的串口通讯类和如何使用的例程。 自己工作要用到串口通讯，于是在网上找了很多的方法都不是很完善，都有点问题，所以自己做了些更改，现在收发都OK了。
C#串口通信类
黑夜中的潜行者
03-28 1058
分享一段C#的串口通信类 也希望可以对更多像我一样的初学者带来更多的帮助 ???????? using System; using System.IO.Ports; using System.Threading; namespace SerialPortProgram { public class SerialPortOP { SerialPort mSerialPort; bool ReceiveEventFlag = false; pu
C#中网络通信
10-11 200
一、服务端代码 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....
C#开发的工业通讯测试工具类与PLC协议实现示例
本资源旨在介绍如何基于C#开发语言实现一个工业上位机的通讯测试工具类，并通过实例演示如何支持不同厂商的PLC协议，以及实现基础的TCP/IP、串口通讯和IO口通讯。 知识点一：C#基础与工业自动化 C#（读作C Sharp）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值