## 引言

### AOP
**AOP（Aspect-Oriented Programming）** 编程思想是一种面向切面编程的编程范式。在日常的软件开发中，我们经常会遇到一些**横切关注点（cross-cutting concerns）**，如`日志记录`、`事务处理`、`权限控制`、`异常处理`等。这些横切关注点可能会存在于程序的多个模块中，使得程序的不同模块之间存在较强的耦合性，从而影响了程序的可维护性和可扩展性。AOP编程思想的目的就是将这些横切关注点从程序的业务逻辑中剥离出来，并将其模块化处理，从而提高程序的可维护性和可扩展性。


 
### 切面
在AOP编程思想中，切面（aspect）是指横切关注点的抽象概念，它通常用一个类或一个模块来表示。切面通过将横切关注点的代码封装到独立的模块中，使得这些代码可以在程序的不同模块之间共享和复用。切面通过定义切点（pointcut）和通知（advice）来实现对横切关注点的处理。

### 切点
切点定义了哪些代码片段需要被处理，通知则定义了在切点处执行的处理逻辑。在AOP编程中，通知可以分为前置通知（before advice）、后置通知（after advice）、环绕通知（around advice）等不同类型，具体使用哪种类型的通知取决于需要实现的功能。

## AOP 的优缺点

### 优点
1. **解耦**：AOP编程将横切关注点从业务逻辑中分离出来，使得程序各个模块之间的依赖关系降低，从而实现了解耦。
2. **复用**：AOP编程将横切关注点封装到独立的模块中，使得这些代码可以在程序的不同模块之间共享和复用。
3. **可维护性**：AOP编程将横切关注点的处理逻辑从业务逻辑中分离出来，使得程序的各个模块更加简单，易于维护。
4. **可扩展性**：AOP编程通过切面的定义和配置，可以很容易地扩展系统的功能，而不需要对原有的业务逻辑进行修改。

### 缺点
1. **增加复杂性**：AOP编程将程序的逻辑分散到多个模块中，增加了程序的复杂性，对于一些小规模的项目可能会显得过于复杂。
2. **难以调试**：由于横切关注点的代码可能被多个模块共享，所以在调试时可能会比较困难。

AOP编程思想增加了程序的复杂性，难以调试等。但总体来说，AOP编程思想对于大型软件系统的开发和维护是非常有用的。它可以使得程序的结构更加清晰、易于维护和扩展，同时也可以提高程序的重用性和可测试性。使用AOP编程思想可以让开发人员更加专注于业务逻辑的实现，而将横切关注点的处理交给AOP框架去处理，从而提高开发效率和代码质量。

## C# 利用AutoFac实现简单AOP

接下来我们借助`反射`，`Attribute`,三方容器`AutoFac`，实现一个简单AOP：

### 1. 创建动态代理

```csharp
    internal class DynamicProxy<T> : DispatchProxy
    {
        public T? decorated { get; set; }//目标类
        
        public Action<object?[]?>? _BeforeAction { get; set; } // 动作之前执行
        
        public Action<object?[]?, object>? _AfterAction { get; set; }  // 动作之后执行
        
        public Action<Exception>? _CatchExceptionAction { get; set; }  // 捕获异常之后执行

        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
        {
            Exception exception = null;

            Before(args);

            object result = null;
            try
            {
                //调用实际目标对象的方法
                result = targetMethod?.Invoke(decorated, args);
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            After(args, result);

            //调用完执行方法后的委托，如果有异常，抛出异常
            if (exception != null)
            {
                CatchException(exception);
            }
            return result;
        }

        /// <summary>
        /// 创建代理实例
        /// </summary>
        /// <param name="decorated">代理的接口类型</param>
        /// <param name="beforeAction">方法执行前执行的事件</param>
        /// <param name="afterAction">方法执行后执行的事件</param>
        /// <param name="catchException">异常捕获后执行的事件</param>
        /// <returns></returns>
        public T Create(T decorated, Action<object?[]?> beforeAction, Action<object?[]?, object> afterAction, Action<Exception> catchException)
        {
            // 调用DispatchProxy 的Create  创建一个新的T
            object proxy = Create<T, DynamicProxy<T>>();

            DynamicProxy<T> proxyDecorator = (DynamicProxy<T>)proxy;

            proxyDecorator.decorated = decorated;

            //把自定义的方法委托给代理类
            proxyDecorator._AfterAction = afterAction;

            proxyDecorator._BeforeAction = beforeAction;

            proxyDecorator._CatchExceptionAction = catchException;

            return (T)proxy;
        }

        private void Before(object?[]? args)
        {
            try
            {
                _BeforeAction.Invoke(args);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"执行之前异常：{ex.Message}");
            }
        }

        private void After(object?[]? args, object? result)
        {
            try
            {
                _AfterAction.Invoke(args, result);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"执行之后异常：{ex.Message}");
            }
        }

        private void CatchException(Exception ex)
        {
            _CatchExceptionAction(ex);
        }
    }
```
### 2. 创建拦截器属性
标记AOP切点的**Attribute--InterceptAttribut**(拦截器属性)

```csharp
    /// <summary>
    /// 自定义拦截器特性
    /// </summary>
    [AttributeUsage(AttributeTargets.Class)]
    internal class InterceptAttribut : Attribute
    {
        public Type Type { get; set; }
        public InterceptAttribut(Type type)
        {
            this.Type = type;
        }
    }
```


### 3. 创建动态代理工厂类
它是泛型工厂,用于创建不同类型的代理类

```csharp
    class DynamicProxyFactory
    {
        /// <summary>
        /// 创建代理实例
        /// </summary>
        /// <param name="decorated">代理的接口类型</param>
        /// <returns></returns>
        public static T Create<T>()
        {
            var decorated = ServiceHelp.GetService<T>(typeof(T));
            
            var type = decorated.GetType();
            
            var interceptAttribut = type.GetCustomAttribute<InterceptAttribut>();
            
            var interceptor = ServiceHelp.GetService<IInterceptor>(interceptAttribut.Type);
            //创建代理类
            var proxy = new DynamicProxy<T>().Create(decorated, interceptor.BeforeExecuted, interceptor.AfterExecuted, interceptor.CatchException);
            
            return proxy;
        }
    }
```
### 4. 创建ServiceHelp
ServiceHelp用于获取实例,其核心就是以Autofac这个IOC容器去注册及获取服务.

```csharp
    internal class ServiceHelp
    {
        //实例化Autofac容器
        private static ContainerBuilder builder = new ContainerBuilder();

        public static IContainer? serviceProvider { get; set; }

        public static void BuildServiceProvider()
        {
            //注册InstanceModule组件
            builder.RegisterModule<InstanceModule>();
            //创建容器
            serviceProvider = builder.Build();
        }

        internal static T GetService<T>(Type serviceType)
        {
            if (serviceProvider.IsRegistered(serviceType))
            {
                return (T)serviceProvider.Resolve(serviceType);
            }
            return default(T);
        }
    }
```
### 5. 创建AOP切面

```csharp
    /// <summary>
    /// 自定义拦截器接口
    /// </summary>
    interface IInterceptor
    {
        /// <summary>
        /// 执行前
        /// </summary>
        /// <param name="args"></param>
        void BeforeExecuted(object?[]? args);
        /// <summary>
        /// 执行后
        /// </summary>
        /// <param name="args">参数</param>
        /// <param name="result">返回值</param>
        void AfterExecuted(object?[]? args, object? result);

        void CatchException(Exception ex);

    }
    /// <summary>
    /// 方法执行的切面
    /// </summary>
    class ExecutAOP : IInterceptor
    {
        public void AfterExecuted(object?[]? args, object? result)
        {
            Console.WriteLine($"拦截器中方法后执行~~~~");
        }

        public void BeforeExecuted(object?[]? args)
        {
            if (args != null && args.Length > 0 && args[0] == null)
                throw new Exception("参数错误");
            Console.WriteLine($"拦截器中方法前执行~~~~");

        }
        public void CatchException(Exception ex)
        {
            Console.WriteLine($"拦截器中捕获到了异常~~~~\r\n{ex.InnerException.Message}");
        }
    }
```
### 6. 创建测试模型
设定一个业务场景,有一个交通工具`ITransportation`有两个公共方法` Run()` 、`Eat()`,以及其实现`Hours`类
```csharp
    interface ITransportation
    {
        public void Run();
        
        public void Eat(string food);
    }

    [InterceptAttribut(typeof(ExecutAOP))]
    class Horse : ITransportation
    {
        public void Eat(string food)
        {
            Console.WriteLine($"小马儿吃了{food}~~~~~~~~~~~~");
        }

        public void Run()
        {
            Console.WriteLine("马儿马儿快马加鞭~~~~~~~~~~~~");
            throw new Exception("小马儿掉沟里了");
        }
    }
```
### 7.测试场景

1. 测试切面方法执行前和执行后

    
```csharp
    static void Main(string[] args)
    {
        ServiceHelp.BuildServiceProvider();

        var hours = DynamicProxyFactory.Create<ITransportation>();

        hours.Eat("新鲜牧草");

        Console.ReadLine();
    }

```
输出:

![image.png](https://niuery.com/static/img/bcace5bd480606ac5fb97bc4b7c3bb7e.image.png)

从控制台输出可以看到，`Horse`再执行`Eat`方法前和方法后都被拦截，并输出了预期结果

2. 测试切面方法异常处理
```csharp
    static void Main(string[] args)
    {
        ServiceHelp.BuildServiceProvider();

        var hours = DynamicProxyFactory.Create<ITransportation>();

        hours.Run();

        Console.ReadLine();
    }

```
输出:

![image.png](https://niuery.com/static/img/4c115bd6a04fd809bc1148e2eace0ee1.image.png)
再`Horse`的`Run`方法中我们主动抛出了异常，然后从控制台输出可以看到，异常也被拦截器拦截，并做了处理输出`拦截器中捕获到了异常`及异常信息。

## 总结
总之，AOP编程思想是一种非常有用的编程范式，它可以使得程序的结构更加清晰、易于维护和扩展，同时也可以提高程序的重用性和可测试性。在日常的软件开发中，我们可以使用AOP框架来实现AOP编程思想，从而提高开发效率和代码质量。

AOP --- 面向切面编程

## 引言

IOC，全称为 Inversion of Control（控制反转），是一种重要的编程思想，它可以帮助我们更好地管理程序中的依赖关系。在IOC的基础上，依赖注入（Dependency Injection，DI）是一种实现IOC的技术手段，它可以提高代码**可测试性**，**可维护性**，**可拓展性**。


## 什么是IOC？

在传统的程序设计中，我们通常会使用直接依赖的方式来实现功能，这意味着我们需要自己创建并管理对象之间的依赖关系。这种方式有一个很明显的缺点，就是代码之间的耦合度非常高，一旦某个类发生了改变，所有依赖于它的类都需要修改。

而IOC则是一种反转控制的方式，它将对象的创建、依赖管理等控制权从程序员手中转移到了容器中，容器会根据配置信息来自动创建对象、管理依赖关系。这样做的好处在于，我们只需要关注自己的业务逻辑，而不需要关心对象的创建、销毁等底层细节

## 什么是依赖注入？
依赖注入是实现IOC的一种方式，它是指将对象所需要的依赖关系通过构造函数、属性、方法等方式传递给对象。通常情况下，我们会使用**构造函数注入**、**Setter方法注入**、**接口注入**等方式来实现依赖注入。

以构造函数注入为例，我们可以将对象所需要的依赖关系通过构造函数的参数传递进来，这样做的好处在于，我们可以在对象创建的时候就确定它所依赖的对象，从而避免了后续修改依赖关系的麻烦。

## 直接依赖可能存在的问题

### 1. 高度耦合
在应用程序中使用紧密耦合的代码会导致代码难以维护和扩展。当一个组件的代码更改时，需要更改其他依赖于该组件的组件的代码。这种高度耦合的代码可能难以单元测试，因为测试需要创建所有依赖项的实例，这可能会使测试变得复杂

### 2. 硬编码依赖项
如果应用程序使用硬编码依赖项，即在代码中直接实例化依赖项，那么应用程序的可测试性将受到影响。这是因为在测试时，不可能轻松地用模拟对象或者桩来替换硬编码的依赖项，这样可能会使测试变得非常困难

### 3. 依赖项管理困难
如果没有使用IOC容器，那么将需要手动管理依赖项的生命周期，包括创建、初始化和销毁。这可能会使代码更加复杂，容易出错，也会导致代码可维护性的下降。

### 4. 缺乏灵活性
没有使用IOC，可能会导致应用程序的灵活性下降。因为依赖项在代码中硬编码，所以更改依赖项需要更改代码。而使用IOC，只需要更改配置即可更改依赖项，从而提高了应用程序的灵活性

### 5. 代码重复
如果没有使用IOC，那么可能会在应用程序中出现大量的重复代码。因为每个组件都需要手动实例化它们的依赖项，这可能导致重复的代码。而使用IOC，可以将依赖项的创建和管理交给IOC容器，从而避免代码重复

## 依赖注入的实现方式
依赖注入的实现方式有很多种，常见的有构造函数注入、Setter方法注入、接口注入等。

### 1. 构造函数注入
构造函数注入是最常见的依赖注入方式，它可以将对象所需要的依赖关系通过构造函数的参数传递进来。这种方式的好处在于，可以在对象创建的时候就确定它所依赖的对象，从而避免了后续修改依赖关系的麻烦。

```csharp
public class MyService
{
    private readonly ILogger _logger;
    private readonly IEmailService _emailService;

    public MyService(ILogger logger, IEmailService emailService)
    {
        _logger = logger;
        _emailService = emailService;
    }

    public void DoSomething()
    {
        // 业务逻辑代码
        // ...
        _logger.Log("DoSomething has been executed");
        _emailService.SendEmail("someone@example.com", "DoSomething has been executed");
    }
}

```

### 2. Setter方法注入
Setter方法注入是另一种常见的依赖注入方式，它可以将对象所需要的依赖关系通过Setter方法进行注入。这种方式的好处在于，可以将对象的依赖关系动态地进行修改，从而更加灵活地管理依赖关系。


```csharp
public class MyService
{
    private ILogger _logger;
    private IEmailService _emailService;

    public void SetLogger(ILogger logger)
    {
        _logger = logger;
    }

    public void SetEmailService(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public void DoSomething()
    {
        // 业务逻辑代码
        // ...
        _logger.Log("DoSomething has been executed");
        _emailService.SendEmail("someone@example.com", "DoSomething has been executed");
    }
}
```

### 3. 接口注入
接口注入是一种比较高级的依赖注入方式，它可以将对象所需要的依赖关系通过接口进行注入。这种方式的好处在于，可以通过接口来进行依赖管理，从而更加灵活地实现对象之间的交互。

```csharp
public interface ILogger
{
    void Log(string message);
}

public interface IEmailService
{
    void SendEmail(string toAddress, string message);
}

public class MyService : IServiceDependency
{
    private readonly ILogger _logger;
    private readonly IEmailService _emailService;

    public MyService(IServiceProvider serviceProvider)
    {
        _logger = serviceProvider.GetService<ILogger>();
        _emailService = serviceProvider.GetService<IEmailService>();
    }

    public void DoSomething()
    {
        // 业务逻辑代码
        // ...
        _logger.Log("DoSomething has been executed");
        _emailService.SendEmail("someone@example.com", "DoSomething has been executed");
    }
}

public interface IServiceDependency
{
}

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddMyServices(this IServiceCollection services)
    {
        services.AddSingleton<ILogger, ConsoleLogger>();
        services.AddSingleton<IEmailService, SmtpEmailService>();
        services.AddSingleton<IServiceDependency>(serviceProvider => new MyService(serviceProvider));
        return services;
    }
}

public class Program
{
    static void Main(string[] args)
    {
        var services = new ServiceCollection();
        services.AddMyServices();

        using (var serviceProvider = services.BuildServiceProvider())
        {
            var myService = serviceProvider.GetService<IServiceDependency>();
            myService.DoSomething();
        }
    }
}

```
## 总结

依赖注入是一种实现IOC的技术手段，它可以帮助我们更好地管理程序中的依赖关系，降低代码耦合度，提高代码复用性和可测试性。当我们掌握了依赖注入的技术，就可以更加轻松地编写高质量、可维护的代码。

IOC --- 控制反转

上文中介绍了[C#ModBus Tcp的学习及Master的实现](http://niuery.com/post/1)，本篇介绍串口实现Modbus RTU。

Modbus协议目前存在用于串口、以太网以及其他支持互联网协议的网络的版本。




![uTools_1678010627779.png](http://niuery.com/static/img/32e64e688ea08fd3436c73269e9c7685.uTools_1678010627779.png)


## 实现
### 引用**NModbus4**
Modbus RTU实现依然借助开源库**NModbus4**，在vs中.打开NuGet管理器.安装NModbus4


![1630815-20190511105244313-446452823.png](http://niuery.com/static/img/d890bc3bf26ed606f8aa943d935836ed.1630815-20190511105244313-446452823.png)
### 代码实现
实现与之前的Modbus Tcp的实现类似 ,只是在实例化master时将TCPClient换为串行端口资源SerialPort,并在实例化是设置好端口所需参数(端口名,波特率,校验位,停止位,数据位)。

```csharp
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Modbus.Device;
using System.Net.Sockets;
using System.Threading;
using System.IO.Ports;

namespace ModbusRtu
{
    public partial class Form1 : Form
    {
        private static IModbusMaster master;
        private static SerialPort port;
        //写线圈或写寄存器数组
        private bool[] coilsBuffer;
        private ushort[] registerBuffer;
        //功能码
        private string functionCode;
        //参数(分别为站号,起始地址,长度)
        private byte slaveAddress;
        private ushort startAddress;
        private ushort numberOfPoints;
        //串口参数
        private string portName;
        private int baudRate;
        private Parity parity;
        private int dataBits;
        private StopBits stopBits;

        public Form1()
        {
            InitializeComponent();
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            cmb_portname.SelectedIndex = 0;
            cmb_baud.SelectedIndex = 5;
            cmb_parity.SelectedIndex = 2;
            cmb_databBits.SelectedIndex = 1;
            cmb_stopBits.SelectedIndex = 0;
        }
        private SerialPort InitSerialPortParameter()
        {
            if (cmb_portname.SelectedIndex < 0 || cmb_baud.SelectedIndex < 0 || cmb_parity.SelectedIndex < 0 || cmb_databBits.SelectedIndex < 0 || cmb_stopBits.SelectedIndex < 0)
            {
                MessageBox.Show("请选择串口参数");
                return null;
            }
            else
            {

                portName = cmb_portname.SelectedItem.ToString();
                baudRate = int.Parse(cmb_baud.SelectedItem.ToString());
                switch (cmb_parity.SelectedItem.ToString())
                {
                    case "奇":
                        parity = Parity.Odd;
                        break;
                    case "偶":
                        parity = Parity.Even;
                        break;
                    case "无":
                        parity = Parity.None;
                        break;
                    default:
                        break;
                }
                dataBits = int.Parse(cmb_databBits.SelectedItem.ToString());
                switch (cmb_stopBits.SelectedItem.ToString())
                {
                    case "1":
                        stopBits = StopBits.One;
                        break;
                    case "2":
                        stopBits = StopBits.Two;
                        break;
                    default:
                        break;
                }
                port = new SerialPort(portName, baudRate, parity, dataBits, stopBits);
                return port;
            }
        }
        /// <summary>
        /// 读/写
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                //初始化串口参数
                InitSerialPortParameter();

                master = ModbusSerialMaster.CreateRtu(port);

                ExecuteFunction();
            }
            catch (Exception)
            {
                MessageBox.Show("初始化异常");
            }
        }

        private async void ExecuteFunction()
        {
            try
            {
                //每次操作是要开启串口 操作完成后需要关闭串口
                //目的是为了slave更换连接是不报错
                if (port.IsOpen == false)
                {
                    port.Open();
                }
                if (functionCode != null)
                {
                    switch (functionCode)
                    {
                        case "01 Read Coils"://读取单个线圈
                            SetReadParameters();
                            coilsBuffer = master.ReadCoils(slaveAddress, startAddress, numberOfPoints);

                            for (int i = 0; i < coilsBuffer.Length; i++)
                            {
                                SetMsg(coilsBuffer[i] + " ");
                            }
                            SetMsg("\r\n");
                            break;
                        case "02 Read DisCrete Inputs"://读取输入线圈/离散量线圈
                            SetReadParameters();

                            coilsBuffer = master.ReadInputs(slaveAddress, startAddress, numberOfPoints);
                            for (int i = 0; i < coilsBuffer.Length; i++)
                            {
                                SetMsg(coilsBuffer[i] + " ");
                            }
                            SetMsg("\r\n");
                            break;
                        case "03 Read Holding Registers"://读取保持寄存器
                            SetReadParameters();
                            registerBuffer = master.ReadHoldingRegisters(slaveAddress, startAddress, numberOfPoints);
                            for (int i = 0; i < registerBuffer.Length; i++)
                            {
                                SetMsg(registerBuffer[i] + " ");
                            }
                            SetMsg("\r\n");
                            break;
                        case "04 Read Input Registers"://读取输入寄存器
                            SetReadParameters();
                            registerBuffer = master.ReadInputRegisters(slaveAddress, startAddress, numberOfPoints);
                            for (int i = 0; i < registerBuffer.Length; i++)
                            {
                                SetMsg(registerBuffer[i] + " ");
                            }
                            SetMsg("\r\n");
                            break;
                        case "05 Write Single Coil"://写单个线圈
                            SetWriteParametes();
                            await master.WriteSingleCoilAsync(slaveAddress, startAddress, coilsBuffer[0]);
                            break;
                        case "06 Write Single Registers"://写单个输入线圈/离散量线圈
                            SetWriteParametes();
                            await master.WriteSingleRegisterAsync(slaveAddress, startAddress, registerBuffer[0]);
                            break;
                        case "0F Write Multiple Coils"://写一组线圈
                            SetWriteParametes();
                            await master.WriteMultipleCoilsAsync(slaveAddress, startAddress, coilsBuffer);
                            break;
                        case "10 Write Multiple Registers"://写一组保持寄存器
                            SetWriteParametes();
                            await master.WriteMultipleRegistersAsync(slaveAddress, startAddress, registerBuffer);
                            break;
                        default:
                            break;
                    }

                }
                else
                {
                    MessageBox.Show("请选择功能码!");
                }
                port.Close();
            }
            catch (Exception ex)
            {

                MessageBox.Show(ex.Message);
            }
        }
        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (comboBox1.SelectedIndex >= 4)
            {
                groupBox2.Enabled = true;
                groupBox1.Enabled = false;
            }
            else
            {
                groupBox1.Enabled = true;
                groupBox2.Enabled = false;
            }
            comboBox1.Invoke(new Action(() => { functionCode = comboBox1.SelectedItem.ToString(); }));
        }

        /// <summary>
        /// 初始化读参数
        /// </summary>
        private void SetReadParameters()
        {
            if (txt_startAddr1.Text == "" || txt_slave1.Text == "" || txt_length.Text == "")
            {
                MessageBox.Show("请填写读参数!");
            }
            else
            {
                slaveAddress = byte.Parse(txt_slave1.Text);
                startAddress = ushort.Parse(txt_startAddr1.Text);
                numberOfPoints = ushort.Parse(txt_length.Text);
            }
        }
        /// <summary>
        /// 初始化写参数
        /// </summary>
        private void SetWriteParametes()
        {
            if (txt_startAddr2.Text == "" || txt_slave2.Text == "" || txt_data.Text == "")
            {
                MessageBox.Show("请填写写参数!");
            }
            else
            {
                slaveAddress = byte.Parse(txt_slave2.Text);
                startAddress = ushort.Parse(txt_startAddr2.Text);
                //判断是否写线圈
                if (comboBox1.SelectedIndex == 4 || comboBox1.SelectedIndex == 6)
                {
                    string[] strarr = txt_data.Text.Split(' ');
                    coilsBuffer = new bool[strarr.Length];
                    //转化为bool数组
                    for (int i = 0; i < strarr.Length; i++)
                    {
                        // strarr[i] == "0" ? coilsBuffer[i] = true : coilsBuffer[i] = false;
                        if (strarr[i] == "0")
                        {
                            coilsBuffer[i] = false;
                        }
                        else
                        {
                            coilsBuffer[i] = true;
                        }
                    }
                }
                else
                {
                    //转化ushort数组
                    string[] strarr = txt_data.Text.Split(' ');
                    registerBuffer = new ushort[strarr.Length];
                    for (int i = 0; i < strarr.Length; i++)
                    {
                        registerBuffer[i] = ushort.Parse(strarr[i]);
                    }
                }
            }
        }

        /// <summary>
        /// 清除文本
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            richTextBox1.Clear();
        }
        /// <summary>
        /// SetMessage
        /// </summary>
        /// <param name="msg"></param>
        public void SetMsg(string msg)
        {
            richTextBox1.Invoke(new Action(() => { richTextBox1.AppendText(msg); }));
        }

    }
}
```
### 测试准备

借助工具 **Virtual Serial Port Dirver** 虚拟串口工具。

链接：https://pan.baidu.com/s/1opGre3GS-HWFoA_dP9qYYg

提取码：2afu 

1. 借助工具我们添加两个虚拟串口 COM1和COM2 点击 **Add Virtual Pair** 添加：


    ![1630815-20190511194028409-724607865.png](http://niuery.com/static/img/2536f7a18d49912647ec184ac1f143ed.1630815-20190511194028409-724607865.png)

2. 设置Modbus Slave,选择连接方式为串口,选择对应端口,模式选择RTU,建立连接：


    ![1630815-20190511194645309-195780803.png](http://niuery.com/static/img/720c44228fd1a4b0bc8f6816e9205a39.1630815-20190511194645309-195780803.png)
    
### 测试开始

1. 运行上文实现的Modbus RTU Master；
2. 设置串口参数（波特率，数据位，奇偶校验，停止位）要与Slave的串口参数一致：

    测试 **功能码 0x01** 读一组线圈

    ![1630815-20190511195346652-1022612729.png](http://niuery.com/static/img/d1c36bfba929f0a71087398efe135b96.1630815-20190511195346652-1022612729.png)


到此为止，Modbus的学习到此结束。若有错误之处，欢迎大家指正。

Modbus（三）---C#Modbus Rtu的实现

因新项目框架升级为 .Net 5.0，原Framework的MongoDB的ORM，不再适用，且旧ORM使用不便，写查询还需要编写BosnDocument，不易于理解，便有了更新ORM的想法。

于是翻看了一下MongoDB的[官方文档](https://www.mongodb.com/docs/drivers/csharp/current/)，发现官方驱动功能本身已经非常强大，且更新迅速，从2.3版本之后就已经支持 .Net 5.0，方法都已支持Task ,可以配合async , await.使用 ,同时也支持Lambda表达式及表达式树。所以便有了创建一个简易版基于MongoDB官方驱动的ORM的想法。


![1677984339841.jpg](http://niuery.com/static/img/15407684f506b7e0c84bd9117b07c5d1.1677984339841.jpg)

## 设计思路
1. 对象实体基类

    为什么要创建实体对象基类？是因为官方驱动支持的实体类与Collection得映射，必须要有id字段，对应数据库中得"_id"，并且这个字段是ObjectIDl类型，像这样：
    
```csharp
 public class Person
    {
        [BsonId]
        [BsonElement("_id")]
        public ObjectId ID { get; set; }
    }
```
    
2. 实现实体类与Collection得自动映射 自动创建数据库连接
    
    我们需要自定义一个Attribute，用于获取获取集合名称，然后创建一个管理器实现一些自动映射的初始化操作；
3. 实现Repository仓储类.提供简单得CRUD方法

    通过封装直接调用官方的驱动提供的API,实现CURD操作；
 
 ## 具体实现
 
 
 
 
 ### 创建对象实体基类
 
```csharp
    [DataContract]
    [Serializable]
    [BsonIgnoreExtraElements(Inherited = true)]  //当BSON文档被反序列化时，每个元素的名称用于在类映射中查找匹配的成员。通常，如果没有找到匹配的成员，将抛出异常。如果要在反序列化期间忽略其他元素 使用这个特性
    public abstract class MongoEntityBase : IMongoEntityBase<string>
    {
        protected MongoEntityBase()
        {
            DB_ID = ObjectId.GenerateNewId().ToString();  //对id进行初始化
        }

        [DataMember]　　　　　
        [BsonElement("_id")]
        [BsonRepresentation(BsonType.ObjectId)]  //因为 ObjectId 这个结构体是不能序列化的,所以使用  [BsonRepresentation(BsonType.ObjectId)] 标记为这个字符串ID在mongo中代表ObjectId
        public virtual string DB_ID { get; set; }        
    }

    public interface IMongoEntityBase<TKey>
    {
        [BsonId]
        TKey DB_ID { get; set; }
    }
    public interface IMongoEntityBase : IMongoEntityBase<string>
    {
    }
```

### 实现实体类与Collection的自动映射


1. 　我们需要先创建一个Attribute类,用于标记实体类来获取实体类对应的集合名称,如下:


```csharp
    [AttributeUsage(AttributeTargets.Class, Inherited = true)]
    public class CollectionNameAttribute : Attribute
    {
        public CollectionNameAttribute(string name)

        {
            if (string.IsNullOrEmpty(name)) throw new ArgumentException("Empty collectionname not allowed", "name");

            this.Name = name;
        }

        public string Name { get; private set; } //定义一个属性 用于获取Collection名称
    }
```
2. App.Config中添加配置信息，用于连接数据库

    
```xml
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add name="MongoServerSettings" connectionString="mongodb://localhost/Person" />
  </connectionStrings>
</configuration>
```

3. 实现一个管理器,用于自动映射


:::tip{title="Tip"}
数据库连接的自动映射,官方驱动其实已经提供了实体类的自动映射

![1630815-20210514153056023-1703034695.png](http://niuery.com/static/img/28db9b518669655a27b432542e8a8c0b.1630815-20210514153056023-1703034695.png)
:::

```csharp
    internal class GlobleManage<T>
    {
        public readonly static GlobleManage<T> Instance = new GlobleManage<T>();

        private string _tableName;
        
        private string _dateBaseName;
        
        private string _mongoServerSettings;
        
        private IMongoCollection<T> _mongoCollection;

        public IMongoCollection<T> MongoCollection
        {
            get => _mongoCollection;

        }
        public string DateBaseName
        {
            get => _dateBaseName;
        }

        public string MongoServerSettings
        {
            get => _mongoServerSettings;
        }
        public string TableName
        {
            get => _tableName;
            set => _tableName = value;
        }

        internal GlobleManage()
        {
            Init();
        }

        private void Init()
        {
            try
            {
                //初始化连接字符串
                string[] parm = ConfigurationManager.ConnectionStrings["MongoServerSettings"].ConnectionString.Split('/');

                _dateBaseName = parm.Last();
                
                _mongoServerSettings = ConfigurationManager.ConnectionStrings["MongoServerSettings"].ConnectionString.Replace(@"/" + _dateBaseName, ":27017");


                //根据实体类标注好的Attribute获取表名
                var entitytype = typeof(T);
                
                var attr = Attribute.GetCustomAttribute(entitytype, typeof(CollectionNameAttribute));
                //若Attribute不为空  获取标注的表名
                if (attr != null)
                {
                    _tableName = ((CollectionNameAttribute)attr).Name;
                }
                else
                {
                    //否则  如果类型是MongoEntityBase的派生类 获取类名作为表名
                    if (typeof(MongoEntityBase).IsAssignableFrom(entitytype))
                    {
                        // No attribute found, get the basetype
                        while (!entitytype.BaseType.Equals(typeof(MongoEntityBase)))
                        {
                            entitytype = entitytype.BaseType;
                        }
                    }
                    _tableName = entitytype.Name;
                }
                //添加实体类映射
                if(!BsonClassMap.IsClassMapRegistered(entitytype))
                    BsonClassMap.RegisterClassMap<T>(cm => cm.AutoMap());

                _mongoCollection = new MongoClient(_mongoServerSettings).GetDatabase(_dateBaseName).GetCollection<T>(_tableName);
            }
            catch (Exception ex)
            {
                _mongoCollection = default;
            }
        }

        public IMongoCollection<T> GetConnection(string tableStr)
        {
            return new MongoClient(_mongoServerSettings).GetDatabase(_dateBaseName).GetCollection<T>(tableStr);
        }
    }
```
### 实现Repository仓储类.提供简单的CRUD方法

1. 创建仓储类的泛型接口　

    
```csharp
    public interface IRepository<T> where T : IMongoEntityBase<string>
    {
        IMongoCollection<T> Collection { get; }

        event Action<object, Exception> ExecutedExceptionEventHandler;
        
        bool Add(T entity);
        
        bool Delete(T delete, Expression<Func<T, bool>> conditions = null);
        
        bool Update(T update, Expression<Func<T, bool>> conditions = null);
        
        List<T> Find(Expression<Func<T, bool>> conditions = null);
    }
```
2. 泛型仓储类实现接口,通过管理器获取自动映射得到的 IMongoCollection
    
```csharp 
 public class Repository<T> : IRepository<T> where T : IMongoEntityBase<string>
    {
        private readonly IMongoCollection<T> _mongoCollection;
        
        public IMongoCollection<T> Collection => _mongoCollection;
        
        public event Action<object, Exception> ExecutedExceptionEventHandler;
        
        public Repository()
        {
            _mongoCollection = GlobleManage<T>.Instance.MongoCollection;
        }
        
        public Repository(string tableStr)
        {
            _mongoCollection = GlobleManage<T>.Instance.GetConnection(tableStr);
        }

        public bool Add(T entity)
        {
            try
            {
                _mongoCollection.InsertOne(entity);
                return true;
            }
            catch (Exception ex)
            {
                ExecutedExceptionEventHandler?.Invoke($"ExecutedException Add({typeof(T).FullName})", ex);
                throw ex;

            }
        }

        public bool Delete(T delete, Expression<Func<T, bool>> conditions = null)
        {
            try
            {
                string _id = string.Empty;
                if (conditions == null)
                {
                    foreach (var item in delete.GetType().GetProperties())
                    {
                        if (item.Name == "DB_ID" && item.GetValue(delete) != null)
                        {
                            _id = item.GetValue(delete).ToString();
                            var result = _mongoCollection.DeleteOne(new BsonDocument("_id", BsonValue.Create(new ObjectId(_id))));
                            return result.IsAcknowledged;
                        }
                    }
                }
                var res = _mongoCollection.DeleteOne(conditions);
                return res.IsAcknowledged;
            }
            catch (Exception ex)
            {
                ExecutedExceptionEventHandler?.Invoke($"ExecutedException Delete({typeof(T).FullName})", ex);
                throw ex;
            }
        }

        public bool Update(T update, Expression<Func<T, bool>> conditions = null)
        {
            try
            {
                ObjectId _id;
                var options = new ReplaceOptions() { IsUpsert = true };
                if (conditions == null)
                {
                    foreach (var item in update?.GetType().GetProperties())
                    {
                        if (item.Name == "DB_ID" && item.GetValue(update) != null)
                        {
                            _id = new ObjectId(item.GetValue(update).ToString());
                            var result = _mongoCollection.ReplaceOne(new BsonDocument("_id", BsonValue.Create(_id)), update, options);
                            return result.IsAcknowledged;
                        }
                    }
                }
                var res = _mongoCollection.ReplaceOne(conditions, update, options);
                return res.IsAcknowledged;
            }
            catch (Exception ex)
            {
                ExecutedExceptionEventHandler?.Invoke($"ExecutedException Update({typeof(T).FullName},{conditions})", ex);
                throw ex;
            }
        }

        public List<T> Find(Expression<Func<T, bool>> conditions = null)
        {
            try
            {
                if (conditions == null)
                {
                    conditions = t => true;
                }
                return _mongoCollection.Find(conditions).ToList() ?? new List<T>();
            }
            catch (Exception ex)
            {
                ExecutedExceptionEventHandler?.Invoke($"ExecutedException Find({typeof(T).FullName},{conditions})", ex);
                throw ex;
            }
        }
    }
```
至此，一个简易版基于MongoDB官方驱动的ORM就完成了。
## 示例代码
 核心调用：
 
     IRepository<Person> _IRepository = new Repository<Person>();

### 创建一个实体类,并且继承 MongoEntityBase
 
```csharp
    [Serializable]
    public class Person : MongoEntityBase
    {
        [BsonConstructor]
        public Person(string name, int age, EnumGender gender)
        {
            Name = name;
            Age = age;
            Gender = gender;
        }
    }
    
    public enum EnumGender
    {
        男,
        女
    }
```
### 使用

```csharp
    static void Main(string[] args)
    {
        IRepository<Person> _IRepository = new Repository<Person>()
        
        //...do something
        Person person = new Person("张三", 8, EnumGender.男);
        _IRepository.Add(person);
        
        //...do something
        var personList = _IRepository.Find(t => t.Name.Equals("张三"));
        
        //...do something
        var p = _IRepository.Find(t => t.Name.Equals("张三")).FirstOrDefault();
        if(p != null)
        {
            p.Name = "李四";
            var res = _IRepository.Update(p);
        }
        
        //...do something
        var p1 = _IRepository.Find(t => t.Name.Equals("李四")).FirstOrDefault();
        if(p1 != null)
        {
            var res = _IRepository.Delete(p1);
        }
        
    }
```

MongoDB --- C# 自定义MongoDB ORM

接上一篇，[C#ModBus Tcp的学习及Master的实现](http://niuery.com/post/1)，我们可以根据功能进行读写。本篇文章，主要对不同的功能码所发出的报文进行解析(包括请求报文及响应报文)。
 


## 读操作

### **功能码 0x01 读一组线圈** 
例：读取站号为1，从地址12开始的10个线圈：


![1630815-20190510181441380-1035543879.png](http://niuery.com/static/img/db0ac050bf6312cefbdd5a0fa8e90b74.1630815-20190510181441380-1035543879.png)


接下来，按照报文格式划分：


![1630815-20190507125605486-1036070568.png](http://niuery.com/static/img/733acf69c7f03225a5d55f5c2aae11b8.1630815-20190507125605486-1036070568.png)

 

解析一下上文中读一组线圈的报文：

```
000002-Rx:00 01 00 00 00 06 01 01 00 0C 00 0A
000003-Tx:00 01 00 00 00 05 01 01 02 AE 00
```


![1630815-20190510183553735-2007331914.png](http://niuery.com/static/img/93f092890385cc10bbc467e6b2360859.1630815-20190510183553735-2007331914.png)



:::tip{title="Tip"}
报文中线圈起始地址 **00000** 对应设备中 **10001** 地址，其他顺延。
:::

### **功能码0x02  读一组输入线圈/离散量线圈**
报文格式与功能码0x01一致，只是第八字节的功能码变为**02**，其他完全一致，解析参考上文。

### **功能码0x03 读一组保持寄存器** 
例：读取站号为1 从地址12开始的10个值

![1630815-20190510190045552-230039486.png](http://niuery.com/static/img/b40ed081bdc04645cb4b96c6720a9edf.1630815-20190510190045552-230039486.png)
解析报文：


![1630815-20190510191353804-697453985.png](http://niuery.com/static/img/f3a33905abb28efda700967f3ebff1d8.1630815-20190510191353804-697453985.png)

### 功能码0x04 读一组输入寄存器 
报文格式与功能码0x03一致，只是第八字节的功能码变为**04**，其他完全一致，解析参考上文。

 

## 写操作

### **功能码:0x05 写单个线圈**  
例：将站号为1，地址为21的线圈置为On：

:::tip{title="Tip"}
在报文中，指定线圈通断标志：
**FF00** 置线圈为**ON**，
**0000**置线圈为**OFF**
:::


![1630815-20190510201738294-757735980.png](http://niuery.com/static/img/69de351a3466b957ca0a482bd949ea36.1630815-20190510201738294-757735980.png)
报文解析:

![1630815-20190510202713559-525769030.png](http://niuery.com/static/img/8216390fd3ec0b31bf19d7fd329b28a0.1630815-20190510202713559-525769030.png)


 

### **功能码0x0F 写一组线圈** 
例：将站号1，起始地址21，的连续五个线圈置为：通，断，断，通，通

测试结果:

![1630815-20190510205207418-869645667.png](http://niuery.com/static/img/1974bac16b2b6baea4e37bc21058ae7c.1630815-20190510205207418-869645667.png)


报文解析:


![1630815-20190510205259390-1138719863.png](http://niuery.com/static/img/32c1543a432ba81490634b4b13a4b64a.1630815-20190510205259390-1138719863.png)

 

### **功能码 0x06  写单个保持寄存器**  
例：将6666写入从站1,地址为21的保持寄存器中:

测试结果

![1630815-20190510210234553-451130699.png](http://niuery.com/static/img/10fcd905b687ba2d06269039e8d38196.1630815-20190510210234553-451130699.png)


报文解析:

![1630815-20190510210250406-1451441253.png](http://niuery.com/static/img/31fa6385ff0e96cdb5d35258c0a8954e.1630815-20190510210250406-1451441253.png)


### **功能码0x10  写一组保持寄存器**   
例：将12，23，34，45，56，67，78分别写入从站1，起始地址为21的7个连续的保持寄存器中：

![1630815-20190510211859008-180180752.png](http://niuery.com/static/img/3c69ca55666e44ca5bd0476026897027.1630815-20190510211859008-180180752.png)
测试结果



报文解析:


![1630815-20190510211938701-1859410713.png](http://niuery.com/static/img/f514231390fec04a5b337c62981c4434.1630815-20190510211938701-1859410713.png)

至此，我们常用的几个ModBus功能码报文都解析完毕了，有错误之处，欢迎指正！