## 引言

**Task**和**ValueTask**都是用于异步编程的类型。它们都表示一项异步操作的结果，并可以在操作完成后检索该结果。

Task是.NET Framework中异步编程模型（APM）的核心类型之一。它是一个通用类型，可表示任何类型的异步操作。通过使用Task，您可以开始执行异步操作并返回一个表示该操作的任务，然后可以等待该任务以获取操作结果。Task还提供了各种方法来管理任务的执行，例如等待多个任务完成、取消任务等等。

ValueTask与Task不同，ValueTask是一个值类型，而不是一个引用类型。在创建和处理ValueTask时，不需要分配额外的堆内存。如果异步操作非常快速并且几乎总是同步完成，则ValueTask可能比Task更有效率。但是，对于较长时间运行的异步操作，使用ValueTask可能会导致性能下降，因为它可能需要分配堆内存来存储大量的状态信息。





> 参考资料
> 
> [1] https://devblogs.microsoft.com/dotnet/understanding-the-whys-whats-and-whens-of-valuetask/
> 
> [2] https://rubikscode.net/2018/06/11/asynchronous-programming-in-net-benefits-and-tradeoffs-of-using-valuetask/
> 
> [3] https://blog.scooletz.com/2018/05/14/task-async-await-valuetask-ivaluetasksource-and-how-to-keep-your-sanity-in-modern-net-world/

解读 --- Task、ValueTask

## 引言

**表达式树(Expression Tree)** 是C#中的一个重要概念。它可以表示代码中的表达式，比如函数调用、算数运算等。
表达式树允许我们在运行时对表达式进行解释执行、转换和编译。可以用于创建动态查询、编码 LINQ 表达式、序列化代码等。

解读 --- Expression表达式树

## 引言

`Span<T>` 是C# 中的一种结构体，它是一种内存安全的类型，可以用来表示连续的内存区域。`Span<T>` 可以被用于访问和操作数组、堆上分配的内存和栈上分配的内存。使用 `Span<T>` 可以避免不必要的内存拷贝，从而提高性能。
    
    

## 对数组使用Span

如果需要快速访问托管或非托管的连续内存，可以使用 `Span<T>`结构。`Span<T>` 结构表示存储连续的内存。所以使用它的数据结构一般也使用连续的内存。例如：
- 数组
- 长字符串(实际上也是数组)

**使用 `Span<T>`，可以直接访问数组元素。且数组的元素不会复制，可以直接使用它们，这样比复制效率要高**。例如下面的代码：

```csharp
static void Main(string[] args)
{
    int[] source = new int[] { 1, 2, 3 };

    int[] arr = new int[] { source[0], source[1], source[2] };
    
    arr[0] = 33;
    
    Console.WriteLine($"The first element of source is {source[0]}");
    Console.WriteLine($"The first element of arr is {arr[0]}");

    Span<int> span = new(source);
    
    span[0] = 11;
    
    Console.WriteLine($"The first element of source is {arr[0]}");
    Console.WriteLine($"The first element of span is {span[0]}");
    
    Console.ReadLine();
}
```
可以先猜测以下上述代码的输出是什么？

输出：
```csharp
The first element of source is 1
The first element of arr is 33
The first element of source is 11
The first element of span is 11
```

上述代码段中，先声明了一个源数组 `source` 和一个数组 `arr` ,并将 `source` 的值复制给 `arr` 。然后修改 `arr` 中的第一个元素值为33，可以看到结果 `arr` 的第一个元素已经改变为33，`source` 保持不变。然后又声明了一个 `Span<int>` ，它引用 `source` 数组。因为`Span<T>`是直接访问数组元素，而不是复制元素，所以修改 `span` 中的第一个元素为11， `source` 中的第一个元素也被修改为11。

## 创建切片

`Span<T>` 的一个强大特性是，可以使用它访问数组的部分或切片。使用切片时，不会复制数组元素，它们是从span 中直接访问的。

有如下代码段：

```csharp
static void Main(string[] args)
{
    int[] source = { 1, 6, 23, 76, 88, 213 };
    
    Span<int> span1 = new Span<int>(source, start: 1, length: 4);
    
    Span<int> span2 = span1.Slice(start: 1, length: 3);
    
    DisplaySpan("span1 contains the elements:", span1);
    
    DisplaySpan("span2 contains the elements:", span2);
    
    Console.ReadLine();
}

private static void DisplaySpan(string content, Span<int> span1)
{
    Console.Write(content);
    
    foreach (var item in span1)
    {
        Console.Write(item + ",");
    }
    
    Console.WriteLine();
}
```

下面的代码片段展示了创建切片的两种方法。
1.  除默认构造函数传参数组之外，另一种重载是直接使用构造函数传递源数组，起始位置和长度。例如上述代码中 `new Span<int>(source, start: 1, length: 4)` 它表示在源数组中从第2个元素开始访问数组的4个元素。
2. 直接从span中再次切片，传入起始位置和长度，例如上述代码中`span1.Slice(start: 1, length: 3)`表示从span1中第2个元素开始包含3个元素的切片。

输出：

```csharp
span1 contains the elements:6,23,76,88,
span2 contains the elements:23,76,88,
```


这里使用时一定注意传入参数 `start` 和 `length` 后的越界问题。

## 使用Span改变值

在文章开头，介绍了如何使用 `Span<T>` 的索引器，直接更改由 span 直接引用的数组元素，实际上它还有其他改变值的方法。

例如：

- `Slice(int start, int length)`：返回一个新的 `Span<T>`，它表示从 `Span<T>` 的指定起始位置开始的指定长度部分。可以使用该方法来获取或更改 `Span<T>` 中的子集。

- `Clear()`：将 `Span<T>` 中的所有元素设置为默认值 `default<T>`。 

- `Fill(T value)`：将 `Span<T>` 中的所有元素设置为指定的值。

- `CopyTo(Span<T> destination)`：将 `Span<T>` 中的所有元素复制到指定的目标 `Span<T>`。

- `CopyTo(T[] destination)`：将 `Span<T>` 中的所有元素复制到指定的目标数组。

- `Reverse()`：反转 `Span<T>` 中的元素顺序。

- `Sort()`：对 `Span<T>` 中的元素进行排序。

请注意，这些方法都是按值传递的，而不是按引用传递的。这意味着在调用这些方法时，将复制 `Span<T>` 中的值。如果您想要修改原始 `Span<T>` 中的值，请使用引用传递方式，例如使用 `ref Span<T>` 参数。


## 只读的Span
如果只需要对数组片段进行读访问，则可以使用 `ReadOnlySpan<T>`,可以使用它来读取内存块中的数据，而不必担心其他代码同时修改了该内存块。

对于 `ReadOnlySpan<T>` ，它的索引器是只读的，所以这种类型没有提供 `Clear` 和 `Fill` 方法，但是可以调用 `CopyTo()` 方法，将 `ReadOnlySpan<T>` 的内容复制到 `Span<T>` 。

此外，它支持隐式转换，由数组或 `Span<T>` 直接赋值给 `ReadOnlySpan<T>`，如下：

```csharp
static void Main(string[] args)
{
    int[] source = { 1, 6, 23, 76, 88, 213 };

    Span<int> span = new Span<int>(source);

    DisplaySpan("span contains the elements:", span);

    ReadOnlySpan<int> readOnlySpan = source;

    DisplaySpan("readOnlySpan contains the elements:", readOnlySpan);

    Console.ReadLine();
}

private static void DisplaySpan(string content, ReadOnlySpan<int> span1)
{
    Console.Write(content);

    foreach (var item in span1)
    {
        Console.Write(item + ",");
    }

    Console.WriteLine();
}
```
输出：

``` csharp
span contains the elements:1,6,23,76,88,213,
readOnlySpan contains the elements:1,6,23,76,88,213,
```

与 `Span<T>` 相比，`ReadOnlySpan<T>` 的一个重要的限制是不允许修改其包含的内存块。这使得 `ReadOnlySpan<T>` 更适合于读取内存块中的数据，而不是修改它们。

解读 --- Span<T>

## 引言

深拷贝是指创建一个新对象，该对象的值与原始对象完全相同，但在内存中具有不同的地址。这意味着如果您对原始对象进行更改，则不会影响到复制的对象


常见的C#常见的深拷贝方式有以下4类：
 1. 各种形式的序列化及反序列化。
 2. 通过反射机制获取该对象的所有字段和属性信息。遍历所有字段和属性，递归将源对象中的值复制到目标对象中。
 3. 新建对象，手动复制所有成员变量。
 4. 实现 `ICloneable` 接口，重写 `Colne` 方法。方法内部可以调用上面任意实现方法。

### 序列化、反序列化
#### 使用二进制序列化和反序列化

可以使用 `BinaryFormatter` 类将对象序列化成二进制形式并保存到文件或内存流中，然后再使用 `BinaryFormatter` 反序列化对象，这样就可以得到该对象的一个完全独立的副本。

```csharp
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

public static T DeepCopy<T>(T obj)
{
    if (obj == null)
    {
        return default(T);
    }

    MemoryStream stream = new MemoryStream();
    BinaryFormatter formatter = new BinaryFormatter();
    formatter.Serialize(stream, obj);
    stream.Seek(0, SeekOrigin.Begin);
    T copy = (T)formatter.Deserialize(stream);
    stream.Close();

    return copy;
}
```
#### 使用 XML 序列化和反序列化

可以使用 `XmlSerializer` 类将对象序列化成 `XML` 形式并保存到文件或内存流中，然后再使用 `XmlSerializer` 反序列化对象，这样也可以得到该对象的一个完全独立的副本。


```csharp
using System.IO;
using System.Xml.Serialization;

public static T DeepCopy<T>(T obj)
{
    if (obj == null)
    {
        return default(T);
    }

    XmlSerializer serializer = new XmlSerializer(typeof(T));
    MemoryStream stream = new MemoryStream();
    serializer.Serialize(stream, obj);
    stream.Seek(0, SeekOrigin.Begin);
    T copy = (T)serializer.Deserialize(stream);
    stream.Close();

    return copy;
}
```

#### 使用 DataContractSerializer 序列化和反序列化

可以使用 DataContractSerializer 类将对象序列化成 XML 或二进制形式并保存到文件或内存流中，然后再使用 DataContractSerializer 反序列化对象。

```csharp
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Serialization.Formatters.Binary;

public static T DeepCopy<T>(T obj)
{
    if (obj == null)
    {
        return default(T);
    }

    DataContractSerializer serializer = new DataContractSerializer(typeof(T));
    MemoryStream stream = new MemoryStream();
    serializer.WriteObject(stream, obj);
    stream.Seek(0, SeekOrigin.Begin);
    T copy = (T)serializer.ReadObject(stream);
    stream.Close();

    return copy;
}
```
####  使用 Json.NET 或 System.Text.Json 序列化和反序列化

可以使用 JsonConvert 类将对象序列化成 JSON 字符串，然后再使用 JsonConvert 反序列化对象。

```csharp
using Newtonsoft.Json;

public static T DeepCopy<T>(T obj)
{
    if (obj == null)
    {
        return default(T);
    }

    string json = JsonConvert.SerializeObject(obj);
    T copy = JsonConvert.DeserializeObject<T>(json);

    return copy;
}
```

```csharp
using System.Text.Json;
public static T DeepCopy<T>(T obj)
{
    if (obj == null)
    {
        return default(T);
    }

    string jsonString = JsonSerializer.Serialize<T>(obj);
    // 将 JSON 字符串反序列化为对象
    var deserializedPerson = JsonSerializer.Deserialize<T>(jsonString);

    return deserializedPerson;
}
```

### 反射

#### 使用反射实现深拷贝

通过反射生成对象，通过反射机制获取该对象的所有字段和属性信息。遍历所有字段和属性，以递归方式将源对象中的值复制到目标对象中。

```csharp
using System;
using System.Reflection;

public static T DeepCopy<T>(T obj)
{
    if (obj == null)
    {
        return default(T);
    }

    Type type = obj.GetType();
    object copy = Activator.CreateInstance(type);

    // 获取所有字段和属性信息，并将源对象中的值复制到目标对象中
    foreach (FieldInfo fieldInfo in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
    {
        object value = fieldInfo.GetValue(obj);
        fieldInfo.SetValue(copy, DeepCopy(value));
    }
    foreach (PropertyInfo propertyInfo in type.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
    {
        if (!propertyInfo.CanWrite || !propertyInfo.CanRead)
        {
            continue;
        }
        object value = propertyInfo.GetValue(obj);
        propertyInfo.SetValue(copy, DeepCopy(value));
    }

    return (T)copy;
}
```

### 手动赋值
#### 手动复制所有成员变量

可以手动编写代码复制对象中的所有成员变量，这需要对对象结构有很好的了解，并且比较繁琐，容易漏掉某些成员。


```csharp
public class Person
{
    public string Name;
    public int Age;

    public Person DeepCopy()
    {
        Person copy = new Person();
        copy.Name = this.Name;
        copy.Age = this.Age;
        return copy;
    }
}
```
### ICloneable 接口
#### 实现 ICloneable 接口

可以在对象中实现 `ICloneable` 接口，并重写 `Clone` 方法来实现深拷贝。重写的 `Clone` 方法内可以调用上述任何一种方案。
```csharp
public class Person : ICloneable
{
    public string Name;
    public int Age;

    public object Clone()
    {
        Person copy = new Person();
        copy.Name = this.Name;
        copy.Age = this.Age;
        return copy;
    }
}
```

### 第三方库

还有一种方式是使用第三方库实现深拷贝，例如 AutoMapper、ValueInjecter 等。这些库可以自动复制对象中的所有成员变量，从而实现深拷贝。
其中比较常用的包括：

- AutoMapper：这是一个非常流行的对象映射库，可以用于将一个对象的属性值复制到另一个对象中，从而实现对象深拷贝。

- Newtonsoft.Json：这是一个广泛使用的 JSON 序列化/反序列化库，它也提供了一些方法来实现对象深拷贝。

- Cloneable：这是一个专门为 .NET 平台设计的对象克隆库，它提供了多种深拷贝和浅拷贝的方式。

- FastDeepCloner：这是一个高性能的对象复制库，它支持对任意类型进行深拷贝，并且提供了多种可配置选项。

可以需要根据自己的具体需求选择适合自己的库。如果只是需要简单的深拷贝操作，那么 AutoMapper 和 Newtonsoft.Json 都是不错的选择；如果需要更加高效、灵活的操作，那么可以考虑使用 FastDeepCloner 或 Cloneable 等库。

解读 --- 深拷贝

## 引言

哨兵思想是指在算法中使用一个特殊值来检测或标记某些条件的发生，它的目的是为了简化代码，并使其更容易理解，常常用于在循环中优化边界条件的判断。



## 介绍

在算法中，"哨兵"思想是指在循环中设置一个特殊的元素（称为哨兵），以便在循环过程中能够更高效地处理某些边界情况或结束条件。

这种思想可以应用于:
- 不知道集合长度的情况。
- 集合长度在循环过程中可能变化的情况。
- 需要灵活结束循环的情况。

其优点有：

- 简化代码：使用哨兵可以简化算法实现，避免了需要在每个循环迭代中检查数组是否越界的繁琐步骤。

- 提高效率：添加哨兵可以使算法更加高效，因为它避免了重复计算和条件语句的判断。

- 程序健壮性增强：哨兵可以帮助程序更好地处理异常情况。例如，当搜索算法找不到目标元素时，使用哨兵可以避免出现无限循环的情况。

- 易于理解：哨兵可以提高代码的可读性，因为它能够让读者更快速地理解算法的实现过程。

## 示例
以 C# 为例，下面是一个实现插入排序算法的示例代码：

```csharp
public void InsertionSort(int[] arr)
{
    for (int i = 1; i < arr.Length; i++)
    {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
```
在这个例子中，我们使用了传统的循环方式进行插入排序。在内层循环中，需要判断当前元素是否小于已排序的序列中的最后一个元素，然后再逐个比较，如果找到合适的位置才能插入。这样，代码中就有两个边界判断`j >= 0`和`arr[j] > key`，增加了代码的复杂度。

而如果使用哨兵，可以将代码简化。在插入排序算法中，我们可以将数组的第一个元素设置为哨兵，这样就可以省略最后一个元素的比较，从而简化代码。下面是使用哨兵优化后的代码：

```csharp
public void InsertionSortWithSentinel(int[] arr)
{
    int n = arr.Length;

    // 将第一个元素作为哨兵
    int sentinelIndex = 0;
    for (int i = 1; i < n; i++)
        if (arr[i] < arr[sentinelIndex])
            sentinelIndex = i;
    int temp = arr[0];
    arr[0] = arr[sentinelIndex];
    arr[sentinelIndex] = temp;

    // 排序
    for (int i = 2; i < n; i++)
    {
        int key = arr[i];
        int j = i - 1;
        while (arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
```
在这个方法中，我们首先找到数组中的最小值并将其与数组的第一个元素交换，以便我们可以使用哨兵来避免越界。然后，我们进行插入排序，将未排序的元素逐个插入到已排序的子数组中。这样就避免了边界问题，且能够更快速的理解该算法的实现过程。

> 参考资料
> 
> [1] [浅聊哨兵思想及其在算法问题中的应用](https://juejin.cn/post/7183688224588431420) ---CN千石