C#?中的"智能枚舉"之如何在枚舉中增加行為(示例代碼)

更新時間：2023年05月17日 10:35:11 作者：反骨仔

這篇文章主要介紹了C#?中的“智能枚舉”之如何在枚舉中增加行為(示例代碼),智能枚舉跟設計模式的意義一樣，可以幫助您避免重復的代碼，并提高代碼的可讀性和可維護性，需要的朋友可以參考下

枚舉的基本用法回顧

以下是一個常見的 C# 枚舉（enum）的示例：

enum Weekday
{
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}

class Program
{
    static void Main(string[] args)
    {
        Weekday today = Weekday.Tuesday;
        Console.WriteLine("今天是" + today.ToString() + "。");
        Console.WriteLine("明天是" + (Weekday)(((int)today + 1) % 7) + "。");
        Console.WriteLine("昨天是" + (Weekday)(((int)today + 6) % 7) + "。");
    }
}

在這個示例中，我們定義了一個名為 Weekday 的枚舉，其中包括每個星期的日子。然后在 Main 方法中，我們將 today 變量設置為 Tuesday，并使用 ToString() 方法將其轉換為字符串。

接下來，我們計算并輸出明天和昨天的日子。我們使用強制類型轉換將枚舉值轉換為整數(shù)，然后在取模 7 意義下加或減 1 或 6，以便正確地計算出前一天或后一天的日子。

輸出結果應該是這樣的：

今天是 Tuesday。
明天是 Wednesday。
昨天是 Monday。

枚舉常見的設計模式運用

enum 可以應用在許多種設計模式下：

狀態(tài)模式
策略模式
工廠模式
觀察者模式

介紹

狀態(tài)模式

狀態(tài)模式用于根據對象的內部狀態(tài)來改變其行為。enum 可以很好地表示對象的狀態(tài)，因此它是實現(xiàn)狀態(tài)模式的常見選擇。在 C# 中，您可以使用 switch 語句來根據不同的 enum 值執(zhí)行不同的操作。

策略模式

策略模式允許您根據運行時條件選擇不同的算法或行為。enum 可以很好地表示這些條件，因此它是實現(xiàn)策略模式的常見選擇。在 C# 中，您可以使用 switch 語句或 if-else 語句來根據不同的 enum 值選擇不同的算法或行為。

工廠模式

工廠模式允許您使用一個共同的接口來創(chuàng)建不同的對象。enum 可以很好地表示這些對象的類型，因此它是實現(xiàn)工廠模式的常見選擇。在 C# 中，您可以使用 switch 語句或 if-else 語句來根據不同的 enum 值創(chuàng)建不同的對象。

觀察者模式

觀察者模式用于建立對象之間的松散耦合關系。enum 可以很好地表示觀察者對象的狀態(tài)，因此它是實現(xiàn)觀察者模式的常見選擇。在 C# 中，您可以使用 enum 來表示觀察者對象的狀態(tài)，并使用委托或事件來通知觀察者對象。

智能枚舉

什么是智能枚舉？智能枚舉不是官方的一個稱謂，而是作者定義的一個名詞。

這種帶行為的一種枚舉，簡單的可以定義為：智能枚舉 = 枚舉 + 豐富的行為。

它由原來的 enum 類型（值類型）改變成了 class 類型（引用類型），允許您將行為和方法綁定到每個枚舉類型上。這意味著您可以在枚舉類型上調用方法和屬性，就像在類實例上調用它們一樣。

智能枚舉跟設計模式的意義一樣，可以幫助您避免重復的代碼，并提高代碼的可讀性和可維護性。它們還可以使您的代碼更加類型安全，因為編譯器可以驗證您是否使用了正確的枚舉值。

代碼示例

首先，我們先定義一個抽象的類型，方便后續(xù)重用：

public abstract class Enumeration<TEnum> : IEquatable<Enumeration<TEnum>> where TEnum : Enumeration<TEnum>
{
    private static readonly Dictionary<int, TEnum?> Enumerations = GetEnumerations();
    /// <summary>
    /// 枚舉類型
    /// </summary>
    private static readonly Type EnumType = typeof(TEnum);
    protected Enumeration(int value, string name)
    {
        Value = value;
        Name = name;
    }
    /// <summary>
    /// 名稱
    /// </summary>
    public string Name { get; protected init; }
    /// <summary>
    /// 值
    /// </summary>
    public int Value { get; protected init; }
    public static TEnum? FromName(string name) => Enumerations.Values.SingleOrDefault(x => x.Name == name);
    public static TEnum? FromValue(int value) => Enumerations.TryGetValue(value, out var enumeration) ? enumeration : default;
    public bool Equals(Enumeration<TEnum>? other) => other is not null && GetType() == other.GetType() && Value == other.Value;
    public override bool Equals(object? obj) => obj is Enumeration<TEnum> other && Equals(other);
    public override int GetHashCode() => HashCode.Combine(Value, Name);
    private static Dictionary<int, TEnum?> GetEnumerations() => EnumType
        .GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
        .Where(x => EnumType.IsAssignableFrom(x.FieldType))
        .Select(x => (TEnum?)x.GetValue(default)).ToDictionary(x => x?.Value ?? 0);
}

先簡單解讀一下。

這是一個通用的 C# 抽象類，用于實現(xiàn)枚舉的高級功能。它使用泛型類型 TEnum 來表示枚舉類型，并繼承自 IEquatable<Enumeration<TEnum>> 接口，以支持比較操作。

這個抽象類包含了一些常用的枚舉操作方法，例如 FromName 和 FromValue，它們可以通過名稱或值來獲取枚舉值。它還重寫了 Equals 和 GetHashCode 方法，以便可以比較兩個枚舉值是否相等。

該類中的核心方法是 GetEnumerations，它使用反射獲取當前枚舉類型中的所有字段，并將它們轉換為枚舉值。在這個過程中，它還會檢查字段的類型是否與枚舉類型相同，并將值存儲在一個字典中，以便以后可以快速地訪問它們。

通過繼承這個抽象類，您可以輕松地實現(xiàn)自己的枚舉類型，并獲得許多有用的功能，例如通過名稱和值獲取枚舉值，并支持比較操作。

業(yè)務應用

我們通常會將枚舉類型這樣定義，而在觸發(fā)業(yè)務邏輯時會使用 switch 來執(zhí)行不同的行為，這樣就很容易會將邏輯分散在不同的地方。

/// <summary>
/// 信用卡類型
/// </summary>
public enum CreditCardType
{
    None = 0,
    Standard = 1,
    Silver = 2,
    Gold = 3,
}

那么升級后的智能枚舉應該是怎樣的呢？它到底智能在哪里？

/// <summary>
/// 信用卡
/// </summary>
public abstract class CreditCard : Enumeration<CreditCard>
{
    public static readonly CreditCard Gold = new GoldCreditCard();
    public static readonly CreditCard Silver = new SilverCreditCard();
    public static readonly CreditCard Standard = new StandardCreditCard();
    public static readonly CreditCard None = new NoneCreditCard();
    private CreditCard(int value, string name) : base(value, name)
    {
    }
    /// <summary>
    /// 折扣
    /// </summary>
    public abstract double Discount { get; }
    /// <summary>
    /// 金卡
    /// </summary>
    private sealed class GoldCreditCard : CreditCard
    {
        public GoldCreditCard() : base(3, nameof(Gold))
        {
        }
        public override double Discount => 0.2;
    }
    private sealed class SilverCreditCard : CreditCard
    {
        public SilverCreditCard() : base(2, nameof(Silver))
        {
        }
        public override double Discount => 0.1;
    }
    /// <summary>
    /// 標準
    /// </summary>
    private sealed class StandardCreditCard : CreditCard
    {
        public StandardCreditCard() : base(1, nameof(Standard))
        {
        }
        public override double Discount => 0.05;
    }
    /// <summary>
    /// 無
    /// </summary>
    private sealed class NoneCreditCard : CreditCard
    {
        public NoneCreditCard() : base(0, nameof(None))
        {
        }
        public override double Discount => 0;
    }
}

這里簡單解讀一下。

這是一個信用卡枚舉類型的實現(xiàn)，它繼承了之前提到的通用枚舉類 Enumeration。其中，GoldCreditCard、SilverCreditCard、StandardCreditCard 和 NoneCreditCard 是四個具體的信用卡子類。

每個子類都重寫了父類 CreditCard 中的 Discount 屬性，以表示不同信用卡的折扣率。GoldCreditCard 有最高的折扣率，NoneCreditCard 沒有任何折扣。

在 CreditCard 類中，Gold、Silver、Standard 和 None 是四個靜態(tài)實例，表示四種不同的信用卡類型。每個實例都是通過相應的子類創(chuàng)建的，并傳入相應的值和名稱。值用于標識枚舉類型的唯一性，而名稱則是該類型的字符串表示。

通過這種方式，我們可以輕松地定義和使用不同類型的信用卡。例如，可以通過 CreditCard.Gold 來引用 Gold 信用卡的實例，并獲取它的折扣率。在需要使用信用卡類型的地方，也可以直接使用 CreditCard 類型來表示。

我們平時也可以這樣使用，通過 FromName 和 FromValue：

public class SmartEnumsTests
{
    private readonly ITestOutputHelper _testOutputHelper;
    public SmartEnumsTests(ITestOutputHelper testOutputHelper)
    {
        _testOutputHelper = testOutputHelper;
    }
    /// <summary>
    /// 基本用法
    /// </summary>
    [Fact]
    public void Use()
    {
        var standardCard = CreditCard.FromName("Standard");
        var standardCard2 = CreditCard.FromValue(1);
        Assert.Equal(standardCard, standardCard2);
        _testOutputHelper.WriteLine(standardCard!.ToJson());
    }
}

看完上述的示例代碼，智能枚舉最明顯的好處應該非常直觀：就是代碼行數(shù)增加了億點點，而不是一點點！