Git --- Git使用手册

## 引言
在WPF应用程序开发中，数据校验是确保用户输入数据的正确性和完整性的重要一环。

之前在做一些参数配置功能时，最是头疼各种参数校验，查阅一些资料后，我总结了数据校验方式有两种：
- ValidationRule
- IDataErrorInfo

接下来分别介绍这两种校验方式。



## ValidationRule
`ValidationRule` 是一个抽象类，提供了抽象方法 `Validate()`, 它是WPF中用于数据验证的一种机制，它可以在用户输入数据之前或之后执行自定义的验证逻辑。可以轻松地实现对数据的格式、范围、逻辑等方面的验证，并在验证失败时提供相应的反馈信息。

**ValidationRule主要作用域在前端页面上**。

### 基本用法
首先创建一个 `ValidationRule`，我这里设定了两个属性 `MaxVal`、`MinVal`，然后在 `Validate()` 方法中判断空、判断大于上限或小于下限，然后在符合条件是，返回 `ValidationResult`，并给出错误提示：


```csharp
public class IntegerValidationRule : ValidationRule
{
    public int MaxVal { get; set; }
    public int MinVal { get; set; }

    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        string text = value as string;

        if (!int.TryParse(text, out int result))
        {
            return new ValidationResult(false, "Text cannot be empty.");
        }

        if (result > MaxVal)
        {
            return new ValidationResult(false, "Value out of upper limit range.");
        }

        if (result < MinVal)
        {
            return new ValidationResult(false, "Value out of lower limit range.");
        }

        return ValidationResult.ValidResult;
    }
}

```
接下来创建有个测试使用的 `ViewModel`:


```csharp
public class TestViewModel : INotifyPropertyChanged
{
    private TestViewModel() { }

    public static TestViewModel Instance { get; } = new TestViewModel();

    public event PropertyChangedEventHandler? PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    private int testField1;
    /// <summary>
    /// 测试属性1
    /// </summary>
    public int TestField1
    {
        get => testField1;
        set
        {
            testField1 = value;
            OnPropertyChanged(nameof(TestField1));
        }
    }

    private int testField2;
    /// <summary>
    /// 测试属性2
    /// </summary>
    public int TestField2
    {
        get => testField2;
        set
        {
            testField2 = value;
            OnPropertyChanged(nameof(TestField2));
        }
    }
}


```

在测试之前，我们可以先看一下 `Binding` 的方法列表：

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

可以看到 **`ValidationRules` 是 `Binding` 下的集合，这意味着 `ValidationRule` 是在 `Binding` 下使用且可以执行多个校验规则。校验时按照顺序依次校验。**

接下来我们创建一个WPF应用程序，在界面添加 `TextBox`，命名为”textbox1“,将文本绑定在 `TestViewModel` 的 `TestField1`。

且为`Validation.ErrorTemplate` 绑定一个模板，这里绑定了一个红色的感叹号。

然后为 `TextBox` 设置触发器，当 `Validation.HasError`为 `true`时，将 `ToolTip` 绑定校验失败的错误提示。

代码如下：

```xml
<Window
    x:Class="WpfApp4.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:local="clr-namespace:WpfApp4"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    Title="MainWindow"
    Width="900"
    Height="450"
    mc:Ignorable="d">
    <Window.Resources>
        <ControlTemplate x:Key="ValidationTemplate">
            <DockPanel>
                <TextBlock
                    Margin="-10,0,0,0"
                    VerticalAlignment="Center"
                    FontSize="22"
                    Foreground="Red"
                    Text="!" />

            </DockPanel>
        </ControlTemplate>

        <Style TargetType="TextBox">
            <Style.Triggers>
                <Trigger Property="Validation.HasError" Value="true">
                    <Setter Property="ToolTip" Value="{Binding RelativeSource={RelativeSource Self}, Path=(Validation.Errors)[0].ErrorContent}" />
                </Trigger>
            </Style.Triggers>
        </Style>
    </Window.Resources>
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="1*" />
            <ColumnDefinition Width="1*" />
        </Grid.ColumnDefinitions>
        <StackPanel Grid.Column="0">
            <TextBlock
                HorizontalAlignment="Center"
                FontSize="18"
                FontWeight="Bold"
                Text="Validation Demo" />
            <TextBox
                Name="textBox1"
                Height="30"
                Margin="10"
                FontSize="22"
                Validation.ErrorTemplate="{StaticResource ValidationTemplate}">
                <TextBox.Text>
                    <Binding Path="TestField1" UpdateSourceTrigger="PropertyChanged">
                        <Binding.ValidationRules>
                            <local:IntegerValidationRule
                                MaxVal="999"
                                MinVal="5" />
                        </Binding.ValidationRules>
                    </Binding>
                </TextBox.Text>
            </TextBox>

        </StackPanel>
    </Grid>
</Window>

```
最后在窗体后台绑定 `ViewModel`:

```csharp
public MainWindow()
{
    InitializeComponent();
    this.DataContext =  TestViewModel.Instance;
}

```
### 测试

1. 为空时，出现红色叹号，`ToolTip` 提示 "Text cannot be empty."
![image.png](https://niuery.com/static/img/3dc5e4c153b087fc36f5ddcfb1e664fe.image.png)

2. 小于下限时，出现红色叹号，`ToolTip` 提示 "Value out of lower limit range."
![image.png](https://niuery.com/static/img/88d90b70aac9d55b46d151e4b5d0fdc8.image.png)

3. 大于上限时，出现红色叹号，`ToolTip` 提示 "Value out of upper limit range."
![image.png](https://niuery.com/static/img/762b62259b10fb28617ee49276105ca4.image.png)
## IDataErrorInfo

`IDataErrorInfo` 是一个接口，Viewmodel 实现接口用于在后台，提供数据验证和错误信息。

`IDataErrorInfo` 主要作用域为后台 `ViewModel`
该接口包含两个成员：`Error` 和 `this[string columnName]`。这两个成员允许你在数据绑定时提供验证错误信息。

### 基本用法

接下来，在程序里添加 `TextBox`，命名为”textbox2“，并添加一个 `TextBlock` 绑定 `Error` 展示在界面。
```xml
<StackPanel Grid.Column="1">
    <TextBlock
        HorizontalAlignment="Center"
        FontSize="18"
        FontWeight="Bold"
        Text="IDataErrorInfo Demo" />
    <TextBox
        Name="textBox2"
        Margin="10"
        VerticalAlignment="Center"
        FontSize="22"
        Text="{Binding TestField2, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />
     <TextBlock
         HorizontalAlignment="Center"
         FontSize="18"
         FontWeight="Bold"
         Foreground="Red"
         Text="{Binding Error, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
</StackPanel>
```

后台 `TestViweModel` 实现 `IDataErrorInfo`，依旧是判断上限值和下限值，此处不判断空，是因为后台 `TestField2` 类型是Int，为空时不会赋值，代码如下：

```csharp
public class TestViewModel : INotifyPropertyChanged, IDataErrorInfo
{
    //省略上文已有代码..。
    
    private string error;
    public string Error
    {
        get => error;
        set
        {
            error = value; OnPropertyChanged(nameof(Error));
        }
    }
    public string this[string columnName]
    {
        get
        {
            switch (columnName)
            {
                case nameof(TestField2):
                    return CheckTestFild2();
                default:
                    return null;
            }
        }
    }

    public int MaxVal = 999;
    public int MinVal = 5;

    private string CheckTestFild2()
    {
        if (TestField2 > MaxVal)
        {
            Error = "Value out of upper limit range in viewmodel.";
        }
        else if (TestField2 < MinVal)
        {
            Error = "Value out of lower limit range  in viewmodel.";
        }
        else
        {
            Error = string.Empty;
        }
        
        return Error;
    }
}
```
### 测试

1. 小于下限时，出现红色文字提示，`ToolTip` 提示 "Value out of lower limit range in viewmodel."
![image.png](https://niuery.com/static/img/2ba46191051264fd5998ce38c0c23e9d.image.png)

2. 大于上限时，出现红色文字提示，`ToolTip` 提示 "Value out of upper limit range in viewmodel."
![image.png](https://niuery.com/static/img/54e898c947d977e9e9c686bae9a1230b.image.png)

## 小结

以上两种数据校验（`IDataErrorInfo`、`ValidationRule`）的方式，均可以实现自定义数据校验，例如对数据的格式、范围、逻辑等方面的验证，并在验证失败时提供相应的反馈信息。

`ValidationRule`适用于在界面做数据校验，且可以定义多个校验规则。

`ValidationRule`适用于在ViewModel做数据校验，可以做一些无法在前端页面做的事情，比如出现异常值是还原为默认值。

所以两者既可以单独使用，也可以组合使用，即使使用MVVM模式，依旧能够优雅的做数据校验。

WPF --- TextBox的输入校验

## 介绍
![fodyIcon.png](https://niuery.com/static/img/a30cc6cdb0982b23487dbe8ad4786ced.fodyIcon.png)

这个项目的名称“Fody”来源于属于织巢鸟科（Ploceidae）的小鸟（[Fody](https://en.wikipedia.org/wiki/Fody)），本身意义为编织。

核心Fody引擎的代码库地址 ：https://github.com/Fody/Fody

Github上是这样介绍的：

**Fody** 是一个用于织制 `.NET` 程序集的可扩展工具。它允许在构建过程中作为一部分来操纵程序集的中间语言（IL），这需要大量的底层代码编写。这些底层代码需要了解 `MSBuild` 和 `Visual Studio` 的 `API`。`Fody` 通过可扩展的插件模型试图消除这些底层代码。这种技术非常强大，例如，可以将简单属性转换为完整的 `INotifyPropertyChanged` 实现，添加对空参数的检查，添加方法计时，甚至使所有字符串比较都不区分大小写。

**Fody** 处理的底层任务包括：
- 将 `MSBuild` 任务注入到构建流程中。
- 解析程序集和 `pdb` 文件的位置。
- 抽象了与 `MSBuild` 日志记录的复杂性。
- 将程序集和 `pdb` 文件读入 `Mono.Cecil` 对象模型中。
- 根据需要重新应用强名称。
- 保存程序集和 `pdb` 文件。


**Fody** 使用 `Mono.Cecil` 和基于插件的方法在编译时修改 `.NET` 程序集的中间语言（IL）。
- 它不需要额外的安装步骤来构建。
- 属性是可选的，具体取决于所使用的编织器。
- 不需要部署运行时依赖项。



## 插件
从介绍就可以看出，理论上只要你想要，基于这个库基本上能做任何事情。

所以基于该库，诞生了非常非常多的插件库，下面简单介绍及编写Demo简单使用

| 插件                      | 描述                                                         | Github URL                                           |
| ------------------------- | ------------------------------------------------------------ | ---------------------------------------------------- |
|**Fody**|编织.net程序集的可扩展工具|https://github.com/Fody/Fody|
| **AutoProperties.Fody**   | 这个外接程序为您提供了对自动属性的扩展控制，比如直接访问backing字段或拦截getter和setter。 | https://github.com/tom-englert/AutoProperties.Fody   |
| **PropertyChanged.Fody**  | 将属性通知添加到实现INotifyPropertyChanged的所有类。         | https://github.com/Fody/PropertyChanged              |
| **InlineIL.Fody**         | 在编译时注入任意IL代码。                                     | https://github.com/ltrzesniewski/InlineIL.Fody       |
| **MethodDecorator.Fody**  | 通过IL重写编译时间装饰器模式                                 | https://github.com/Fody/MethodDecorator              |
| **NullGuard.Fody**        | 将空参数检查添加到程序集                                     | https://github.com/Fody/NullGuard                    |
| **ToString.Fody**         | 给属性生成ToString()方法                                     | https://github.com/Fody/ToString                     |
| **Rougamo.Fody** | 在编译时生效的AOP组件，类似于PostSharp。 |https://github.com/inversionhourglass/Rougamo|

### AutoProperties.Fody

这个插件提供了对自动属性的扩展控制，比如直接访问backing字段或拦截getter和setter。

```csharp
using System;
using AutoProperties;
using Xunit;

public class AutoPropertiesInterceptor
{
    [Fact]
    public void Run()
    {
        Assert.Equal(10, Property1);
        Assert.Equal("11", Property2);

        Property1 = 42;

        Assert.Equal(45, Property1);
        Assert.Equal("11", Property2);

        Property2 = "44";

        Assert.Equal(45, Property1);
        Assert.Equal("47", Property2);
    }

    [GetInterceptor]
    T GetInterceptor<T>(string propertyName, T fieldValue)
    {
        return (T)Convert.ChangeType(Convert.ToInt32(fieldValue) + 1, typeof(T));
    }

    [SetInterceptor]
    void SetInterceptor<T>(T value, string propertyName, out T field)
    {
        field = (T)Convert.ChangeType(Convert.ToInt32(value) + 2, typeof(T));
    }

    public int Property1 { get; set; } = 7;

    public string Property2 { get; set; } = "8";
}

```

### PropertyChanged.Fody

该插件在编译时将INotifyPropertyChanged代码注入属性中：

```csharp
using System.ComponentModel;
using System.Runtime.CompilerServices;
using AutoProperties;
using Xunit;

public class AutoPropertiesSample : INotifyPropertyChanged
{
    int numberOfPropertyChangedCalls;

    public string AutoProperty1 { get; set; }
    public string AutoProperty2 { get; set; }

    public AutoPropertiesSample()
    {
        AutoProperty2.SetBackingField("42");
    }

    [Fact]
    public void Run()
    {
        // no property changed call was generated in constructor:
        Assert.Equal(0, numberOfPropertyChangedCalls);
        Assert.Equal("42", AutoProperty2);

        AutoProperty1 = "Test1";
        Assert.Equal(1, numberOfPropertyChangedCalls);
        Assert.Equal("Test1", AutoProperty1);

        AutoProperty1.SetBackingField("Test2");
        Assert.Equal(1, numberOfPropertyChangedCalls);
        Assert.Equal("Test2", AutoProperty1);
    }


    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        numberOfPropertyChangedCalls += 1;

        PropertyChanged?.Invoke(this, new(propertyName));
    }
}


```


除此之外，该插件附带了一个 C# 代码生成器，只需将实现 INotifyPropertyChanged 接口或包含  `[AddINotifyPropertyChangedInterface]` 属性的类标记为 partial，生成器将会自动添加必要的事件和事件触发器。

可以通过项目文件中的属性配置代码生成器：

```xml
<PropertyGroup>
  <PropertyChangedAnalyzerConfiguration>
    <IsCodeGeneratorDisabled>false</IsCodeGeneratorDisabled>
    <EventInvokerName>OnPropertyChanged</EventInvokerName>
  </PropertyChangedAnalyzerConfiguration>
</PropertyGroup>
```
更多用法建议查看官方文档。

### InlineIL.Fody

该插件允许在编译时将任意IL注入到程序集中。

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

示例代码
```csharp
using System;
using Xunit;
using static InlineIL.IL.Emit;
public class Sample
{
    [Fact]
    public void Run()
    {
        var item = new MyStruct
        {
            Int = 42,
            Guid = Guid.NewGuid()
        };

        ZeroInit.InitStruct(ref item);

        Assert.Equal(0, item.Int);
        Assert.Equal(Guid.Empty, item.Guid);
    }

    struct MyStruct
    {
        public int Int;
        public Guid Guid;
    }
}

public static class ZeroInit
{
    public static void InitStruct<T>(ref T value)
        where T : struct
    {
        Ldarg(nameof(value));

        Ldc_I4_0();

        Sizeof(typeof(T));

        Unaligned(1);

        Initblk();
    }
}

```

小技巧：这里可以借助ILDASM工具先生成想要的 `IL` 代码，在按照 `IL` 代码取编写要注入的 C# 代码，也可以参照我之前的文章[工具 --- IL指令集解释](https://niuery.com/post/61)，理解 `IL` 执行过程。

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

### MethodDecorator.Fody

通过IL重写编译时装饰器模式。

定义拦截器属性：

```csharp
using System;
using System.Reflection;
using MethodDecorator.Fody.Interfaces;

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Module)]
public class InterceptorAttribute : Attribute, IMethodDecorator
{
    public void Init(object instance, MethodBase method, object[] args)
    {
    }

    public void OnEntry()
    {
        InterceptionRecorder.OnEntryCalled = true;
    }

    public void OnExit()
    {
        InterceptionRecorder.OnExitCalled = true;
    }

    public void OnException(Exception exception)
    {
        InterceptionRecorder.OnExceptionCalled = true;
    }
}

```
定义拦截记录器

```csharp
public static class InterceptionRecorder
{
    public static bool OnEntryCalled;
    public static bool OnExitCalled;
    public static bool OnExceptionCalled;

    public static void Clear()
    {
        OnExitCalled= OnEntryCalled = OnExceptionCalled = false;
    }
}
```

定义目标类


```csharp
public static class Target
{
    [Interceptor]
    public static void MyMethod()
    {

    }

    [Interceptor]
    public static void MyExceptionMethod()
    {
        throw new("Foo");
    }
}
```

示例：


```csharp
using Xunit;

public class MethodDecoratorSample
{
    [Fact]
    public void SimpleMethodSample()
    {
        InterceptionRecorder.Clear();
        Target.MyMethod();
        Assert.True(InterceptionRecorder.OnEntryCalled);
        Assert.True(InterceptionRecorder.OnExitCalled);
        Assert.False(InterceptionRecorder.OnExceptionCalled);
    }

    [Fact]
    public void ExceptionMethodSample()
    {
        InterceptionRecorder.Clear();
        try
        {
            Target.MyExceptionMethod();
        }
        catch
        {
        }
        Assert.True(InterceptionRecorder.OnEntryCalled);
        Assert.False(InterceptionRecorder.OnExitCalled);
        Assert.True(InterceptionRecorder.OnExceptionCalled);
    }
}

```


### NullGuard.Fody

该插件向程序集添加null参数检查，支持三种操作模式：**隐式模式**、**显式模式**和**可为空引用类型模式**。

- 在隐式模式下，假定一切都不为空，除非标记为 [AllowNull]。这是 NullGuard 一直以来的工作方式。
- 在显式模式下，假定一切都可为空，除非标记为 [NotNull]。这种模式旨在支持 ReSharper（R#）的可为空性分析，使用悲观模式。
- 在可为空引用类型模式下，使用 C# 8 可为空引用类型（NRT）注释来确定类型是否可为空。


如果没有显式配置，NullGuard 将按以下方式自动检测模式：

- 如果检测到 C# 8 可为空属性，则使用可为空引用类型模式。
- 引用 JetBrains.Annotations 并在任何地方使用 [NotNull] 将切换到显式模式。
- 如果不满足上述条件，则默认为隐式模式。

示例：

```csharp
using Xunit;

public class NullGuardSample
{
    [Fact(Skip = "Explicit")]
    public void Run()
    {
        var targetClass = new TargetClass();
        Assert.Throws<ArgumentNullException>(() => targetClass.Method(null));
    }
}

public class TargetClass
{
    public void Method(string param)
    {
    }
}

```

### ToString.Fody

该插件可以从带有[ToString]属性修饰的类的公共属性中生成ToString方法。

```csharp
using System.Diagnostics;
using Xunit;

public class ToStringSample
{
    [Fact]
    public void Run()
    {
        var target = new Person
                     {
                         GivenNames = "John",
                         FamilyName = "Smith"

                     };
        Debug.WriteLine(target.ToString());
        Assert.Equal("{T: \"Person\", GivenNames: \"John\", FamilyName: \"Smith\"}", target.ToString());
    }
}

[ToString]
class Person
{
    public string GivenNames { get; set; }
    public string FamilyName { get; set; }

    [IgnoreDuringToString]
    public string FullName => $"{GivenNames} {FamilyName}";
}

```
### Rougamo.Fody
Rougamo是一个静态代码织入的AOP组件，类似Postsharp的一个组件，具有 **MethodDecorator.Fody**的功能，但功能更加强大，我个人觉得最为突出，优秀的两个功能点：
- 匹配
- 编织

匹配指的是命中AOP要拦截的目标匹配，比如有特征匹配，表达式匹配，类型匹配，更细化到模糊匹配，正则匹配。

编制则指的是拦截后能做的操作，比如有重写方法参数，修改返回值，异常处理，重试等。

该插件很强大，示例代码太多，就不再本篇内列出示例代码，官方文档中文介绍非常详细，建议直接查看官方文档。

### 其他

在Github库中，它提供了一些插件使用的Demo，除以上简单介绍的部分插件以外，还有这些
```xml
<Weavers VerifyAssembly="true"
         VerifyIgnoreCodes="0x80131869"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="FodyWeavers.xsd">
 
  <Anotar.Catel />
  <Anotar.Splat />
  <Anotar.Serilog />
  <Anotar.NLog />
  <Anotar.Custom />
  <Anotar.CommonLogging />
  <AsyncErrorHandler />
  <BasicFodyAddin />
  <Caseless />
  <ConfigureAwait  ContinueOnCapturedContext="false" />
  <EmptyConstructor />
  <ExtraConstraints />
  <Equatable />
  <InfoOf />
  <Ionad />
  <Janitor />
  <MethodTimer />
  <ModuleInit />
  <Obsolete />
  <PropertyChanging />
  <PropertyChanged />
  <Validar />
  <Resourcer />
  <Publicize />
  <Virtuosity />
  <Visualize />
</Weavers>
```

若是在 `Visual Studio` 的 `NuGet` 管理器中搜索 `Fody` 相关包，会有更多的一些三方或者小众的库，依旧值得尝试。


## 小结

从 `Fody` 实现原理上就能看出，这个库**强**，**很强**，**非常强**。加上现在已有的非常之多的插件，除了能够提升开发效率之外，以在一定程度上实现一些难以实现的功能。强烈推荐大家学习使用。


>参考
>
> Fody官方Demo：https://github.com/Fody/FodyAddinSamples
> 
> 工具 --- IL指令集解释：https://niuery.com/post/61

IL编制器 --- Fody

## 引言

面试中，常会问道，在大数据量的字符串拼接情况，为什么 `StringBuilder` 性能比直接字符串拼接更好？

主要原因就是 `string` 是不可变类型，每次操作都会创建新的字符串对象，频繁操作会导致内存频繁的分配和回收，就会降低性能， 而 `StringBuilder` 是可变类型，它允许对字符串进行原地修改，无需每次都创建新对象，其内部使用一个缓冲区来存储字符，可以高效地执行字符串操作，如添加、插入、删除等。

面试题就不多说了，既然这里已经提到了字符串性能，那我们来说一说保证字符串的性能、内存效率和安全性的两大门神：

- 字符串的不可变性
- 字符串驻留池


## 原理与关系
C# 中的字符串驻留池（**String Interning Pool**）是一个关键的内存管理概念，旨在提高字符串的性能和内存效率。字符串驻留池是一个特殊的内存区域，用于存储字符串字面值的唯一实例，以减少内存使用和提高性能。

### 字符串字面值

字符串字面值是指由双引号括起来的字符序列，比如："Hello, World!"。字符串字面值通常用于声明字符串变量或进行字符串操作。这些字符串字面值在编译时被解析，并根据它们的值存储在内存中。

下面声明了两个字符串字面值：
```csharp
 String s1 = "hello";
 String s2 = "world";
```


### 字符串不可变性

字符串不可变，这意味着一旦创建，字符串的内容不能被更改。这种不可变性是为了确保字符串的安全性和可靠性。当你对字符串进行操作时，实际上是创建了新的字符串对象，而原始字符串保持不变。这对于多线程和内存管理非常重要。

```csharp
string originalString = "Hello, World!"; // 创建一个字符串

Console.WriteLine("原始字符串：" + originalString);

// 尝试修改字符串内容
// 下面的行将引发编译错误，因为字符串是不可变的
// originalString[0] = 'M';

// 创建新字符串而不是修改原始字符串
string newString = originalString.Replace('H', 'M');
Console.WriteLine("修改后的字符串：" + newString);

Console.WriteLine("原始字符串：" + originalString); // 原始字符串不受影响

Console.WriteLine(object.ReferenceEquals(originalString, newString)); // 不是同一对象
```
上述代码输出：

```csharp
原始字符串：Hello, World!
修改后的字符串：Mello, World!
原始字符串：Hello, World!
False
```

### 字符串驻留池的工作原理

字符串驻留池的核心概念是确保具有相同值的字符串在内存中只有一个实例。它的工作原理如下：

1. **字符串字面值的存储**：当你在代码中使用字符串字面值时，编译器会将这些字符串字面值存储在字符串驻留池中。这是编译时操作，而不是运行时操作。

2. **检查字符串值**：在创建字符串字面值时，编译器会首先检查字符串池，看是否已经存在具有相同值的字符串。如果存在，编译器会返回对现有字符串的引用，而不是创建一个新的字符串对象。

3. **共享相同的实例**：如果多个字符串字面值具有相同的值，它们会共享相同的内存实例，从而节省内存。这意味着即使你多次创建相同值的字符串，实际上它们指向的是相同的内存位置。

4. **不可变性的重要性**：字符串的不可变性是字符串驻留池的基础。因为字符串是不可变的，共享字符串实例不会导致数据损坏或不一致性。

### 字符串驻留池的优点

字符串驻留池的存在带来了多个重要优点：

1. **内存节省**：由于字符串驻留，相同的字符串值只需存储一次，减少了内存使用。这对于大规模应用程序和处理大量文本数据尤为重要。

2. **性能提升**：由于字符串共享相同的实例，比较字符串的相等性变得更快速，因为可以直接比较引用，而不必比较字符串的内容。

3. **可靠性**：字符串驻留池有助于确保字符串数据的一致性。如果多个部分使用相同的字符串值，它们将引用相同的实例，从而避免数据不一致性。

4. **简化代码**：开发人员可以放心地使用字符串字面值，而不必担心内存管理。这使得代码更简洁和易于维护。

### 使用字符串驻留池

通常情况下，你不需要手动管理字符串驻留池，因为C#编译器和运行时会自动处理字符串的驻留。这意味着当你声明多个相同值的字符串时，它们将共享相同的内存实例，无需任何额外的代码。

```csharp
string s1 = "Hello";
string s2 = "Hello";

Console.WriteLine(object.ReferenceEquals(s1, s1)); //输出True
```

然而，如果你需要显式地将一个字符串添加到字符串驻留池中，可以使用`string.Intern()`方法：

```csharp
 string s1 = "Hello";
 string s2 = "World";
 // 手动将字符串s2添加到字符串驻留池
 string internedString = string.Intern(s2);
 // 现在s2和internedString都指向相同的字符串对象
 Console.WriteLine(object.ReferenceEquals(s2, internedString));   //输出True

```
### 两者关系

字符串的不可变性和字符串驻留池之间存在紧密的关系，它们共同作用于C#中的字符串处理和内存管理。
这两个概念之间的关系在以下方面体现：

- **内存共享**：由于字符串的不可变性，可以安全地在字符串之间共享内存实例。字符串的不可变性确保了多个字符串可以指向相同的内存位置，而不必担心数据被修改。字符串驻留池利用这一点，确保相同值的字符串字面值共享相同的内存。

- **性能和内存优化**：由于字符串不可变且字符串驻留池的存在，比较字符串的相等性变得更加高效，因为可以直接比较引用而不必比较字符串内容。这提高了字符串操作的性能，同时减少了内存使用，因为相同值的字符串只需存储一次。

- **共享和复用**：字符串不可变性和字符串驻留池的结合使得相同的字符串字面值可以被多个部分共享和复用，从而减少了内存开销。这对于具有重复字符串值的大型应用程序和处理大量文本数据的情况尤其有益。

## 总结

综上所述，字符串的不可变性和字符串驻留池共同提高了C#中字符串的性能、内存效率和安全性，使得多个部分可以共享相同值的字符串实例，同时确保字符串的内容不会被无意修改。这些概念在C#中的字符串处理中发挥着关键作用。

字符串 --- 不可变性与驻留池

##  介绍



### 一、MQTT简介

**MQTT（Message Queuing Telemetry Transport）** 是一种轻量级的消息传输协议，通常用于在物联网（IoT）和传感器网络中进行通信。它设计用于在低带宽、不稳定或高延迟的网络环境下传输数据，因此非常适用于连接设备之间的通信，尤其是在资源有限的环境中。

MQTT 的主要特点包括以下几点：

1. 轻量级：MQTT 协议本身非常简洁，消息头部占用较少的带宽，使其在低带宽网络中运行效率高。

2. 发布/订阅模型：MQTT 使用发布/订阅模型，其中客户端可以订阅特定的主题（Topic），并接收与该主题相关的消息。发布者发布消息到特定主题，然后所有订阅了该主题的客户端都将收到该消息。

3. 可靠性：MQTT 支持三种不同级别的消息传输质量，包括最多一次、至少一次和仅一次传输，可根据应用需求选择合适的级别。

4. 持久会话：MQTT 允许客户端建立持久会话，以便在连接丢失后重新连接时能够恢复之前的订阅和消息传递状态。

5. QoS（Quality of Service）：MQTT 提供不同的 QoS 级别，以确保消息的可靠传递。这包括 QoS 0（最多一次传输）、QoS 1（至少一次传输）和 QoS 2（仅一次传输）。

6. 适应性：MQTT 可以在多种网络协议上运行，包括 TCP/IP、WebSocket 和其他协议。

总之，MQTT 是一种非常适合物联网和传感器网络的通信协议，因其轻量级和高效的特性而受到广泛应用。它允许设备之间实时地交换信息，从而支持各种应用，包括智能家居、工业自动化、农业监测等。

### 二、MQTT 的 QoS 机制

什么是 QoS 机制？（https://www.emqx.com/zh/blog/introduction-to-mqtt-qos）

很多时候，使用 MQTT 协议的设备都运行在网络受限的环境下，而只依靠底层的 TCP 传输协议，并不能完全保证消息的可靠到达。因此，MQTT 提供了 QoS 机制，其核心是设计了多种消息交互机制来提供不同的服务质量，来满足用户在各种场景下对消息可靠性的要求。

MQTT 定义了三个 QoS 等级，分别为：

- QoS 0，最多交付一次。
- QoS 1，至少交付一次。
- QoS 2，只交付一次。

其中，使用 QoS 0 可能丢失消息，使用 QoS 1 可以保证收到消息，但消息可能重复，使用 QoS 2 可以保证消息既不丢失也不重复。QoS 等级从低到高，不仅意味着消息可靠性的提升，也意味着传输复杂程度的提升。

## MQTT 的.Net 库 --- MQTTnet

MQTTnet是一个开源的用于基于MQTT的通信的高性能.NET库。它提供了一个MQTT客户端和一个MQTT服务器（代理），并支持MQTT协议，直到版本5。它与大多数受支持的.NET兼容框架版本和CPU体系结构。

Guthub地址： https://github.com/dotnet/MQTTnet

MQTTnet通过NuGet软件包管理器交付。可以在这里找到软件包：https://www.nuget.org/packages/MQTTnet/

在Visual Studio中，在Package Manager控制台中使用以下命令手动安装MQTTnet:

```shell
Install-Package MQTTnet
```

可以通过GitHub上直接查看Demo源码，或者下载源码后使用Visual Studio打开，它提供了多个`Samples` ，每个`Samples`下有不同的相关方法，有以下几类：

- Client_Connection_Samples ---
- Client_Publish_Samples
- Client_Subscribe_Samples
- Logger_Samples
- Managed_Client_Simple_Samples
- PackageInspection_Samples
- RpcClient_Samples
- Server_ASP_NET_Samples
- Server_Diagnostics_Samples
- Server_Intercepting_Samples
- Server_Retained_Messages_Samples
- Server_Simple_Samples
- Server_TLS_Samples

可以下载源码编译，运行起来后如下：


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

## Windows下MQTT消息服务器的安装使用

一般，常见的MQTT服务器软件有：

- **Mosquitto** - 流行的开源MQTT服务器，但是没有可视化界面，需要借助其他工具才可以可视化。

- **EMQX** - 强大的开源MQTT服务器，有可视化界面。

- **HiveMQ**  - HiveMQ 是一个商业的MQTT服务器，提供免费的开发者版。

这里推荐使用EMQX ，它提供了可视化界面，以便更容易地配置、管理和监控MQTT服务器。

### 一、下载EMQX

EMQX 官网提供了丰富的文档，Quick Start 地址：https://www.emqx.io/docs/zh/v5.2/

这里不建议安装最新版本，建议降低版本，若安装最新版本 emqx-5.3.0-windows-amdx64，则会启动异常，如下所示：


![image.png](https://niuery.com/static/img/942aabe7d0f36e4de5fdc40513b5283d.image.png)
本次测试使用 [emqx-4.4.19-otp24.3.4.6-windows-amd64](https://www.emqx.com/en/downloads/broker/4.4.19/emqx-4.4.19-otp24.3.4.6-windows-amd64.zip) 版本，如下：


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

按照官网教程，进入到安装目录/emqx/bin 下，使用以下指令启动EMQX ：

```shell
emqx start
```

### 二、启动EMQX 服务

EMQX 常用启动命令：

| **命令**   | **描述**                                                     |
| ---------- | ------------------------------------------------------------ |
| start      | 以守护进程模式启动 EMQX，运行期间不需要交互式 shell。        |
| console    | 在 Erlang 或 Elixir 交互式 shell 中启动 EMQX。用于在开发环境中调试 EMQX，需要与 EMQX 进行交互。 |
| foreground | 在前台模式下启动 EMQX，不使用交互式 shell。用于在开发环境中启动 EMQX，但不需要后台运行。 |
| stop       | 停止运行中的 EMQX 节点。                                     |
| ctl        | 管理和监控 EMQX，执行 `emqx ctl help` 可以获取更多详细信息。 |

EMQX 常用ctl命令：

| **命令**      | **描述**                                                     |
| ------------- | ------------------------------------------------------------ |
| status        | 快速查看当前运行的节点是否运行。                             |
| broker        | 查看当前节点的运行的版本状态以及运行时长。                   |
| observer      | 可以用于查看运行时状态。展示一个类似于 linux 的 `top` 命令的界面。 |
| admins        | 用于创建、修改、删除管理员账户。                             |
| clients       | 查看和管理客户端。                                           |
| topics        | 查看当前系统中所有订阅的主题。                               |
| subscriptions | 查看、增加或者删除某个客户端的订阅。                         |

### 三、EMQX Dashboard

EMQX Dashboard 是EMQX内置的Web 应用程序，它支持查看运行中的 EMQX 集群的整体连接数，订阅主题数，消息收发数量和流入流出速率，还包括节点列表和节点信息和一些系统指标信息，同时也可以对一些客户端连接与订阅数据进行查看与管理`。`

如果 EMQ 安装在本机，则使用浏览器打开地址 [http://127.0.0.1:18083](http://127.0.0.1:18083/) ，输入默认用户名 `admin` 与默认密码 `public` ，登录进入 Dashboard，如下图：


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


如果忘记了 Dashboard 登录密码，可以通过 cli 的 `admins` 命令进行重置，详情请参考 [命令行 - admins](https://www.emqx.io/docs/zh/v5.2/admin/cli.html#admins)：

```sh
./bin/emqx ctl admins passwd <Username> <Password>
```

###  四、MQTTX Desktop

[MQTTX 客户端](https://www.emqx.io/docs/zh/v5.2/messaging/publish-and-subscribe.html#mqttx)是一款跨平台的 MQTT 桌面客户端工具。它提供用户友好的图形界面，让用户可以快速创建、测试 MQTT 连接，并进行MQTT 消息的发布和订阅。下载地址：https://mqttx.app/zh/downloads 界面如下图：


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


## 客户端代码编写

### 一、准备工作

接下来 我们使用MQTTnet，编写服务端和客户端测试一下：

1. 新建控制台项目，添加MQTTnet库。

2. 按照上文中命令启动EMQX服务

3. 使用MQTTX Desktop，设置 **host** 为`localhost` ，**prot** 为 `1883` ，连接服务，如下图：


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

### 二、代码编写

这样准备工作就做好了，编写创建发布客户端代码，如下：

```c#
public static async Task CreatePublishMQTTClient()
{
    try
    {
        MqttFactory mqttFactory = new MqttFactory();

        var mqttClient = mqttFactory.CreateMqttClient();

        var mqttClientOptions = new MqttClientOptionsBuilder()
            .WithTcpServer("localhost", 1883)
            .WithClientId("Client1")
            .Build();
        var connectResult = await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);

        Console.WriteLine("mqttClient connectResult: " + connectResult.ResultCode.ToString());

        while (true)
        {
            var msg = Console.ReadLine();

            string topic = "testtopic/publish";
            string payload = $"{msg} {DateTime.Now:yyyy-MM-dd HH:mm:ss:fff}"; // 消息内容

            var message = new MqttApplicationMessageBuilder()
                .WithTopic(topic)
                .WithPayload(payload)
                .WithQualityOfServiceLevel(MqttQualityOfServiceLevel.AtLeastOnce) // 设置消息质量
                .WithRetainFlag(false) // 是否保留消息
                .Build();

            await mqttClient.PublishAsync(message, CancellationToken.None);
        }

    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.ToString());
    }
}

```

接下来再编写一个订阅客户端代码：

```c#
public static async Task CreateSubscribeMQTTClient()
{
    try
    {
        MqttFactory mqttFactory = new MqttFactory();

        var mqttClient = mqttFactory.CreateMqttClient();

        var mqttClientOptions = new MqttClientOptionsBuilder()
            .WithTcpServer("localhost", 1883)
            .WithClientId("Client1")
            .Build();


        mqttClient.ApplicationMessageReceivedAsync += (e) =>
        {
            Task task = Task.Factory.StartNew(() =>
            {
                var msgArray = e.ApplicationMessage.Payload;
                string result = Encoding.UTF8.GetString(msgArray);
                Console.WriteLine("Received: " + result);
            });

            return task;
        };

        var connectResult = await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);

        Console.WriteLine("mqttClient connectResult: " + connectResult.ResultCode.ToString());

        string topic = "testtopic/subscribe";

        var subscribeOptions = new MqttClientSubscribeOptionsBuilder()
            .WithTopicFilter(topic)
            .Build();

        await mqttClient.SubscribeAsync(subscribeOptions);

    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.ToString());
    }
}

```

接下来编写控制台Main方法，由于MQTT Client方法是异步的，所以为了避免控制台退出，在调用方法后，增加了一个`While` 死循环保证控制台程序是激活状态，代码如下：

``` c#
static void Main(string[] args)
{
    Console.WriteLine("Choose a creation type: \r\n 1: PublishClient\r\n 2: SubscribeClient");
    var type = Console.ReadLine();
    switch (type)
    {
        case "1":
            _ = CreatePublishMQTTClient();
            break;
        case "2":
            _ = CreateSubscribeMQTTClient();
            break;

    }
    while (true) Thread.Sleep(1000);
}

```

### 三、测试

先测试发布客户端，在控制台选择PublishClient，然后等待连接，可以看到连接结果为Success，发送两条测试消息，可以看到MQTTX Desktop 均收到。


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

接下来测试订阅客户端，在控制台选择SubscribeClient，然后等待连接，可以看到连接结果为Success，在MQTTX Desktop 发布一条消息给订阅客户端，可以看到控制台程序中，接收到了测试消息。


![image.png](https://niuery.com/static/img/4536c15b406035365da3c60e88cff917.image.png)
## 总结

总的来说， 使用C#编写 MQTT相关代码的资料还是比较少的，但好在官方文档足够详细，今天试玩一下还是花费不少功夫的。本篇文章作抛砖引玉，浅浅了解MQTT这个轻量级的通讯协议，在辅以Demo加深理解，熟悉如何使用，文章末尾也提供诸多参考文章，方便大家借鉴学习。



> 参考链接
>
> MQTTnet Guthub地址： https://github.com/dotnet/MQTTnet
>
> MQTT 入门指南：https://www.emqx.com/zh/mqtt-guide
>
> EMQX 官方文档：https://www.emqx.io/docs/zh/v5.2/
>
> EMQX 命令行文档：https://www.emqx.io/docs/zh/v5.2/admin/cli.html
>
> EMQX 配置手册：https://www.emqx.io/docs/zh/v5.2/configuration/configuration-manual.html
>
> EMQX基础功能： https://juejin.cn/post/7081629128650129416
> 
> MQTTX 客户端下载：https://mqttx.app/zh/downloads

git是什么

引言

介绍

引言

介绍