## 引言
现在模拟一个异步方法抛出了异常：

```csharp
public static async Task ThrowAfter(int ms, string message)
{
    await Task.Delay(ms);
    throw new Exception(message);
}
```

思考一下， `DontHandle()` 方法是否能够捕获到异常？

```csharp
public static void DontHandle()
{
    try
    {
        ThrowAfter(1000, "first");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }

}

```


答案是：不会捕获到异常！

因为 `DontHandle()` 方法在 `ThrowAfter()` 方法抛出异常之前，就已经执行完毕。


## 异步方法的异常处理

那么上述代码怎么才能捕获到异常呢？

若想要捕获异常则必须通过 `await` 关键字等待 `ThrowAfter()` 方法执行完成。

将上文中的代码段进行修改：

```csharp
public static async void HandleoOnError()
{
    try
    {
        await ThrowAfter(1000, "first");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
```
结果就会输出：

```csharp
first
```

## 多个异步方法的异常处理

如果调用两个异步方法，每个都会抛出异常，该如何处理呢？

我们可以这样写：

```csharp
public static async void StartTwoTasks()
{
    try
    {
        await ThrowAfter(1000, "first");
        await ThrowAfter(1000, "second");
        Console.WriteLine("StartTwoTasks is Complate");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
```
思考一下输出是什么？

答案是：

```csharp
first
```
并没有预想中的两个异常都捕获打印出来，也没有看到“StartTwoTasks is Complate”这句话打印出来。因为使用 `await` 关键字之后，两次调用 `ThrowAfter()` 方法就变成了同步执行，捕获到第一次的异常之后直接进入到 `catch` 代码段，不再执行后续代码。

可以尝试解决这个问题，使用 `Task.WhenAll()` 方法，该方法不管任务是否抛出异常，都会等到两个任务完成。如下代码：

```csharp
public static async void StartTwoTasksParallel()
{
    try
    {
        Task t1 = ThrowAfter(1000, "first");
        Console.WriteLine("t1 is Complate");
        Task t2 = ThrowAfter(1000, "second");
        Console.WriteLine("t2 is Complate");
        await Task.WhenAll(t2, t1);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
```

输出：

```csharp
t1 is Complate
t2 is Complate
second
```

从输出可以看出来，使用 `WhenAll()` 方法，两个任务都是执行完成的，但是，捕获异常只能捕获 `WhenAll()`方法参数中，排在最前面的，且第一个抛出异常的任务的消息，

上述方式有缺陷，只能抛出一个异常的任务的消息，可以将上面的方式再进化一下，如下代码：

```csharp
public static async void StartTwoTasksParallelEx()
{
    Task t1 = null;
    Task t2 = null;
    try
    {
        t1 = ThrowAfter(1000, "first");
        t2 = ThrowAfter(1000, "second");
        await Task.WhenAll(t2, t1);

    }
    catch (Exception ex)
    {
        if (t1.IsFaulted)
        {
            Console.WriteLine(t1.Exception.InnerException.Message);
        }

        if (t2.IsFaulted)
        {
            Console.WriteLine(t2.Exception.InnerException.Message);
        }
    }
}
```
输出：

```csharp
first
second
```


在 `try/catch` 代码块外声明任务变量t1、t2，使他们可以在 `try/catch` 块内访问，在这里，使用了`IsFaulted` 属性，检查任务的状态，若`IsFaulted` 属性为 `true` ，则表示该任务出现异常，就可以使用 `Task.Exception.InnerException` 访问异常本身。

## 使用AggregateException信息

除了上述方式外，还有一种更好的获取所有任务的异常信息的方式，`Task.WhenAll()` 方法返回的结果其实也是一个 `Task` 对象，而 `Task` 有一个 `Exception` 属性，它的类型是 `AggregateException`，是 `Exception`的一个派生类，`AggregateException` 类有一个 `InnerExceptions` 属性（异常集合，包含 `Task.WhenAll()` 方法列表中所有异常任务的异常信息）。

有了这个属性则可以轻松遍历所有异常。如下代码：

```csharp
public static async void StartTwoTasksParallelEx2()
{
    Task t3 = null;
    try
    {
        Task t1 = ThrowAfter(1000, "first");
        Task t2 = ThrowAfter(1000, "second");
        await (t3 = Task.WhenAll(t2, t1));

    }
    catch (Exception ex)
    {
        foreach (var item in t3.Exception.InnerExceptions)
        {
            Console.WriteLine("InnerException:" + item.Message);
        }
    }
}
```

输出：
```csharp
InnerException:second
InnerException:first
```

## 总结

除了前面提到的异步方法异常处理的基本知识点，以下是一些进阶的异常处理技巧：

- 在异步方法中，如果需要将异常传递给调用方，请不要直接抛出异常。相反，应该使用 throw 关键字将异常包装在一个 `Task` 或 `ValueTask` 对象中，并将其返回给调用方。这可以避免在异步操作中丢失异常信息。

- 如果需要在异步方法中处理多个异常，可以使用 `catch` 块来捕获不同类型的异常，并根据需要执行不同的处理操作。还可以使用 `finally` 块来执行清理操作，例如释放资源或恢复状态。

- 如果需要在异步方法中执行一些异步操作，并且这些操作都必须成功才能继续执行下一步操作，那么可以使用 `Task.WhenAll` 方法来等待所有异步操作完成。如果任何一个异步操作失败，`WhenAll` 方法将返回一个 `AggregateException` 对象，其中包含所有失败的异常。

- 如果需要在异步方法中执行多个异步操作，并且这些操作中的任何一个失败都将导致整个操作失败，那么可以使用 `Task.WhenAny` 方法来等待第一个异步操作完成。如果第一个操作失败，`WhenAny` 方法将返回一个 `AggregateException` 对象，其中包含第一个失败的异常。

- 如果需要在异步方法中进行错误处理并且希望能够获取更多有关异常的信息，可以使用 `ExceptionDispatchInfo` 类。这个类可以捕获异常并将其存储在一个对象中，然后在需要时重新抛出异常。这可以帮助在异步操作中保留异常信息，并将其传递给调用方。

总之，在异步方法中处理异常时，需要注意一些细节和技巧，例如正确处理异常、捕获多个异常、等待多个异步操作、以及使用 `ExceptionDispatchInfo` 类来捕获异常。掌握这些处理技巧可以帮助编写更可靠、更健壮的异步代码。

并发编程 --- 异步方法的异常处理

## 引言
在实际开发场景中，当ViewModel内的一个属性是一个 `ObservableCollection<T>` 或者是一个多层级 `class` 的时候，有可能有的需求需要 `ObservableCollection<T>`内的元素的子属性或多层级 `class` 的子属性，甚至子属性的子属性，变化，需要通知到ViewModel，该怎么做呢？



例如我有一个设置功能模块，十几个模型，一两百个属性参数，模型之间是2~3层的嵌套关系，最后得到一个大模型表示Model，我想要在子属性的值变化的是通知到ViewModel，记录日志或其他操作。


现有的MVVM框架，例如 `MVVMLight` ，`Prism` ， 我好像都没有找到这样的功能，如果有更好的方案或实现，烦请告之。

现在手动实现一个这样的辅助类。接下来看一下实现过程：

### INotifyHolder接口
 
先定义 `INotifyHolder` 接口，用于通知 `HolderViewModel` ，有属性变化了。

```csharp
namespace MvvmNoticeHolderLib
{
    public interface INotifyHolder
    {
        void AfterPropertyChangedNotified(object sender, string info);
    }
}
```
### NoticeFlagAttribute特性
定义 `NoticeFlagAttribute` 特性，用于标记哪些属性是需要在变化时通知到 `HolderViewModel` 的。
```csharp
namespace MvvmNoticeHolderLib
{

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
    public class NoticeFlagAttribute : Attribute
    {
        public string Name { get; set; } = string.Empty;
        
        public Type Type { get; set; }

        public NoticeFlagAttribute(string names, Type type)
        {
            Name = names;
            Type = type;
        }
    }
}
```
###  NotifyHolder的Binding管理器

```csharp
namespace MvvmNoticeHolderLib
{
    public class NotifyHolderBindingManager
    {
        private static T BindSlaveProperty<T>(T source, object root)
        {
            try
            {
                if (source != null)
                {
                    var type = source.GetType();

                    var properties = type.GetProperties();

                    var NoticeFlags = type.GetCustomAttributes<NoticeFlagAttribute>();

                    if (NoticeFlags != null && NoticeFlags.Count() > 0)
                    {
                        foreach (var noticeFlag in NoticeFlags)
                        {
                            PropertyInfo info = properties.SingleOrDefault(x => x.Name == noticeFlag.Name);

                            if (info != null)
                            {
                                BindProperty(source, root, info);
                            }
                        }
                    }
                }
                return source;
            }
            catch (Exception ex)
            {
                return source;
            }
        }

        public static T BindSelfProperty<T>(T root)
        {
            try
            {
                if (root != null)
                {
                    var type = root.GetType();

                    var properties = type.GetProperties();

                    var NoticeFlags = type.GetCustomAttributes<NoticeFlagAttribute>();

                    if (NoticeFlags != null && NoticeFlags.Count() > 0)
                    {
                        foreach (var noticeFlag in NoticeFlags)
                        {
                            PropertyInfo info = properties.SingleOrDefault(x => x.Name == noticeFlag.Name);

                            if (info != null)
                            {
                                BindSlaveProperty(root, root);

                                var tmp = info.GetValue(root);

                                if (root is INotifyPropertyChanged notify)
                                {
                                    notify.PropertyChanged += (sender, e) =>
                                    {
                                        if (NoticeFlags.Any(t => t.Name == e.PropertyName))
                                        {
                                            var senderType = sender.GetType();
                                            PropertyInfo senderProperty = senderType.GetProperty(e.PropertyName);
                                            BindProperty(sender, sender, senderProperty);
                                        }
                                    };
                                }
                            }
                        }
                    }
                }
                return root;
            }
            catch (Exception)
            {
                return root;
            }
        }

        private static void BindProperty<T>(T source, object root, PropertyInfo info)
        {
            if (info.PropertyType.IsGenericType && info.PropertyType.GetGenericTypeDefinition() == typeof(ObservableCollection<>))
            {
                var tmp = info.GetValue(source);

                if (tmp != null && tmp is INotifyCollectionChanged notifyCollectionChanged)
                {
                    notifyCollectionChanged.CollectionChanged += (sender, e) =>
                    {
                        if (e.NewItems != null && e.NewItems.Count > 0)
                        {
                            BindSlaveProperty(e.NewItems[0], root);

                            if (e.NewItems[0] != null && e.NewItems[0] is INotifyPropertyChanged notify)
                            {
                                if (root is INotifyHolder notifyHolder)
                                {
                                    notify.PropertyChanged += (s, e) =>
                                    {
                                        notifyHolder.AfterPropertyChangedNotified(s, info.Name + "." + e.PropertyName + "发生了变化");
                                    };
                                }
                            }
                        }
                    };

                    var arr = (IEnumerable<object>)tmp;
                    foreach (var item in arr)
                    {
                        if (item is INotifyPropertyChanged notify && root is INotifyHolder notifyHolder)
                        {
                            BindSlaveProperty(item, root);
                            notify.PropertyChanged += (sender, e) =>
                            {
                                notifyHolder.AfterPropertyChangedNotified(sender, info.Name + "." + e.PropertyName + "发生了变化");
                            };
                        }
                    }
                }
            }
            else if (info.PropertyType.GetInterfaces().Contains(typeof(INotifyPropertyChanged)))
            {
                var tmp = info.GetValue(source);
                if (tmp != null && tmp is INotifyPropertyChanged notify)
                {
                    BindSlaveProperty(tmp, root);
                    if (root is INotifyHolder notifyHolder)
                    {
                        notify.PropertyChanged += (sender, e) =>
                        {
                            notifyHolder.AfterPropertyChangedNotified(sender, info.Name + "." + e.PropertyName + "发生了变化");
                        };
                    }
                }
            }
        }
    }
}

```
 
这个类就是实现这个功能的核心，其主要原理是，通过 `NoticeFlagAttribute` 特性，获取你要绑定的属性，然后  监控你要绑定的属性的 `INotifyPropertyChanged` 的`PropertyChanged` 事件或者是 `INotifyCollectionChanged` 的 `CollectionChanged`事件，最后通知到 `HolderViewModel` 中，若子属性有多层级关系，可以多层级中每个层级使用 `NoticeFlagAttribute` 特性，标记你想要监控的属性，然后Binding管理器通过递归方式依次绑定好，就实现了多层级的监控通知到 `HolderViewModel` 中。

我已将Demo发布到github，Readme.md中有使用说明。
 
>github仓库地址
>
>https://github.com/PeterPandefu/MvvmNoticeHolder

MVVM --- 实现多层级通知

## 介绍

**CAS**(Compare And Swap) 是一种无锁算法的实现手段，中文名称为比较并交换。它由 CPU 的原子指令实现，可以在多线程环境下实现无锁的数据结构。



### 原理
**CAS** 的原理是：它会先比较内存中的某个值是否和预期值相同，如果相同则更新这个值，否则不做任何操作。这整个过程是原子的，所以可以在多线程环境下实现无锁的数据结构。

**CAS** 操作有3个原子性操作:
1. 读取内存的值
2. 将内存的值与期望值比较
3. 如果相等，则将内存值更新为新值


这三个操作一起完成，中间不会被线程切换打断。这就保证了比较和交换的原子性。

使用C#伪代码实现如下：


```csharp
bool Cas(ref object obj, object expected, object newValue)
{
    object oldValue = obj;
    if (oldValue == expected) {
        obj = newValue;
        return true;
    }
    return false;
}
```
解释如下:
- C#使用ref关键字来表示要操作的内存地址obj
- oldValue = obj读取内存值，obj = newValue更新内存值。
- 其他逻辑与伪代码相同，先读取内存值oldValue，然后判断是否等于期望值expected，如果相等则更新内存值为newValue并返回true，否则返回false。
- **CAS**操作包含读内存值、比较内存值与期望值、更新内存值三个原子步骤。这三步作为一个整体执行，中间不会被中断，保证比较和交换的原子性。
- 该方法尝试使用**CAS**操作更新obj的值，当且仅当obj的值等于expected时才更新，否则不做任何操作。

### 示例


C# 中提供了 Interlocked 类来实现 **CAS** 操作。主要包含以下几个方法:
- Interlocked.CompareExchange(ref val, newValue, comparand)：如果 `val` 等于 `comparand`，则将 `val` 的值更新为 `newValue`，并返回 `comparand`，否则返回 `val` 的当前值。
- Interlocked.Exchange(ref val, newValue)：将 `val` 的值更新为 `newValue`，并返回 `val` 的旧值。
- Interlocked.Increment(ref val)：将 `val` 的值增加 1，并返回增加后的值。 
- Interlocked.Decrement(ref val)：将 `val` 的值减少 1，并返回减少后的值。
示例代码:
```csharp
int val = 0;
Interlocked.CompareExchange(ref val, 1, 0); // val = 1， 返回 0  
Interlocked.CompareExchange(ref val, 2, 1); // val 保持 1， 返回 1
Interlocked.Increment(ref val);           // val = 2， 返回 2
Interlocked.Decrement(ref val);           // val = 1， 返回 1
```

这些方法可以实现无锁数据结构，例如无锁队列:
```csharp
public class LockFreeQueue<T>
{
    private T[] array;
    private int head;
    private int tail;

    public void Enqueue(T obj)
    {
        int tail = Interlocked.Increment(ref this.tail);
        this.array[tail % this.array.Length] = obj;
    }

    public T Dequeue()
    {
        int head = Interlocked.Increment(ref this.head);
        return this.array[head % this.array.Length];
    }
} 
```
通过 Interlocked 类的原子操作实现了无锁入队出队，这是一个典型的使用 CAS 实现无锁算法的例子。

### CAS优缺点

**优点**:
- 无锁，实现高并发的数据结构。**CAS** 是实现无锁算法的关键手段。
- 原子操作，线程安全，不会引起数据竞争。
- 简单高效，只需要硬件支持，性能很高。


**缺点**:
- ABA 问题。如果一个值从 `A` 改为 `B`，又改回 `A`，那么 **CAS** 操作会误认为值没有改变。常用的解决方法是使用版本号。
- 只能保证一个共享变量的原子操作。如果对多个共享变量操作，则需要使用锁。
- 资源浪费。当 **CAS** 失败时，会进行重试，消耗 CPU 资源。
- 只能在某些平台使用。需要硬件对 **CAS** 操作的支持，一些低端硬件并不支持 **CAS**。


综上，CAS 是实现无锁算法的关键手段，有很高的性能，但是也存在一定的问题，需要权衡使用。

**一般适用场景**:
- 当对一个共享变量的原子操作时，使用 **CAS**。
- 当操作多个共享变量时，使用锁可能性能更高。
- 如果硬件不支持 **CAS**，也不得不使用锁。

### 结论

**CAS** 是实现无锁算法的关键手段，性能高并发度高，但是也存在一定问题，需要权衡使用。一般来说，当操作一个共享变量时使用 **CAS**，操作多个共享变量时使用锁可能更高效。如果硬件不支持 **CAS**，也只能使用锁。

此外，**CAS** 和锁是两种不同的同步原语，各有优缺点，需要根据实际情况选择使用。**CAS** 是无锁算法的基石，所以高性能高并发系统中还是比较重要的

并发编程 --- CAS原子操作

## 引言

**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 表达式、序列化代码等。