本文對Metalama中的切麵進行簡介及以WPF中的 INotifyPropertyChanged 為例，展示如何利用Metalama簡化INotifyPropertyChanged 的實現 ...

上文介紹到Aspect是Metalama的核心概念，它本質上是一個編譯時的AOP切片。下麵我們就來系統說明一下Metalama中的Aspect。
Metalama簡介1. 不止是一個.NET跨平臺的編譯時AOP框架

本文講些什麼

關於Metalama中Aspect的基礎
一些關於Aspect的示例，最終目的是通過本篇的介紹，將在編譯時自動為類型添加INotifyPropertyChanged，實現如下效果:
1. 自動添加介面
2. 自動添加介面實現
3. 改寫屬性的set和get

關於Aspect

在前面的文章中我們已經介紹了使用Metalama編寫簡單的AOP。但是例子過於簡單，也只是在代碼前後加了兩個Console.WriteLine，並沒有太大的實際參考意義。下麵我就以幾個實際例子，來體現Metalama在復用代碼方面的好處。
對於Metalama中的Aspect分為以下兩種API

1.Aspect基礎API

TypeAspect 對類型進行編譯時代碼插入,見示例3
MethodAspect
PropertyAspect
ParameterAspect
EventAspect
FieldAspect
FieldOrPropertyAspect
ConstructorAspect

2.Override API（重寫式API）

重寫試API使用更方便、更直觀,與上面基礎API等價，但是更容易使用

OverrideMethodAspect 對方法進行編譯時代碼插入，請見下麵示例1
OverrideFieldOrPropertyAspect 對欄位或屬性進行編譯時代碼插入，請見下麵示例2
OverrideEventAspect 對事件進行編譯時插入代碼

以 MethodAspect 和 OverrideMethodAspect 為例，以下代碼等價。

基礎API MethodAspect

    public class LogAttribute : MethodAspect
    {
        public override void BuildAspect(IAspectBuilder<IMethod> builder)
        {
           // 為方法添加重寫
           builder.Advices.OverrideMethod(builder.Target,nameof(this.MethodLog));
        }
        [Template]// 這個Template必須要加
        public dynamic MethodLog()
        {
            Console.WriteLine(meta.Target.Method.ToDisplayString() + " 開始運行.");
            var result = meta.Proceed();
            Console.WriteLine(meta.Target.Method.ToDisplayString() + " 結束運行.");
            return result;
        }
    }

Override API

    public class LogAttribute : OverrideMethodAspect
    {
        public override dynamic? OverrideMethod()
        {
            Console.WriteLine(meta.Target.Method.ToDisplayString() + " 開始運行.");
            var result = meta.Proceed();
            Console.WriteLine(meta.Target.Method.ToDisplayString() + " 結束運行.");
            return result;
        }
    }

下麵針對各種情況舉一些試例。
根據每個例子的不同也分別介紹如何對方法、欄位、屬性進行重寫。

關於meta類

通過上面的示例我們可以看到，無論是在基礎API中還是Override API中，在定義AOP方法時，都使用到了meta。 meta是一個方便在Aspect中訪問當前AOP上下文的工具類
常用的成員有：

成員	說明
`meta.Proceed()`	等同於執行AOP作用目標直接執行，例如方法Aspect中就是原方法直接執行，屬性的get中就是獲取值，屬性的Set中就是賦值value
`meta.Target`	當前AOP的作用目標，如作用目標是個方法則通過 `meta.Target.Method` 調用，如果目標是個屬性則通過 `meta.Target.Propery` 調用
`meta.This`	等同於使用在AOP作用目標中的`this`，例如可以用於獲取AOP目標所在類的其它屬性，方法
`meta.ThisStatic`	用於訪問AOP作用目標中的靜態類型

示例1對方法：實現一個重試N次的功能

在平時的代碼中，有這種場景，例如，我調用一個方法或API，他有一定的概率失敗，例如發生了網路異常，所以我們就要設定一個重試機制（以重試3次然後放棄為例）。
假設我們有一個方法，代碼詳見示例中的RetryDemo。

    static int _callCount;
    // 此方法第一二次調用會失敗，第三次會成功
    static void MyMethod()
    {
        _callCount++;
        Console.WriteLine($"當前是第{_callCount}次調用.");
        if (_callCount <= 2)
        {
            Console.WriteLine("前兩次直接拋異常:-(");
            throw new TimeoutException();
        }
        else
        {
            Console.WriteLine("成功 :-)");
        }
    }

如果我們直接編寫代碼，可以使用類似以下邏輯處理。

        for (int i = 0; i < 3; i++)
        {
            try
            {
                MyMethod();
                break;
            }
            catch (Exception ex)
            {
                // Console.WriteLine(ex);
            }
        }

這樣的話，對於不同的方法我們就會出現大量的重試邏輯。
那麼使用Metalama我們如何進行代碼改造，去掉復用代碼呢。
第一步，我們需要創建一個可以修改方法的AOP的Attribute,如下：

internal class RetryAttribute : OverrideMethodAspect
{
    // 重試次數
    public int RetryCount { get; set; } = 3;
    // 應用到方法的切麵模板
    public override dynamic? OverrideMethod()
    {
        for (var i = 0; ; i++)
        {
            try
            {
                return meta.Proceed(); // 這是實際調用方法的位置
            }
            catch (Exception e) when (i < this.RetryCount)
            {
                Console.WriteLine($"發生異常 {e.Message.GetType().Name}. 1秒後重試.");
                Thread.Sleep(1000);
            }
        }
    }
}

這裡可以看到定義這個Attribute時，使用了Metalama提供的基類OverrideMethodAspect此基類是用於為方法添加編譯時切麵代碼的Attribute.
然後我們將這個Attribute加到方法定義上。

    static int _callCount;

    [Retry(RetryCount = 5)]
    static void MyMethod()
    {
        _callCount++;
        Console.WriteLine($"當前是第{_callCount}次調用.");
        if (_callCount <= 2)
        {
            Console.WriteLine("前兩次直接拋異常:-(");
            throw new TimeoutException();
        }
        else
        {
            Console.WriteLine("成功 :-)");
        }
    }

這樣在編譯時Metalama就會將代碼編譯為如下圖所示。

而RetryAttribute編譯後則會變為

也就是會將原有的OverrideMethod自動實現為throw new System.NotSupportedException("Compile-time-only code cannot be called at run-time.")。
最終調用結果為

當前是第1次調用.
前兩次直接拋異常:-(
發生異常 String. 1秒後重試.
當前是第2次調用.
前兩次直接拋異常:-(
發生異常 String. 1秒後重試.
當前是第3次調用.
成功 :-)

源代碼：https://github.com/chsword/metalama-demo/tree/main/src/RetryDemo

示例2對屬性：INotifyPropertyChanged自動屬性的實現

在很多處理邏輯中我們會用到INotifyPropertyChanged如我們要獲取以下類的屬性更改：

public class MyModel
{
    public int Id { get; set; }
    public string Name { get; set; }
}

我們可以這麼做：

using System.ComponentModel;
public class MyModel: INotifyPropertyChanged
{
    private int _id { get; set; }
    public int Id {
        get {
            return _id;
        }
        set
        {
            if (this._id != value)
            {
                this._id = value;
                this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Id"));
            }
        }
    }
    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }
        set
        {
            if (this._name != value)
            {
                this._name = value;
                this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Name"));
            }
        }
    }
    public event PropertyChangedEventHandler? PropertyChanged;
}

但是這裡，要將自動屬性進行展開，並產生大量欄位，對於這裡的重覆代碼，我們可以用Metalama進行處理，我們最終要代碼實現為如下：

public class MyModel: INotifyPropertyChanged
{
    [NotifyPropertyChanged]
    public int Id { get; set; }
    [NotifyPropertyChanged]
    public string Name { get; set; }

    public event PropertyChangedEventHandler? PropertyChanged;
}

當然我們也要實現NotifyPropertyChangedAttribute:

public class NotifyPropertyChangedAttribute : OverrideFieldOrPropertyAspect
{
    public override dynamic OverrideProperty
    {
        // 保留原本get的邏輯
        get => meta.Proceed();
        set
        {
            // 判斷當前屬性的Value與傳入value是否相等
            if (meta.Target.Property.Value != value)
            {
                // 原本set的邏輯
                meta.Proceed();
                // 這裡的This等同於調用類的This
                meta.This.PropertyChanged?.Invoke(meta.This, new PropertyChangedEventArgs(meta.Target.Property.Name));
            }
        }
    }
}

這樣就可以實現上面相同的效果。

源代碼：https://github.com/chsword/metalama-demo/tree/main/src/PropertyDemo

示例3對類型：進一步實現INotifyPropertyChanged自動屬性

剛纔對屬性在編譯時生成INotifyPropertyChanged實現的代碼中，其實可以再進一步優化，INotifyPropertyChanged介面的實現也可以通過Metalama進一步省去，最終代碼為：

[TypeNotifyPropertyChanged]
public class MyModel
{
    public int Id { get; set; }
    public string Name { get; set; }
}

那麼TypeNotifyPropertyChangedAttribute又應該怎麼實現呢，Type Aspect並沒有對應的Override實現，所以要使用TypeAspect。

internal class TypeNotifyPropertyChangedAttribute : TypeAspect
{
    public override void BuildAspect(IAspectBuilder<INamedType> builder)
    {
        // 當前類實現一個介面
        builder.Advices.ImplementInterface(builder.Target, typeof(INotifyPropertyChanged));
        // 獲取所有符合要求的屬性
        var props = builder.Target.Properties.Where(p => !p.IsAbstract && p.Writeability == Writeability.All);
        foreach (var property in props)
        {
            //用OverridePropertySetter重寫屬性或欄位
            //參數1 要重寫的屬性 參數2 新的get實現 參數3 新的set實現
            builder.Advices.OverrideFieldOrPropertyAccessors(property, null, nameof(this.OverridePropertySetter));
        }
    }
    // Interface 要實現什麼成員
    [InterfaceMember]
    public event PropertyChangedEventHandler? PropertyChanged;

    // 也可以沒有這個方法，直接調用 meta.This 這裡只是展示另一種調用方式，更加直觀
    [Introduce(WhenExists = OverrideStrategy.Ignore)]
    protected void OnPropertyChanged(string name)
    {
        this.PropertyChanged?.Invoke(meta.This, new PropertyChangedEventArgs(name));
    }

    // 重寫set的模板
    [Template]
    private dynamic OverridePropertySetter(dynamic value)
    {
        if (value != meta.Target.Property.Value)
        {
            meta.Proceed();
            this.OnPropertyChanged(meta.Target.Property.Name);
        }

        return value;
    }
}

這樣就可以實現和以上相同效果的代碼，以後再添加實現INotifyPropertyChanged的類，只要添加以上Attribute即可。

源代碼：https://github.com/chsword/metalama-demo/tree/main/src/TypeDemo

減少代碼入侵

上面的示例3中，其實對方法還是有一定入侵的，至少要標記一個Attribute，Metalama還提供了其它無入侵的方式來為類或方法添加Aspect，我們將在後面來介紹。

先上個代碼

internal class Fabric : ProjectFabric
{
    public override void AmendProject(IProjectAmender amender)
    {
        // 添加 TypeNotifyPropertyChangedAttribute 到符合規則的類上
        // 當前篩選以 Model 結尾的本項目中的類型添加 TypeNotifyPropertyChangedAttribute
         amender.WithTargetMembers(c =>
            c.Types.Where(t => t.Name.EndsWith("Model"))
            ).AddAspect(t => new TypeNotifyPropertyChangedAttribute());
    }
}

調試

調試 Aspect 的 Attribute時，尚不能使用斷點直接調試，但可以通過以下方法：
在編譯配置中除Debug或Release外還有一個LamaDebug。選擇使用LamaDebug即可直接對Metalama的項目進行調試。

在編譯時就會調用的內容中，如BuildAspect,使用 System.Diagnostics.Debugger.Break().
在Template方法或Override中, 使用meta.DebugBreak。

如果是想以附加進程等方式添加斷點調試，可以參考官方文檔https://doc.metalama.net/aspects/debugging-aspects

供大家學習參考,轉文章隨意--重典

Metalama簡介2.利用Aspect在編譯時進行消除重覆代碼