## 引言
SOLID是五个常见的面向对象设计原则的缩写，其目的是帮助开发者设计易于维护和扩展的软件系统

其中包含**单一职责原则(SRP)**，**开闭原则(OCP)**，**里氏替换原则(LSP)**，**接口隔离原则(ISP)**，**依赖反转原则(DIP)**。

除SOLID之外，后续又增加了**迪米特法则**。



## 单一职责原则

**单一职责原则（Single Responsibility Principle，SRP）**，这个原则指出一个类应该只有一个职责。也就是说，一个类应该只有一种修改的原因。如果一个类负责多个不同的职责，那么对其中一个职责的修改可能会影响到其他职责，从而导致系统的不稳定性。

## 开闭原则

**开闭原则（Open-Closed Principle，OCP）**，这个原则指出一个类应该对扩展开放，对修改关闭。也就是说，系统中的类应该能够方便地进行扩展，但是对于已经存在的类，尽量避免进行修改。这样可以减少代码的复杂性，提高系统的稳定性。



:::tip{title="提示"}
开闭原则需要避免过度设计，即在不必要的情况下进行扩展。同时，应该避免使用复杂的继承结构，而应该优先使用组合和接口实现扩展。
:::

## 里氏替换原则

**里氏替换原则（Liskov Substitution Principle，LSP）**，这个原则指出，如果一个子类不能完全替代它的父类，那么这个子类就不应该存在。换句话说，子类应该能够在不影响父类的前提下，完全替代父类的功能。这样才能保证系统的正确性和稳定性。



:::tip{title="提示"}
里氏替换原则需要注意继承关系的正确性。子类必须要遵循父类的约束，否则就会破坏LSP的原则。同时，在使用多态时需要注意类型的转换和类型检查的正确性。
:::

## 接口隔离原则

**接口隔离原则（Interface Segregation Principle，ISP）**，这个原则指出一个类不应该强制依赖它不需要的接口。如果一个类依赖了一个过于庞大的接口，那么当这个接口发生变化时，这个类也需要相应地进行修改。因此，一个类应该尽量只依赖于它需要的接口，避免不必要的依赖。

:::tip{title="提示"}
接口隔离原则需要避免接口的冗余和重复。接口应该根据不同的职责进行分离，避免一个接口承担过多的职责。同时，应该避免使用过于具体的接口，而应该优先使用更抽象的接口
:::

## 依赖反转原则

**依赖反转原则（Dependency Inversion Principle，DIP）**，这个原则指出，高层模块不应该依赖于低层模块，两者都应该依赖于抽象。同时，抽象不应该依赖于具体实现，具体实现应该依赖于抽象。这样可以减少系统的耦合度，提高系统的可扩展性和可维护性。

:::tip{title="提示"}
依赖反转原则需要注意依赖注入的方式和依赖倒置的层次。依赖注入应该使用构造函数注入、属性注入或方法注入，避免使用硬编码的依赖。同时，在依赖倒置时需要注意依赖的层次，避免高层模块依赖过于低层的模块。
:::

## 迪米特法则
**迪米特法则(Law of Demeter,LoD)也称为最少知识原则(Least Knowledge Principle,LKP)**。
迪米特法则要求一个对象应该只与其直接的朋友通信，而不是跟朋友的朋友或者更远的对象通信。对象之间的耦合度越低，系统的灵活性、可维护性、可扩展性就越好，同时也降低了代码的复杂度和风险。
:::tip{title="提示"}
迪米特法则需要注意：
- 将方法中的参数尽量缩小，尽量不引入不需要的对象。
- 在类的设计中，尽量降低对其他类的依赖。
- 将依赖其他类的操作放到一个中介类中，由中介类负责和其他类的通信。
:::

## 结论

SOLID原则是一种很好的软件设计指导原则，能够帮助开发者设计出易于维护和扩展的软件系统。但是，这些原则并不是银弹，需要根据具体的情况进行灵活运用。同时，在应用这些原则时需要注意细节和实现细节，才能真正达到SOLID原则的设计目标。

设计原则 --- SOLID

## 引言

### 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);
        }
        
    }
```