C#泛型設計的一個小陷阱.

距離上次發表博客已經有幾年了. 對於沒能堅持更新博客,實在是感覺到甚是慚愧. 

閑言少敘, 直接切入主題.

背景

最近一直在對於公司一個網絡通信服務程序使用.net core 進行重構.重構的目的有兩個:一是讓程序能夠跨平台運行. 二是優化程序代碼結構是程序的可維護性有所提升.  重構的過程主要由我來設計底層的架構. 在這個過程中,由於我對C# 泛型的理解還不夠深入,所以在這個方面我就犯了個錯誤. 希望本文能把我犯的這個錯誤闡述清楚, 如果能幫助園里其他朋友避免這個問題當然是最好的了.

早前的設計

先用一張圖來描述早前的代碼結構

Singleton<T>:是一個單例的基類, 用來實現單例模式.

Base<T>:則是一個基礎類,它有一些靜態的屬性和方法(例如訪問Redis,kafka,數據庫等). 這些屬性和方法提供給 Child1 和 Child2 去使用.

Child1 和Child2: 相當於不同模塊的業務邏輯實現.

 

我期望的結果是Base<T>里面的靜態成員在整個程序運行期間只有一份.

 

 代碼的實現

Singleton

    public abstract class Singleton<T> where T : new()
    {
        /// <summary>
        /// 鎖定對象
        /// </summary>
        private static readonly object locker = new object();
        /// <summary>
        /// T 的實例
        /// </summary>
        static T instance = default(T);
        /// <summary>
        /// T 的實例
        /// </summary>
        public static T Instance
        {
            get
            {
                if (null == instance)
                {
                    lock (locker)
                    {
                        if (null == instance)
                        {
                            instance = new T();
                        }
                    }
                }
                return instance;
            }
        }
    }

Base

public class Base<T> : Singleton<T> where T : new()
{
    protected static object Object { set; get; }

    static Base()
    {
        Object = new object();
    }
}

Child1 和Child2

public class Child1 : Base<Child1>
{
}

public class Child2 : Base<Child2>
{
}

 

 

 

我以為 Base的靜態構造函數只會執行一次. 可是當我在程序里使用 Child1.Instance 和 Child2.Instance 時發現, Base的靜態構造函數被執行了2次. 那么Child1.Instance的Object和Child2.Instance的Object對象一定不是同一個.

那么問題出現在什么地方了呢? 答案其實挺簡單的:系統認為 Base<Child1> 和 Base<Child2>並不相同. 相當於在系統里定義了Base_Child1 和Base_Child2兩個類. 如果我們這么理解這個問題 ,那么Base的靜態構造函數被執行了2次就不難理解了.(我覺得我已經把這個問題的成因描述清楚了,如果您沒理解,歡迎在下面評論.)

如果要達到我設計的目標應該怎么做呢?

修正的設計

還是先上類圖.

Base:

public class Base
{
    protected static object Object { set; get; }

    static Base()
    {
       Object = new object();
    }
}

Singleton:

public abstract class Singleton<T>: Base where T : new()
{
        /// <summary>
        /// 鎖定對象
        /// </summary>
        private static readonly object locker = new object();
        /// <summary>
        /// T 的實例
        /// </summary>
        static T instance = default(T);
        /// <summary>
        /// T 的實例
        /// </summary>
        public static T Instance
        {
            get
            {
                if (null == instance)
                {
                    lock (locker)
                    {
                        if (null == instance)
                        {
                            instance = new T();
                        }
                    }
                }
                return instance;
            }
        }
}

Child1 和Child2:

public class Child1 : Singleton<Child1>
{
}

public class Child2 : Singleton<Child2>
{
}

 

由Singleton 來繼承Base.然后Child1 和Child2來繼承Singleton. 這樣問題就都解決了.