【wif系列】C#之單例模式（Singleton Pattern）最佳實踐

目錄

• 前言
• 單例基類
• 單例提供者
• 總結

前言

在上一篇譯文——《深入理解C#——在C#中實現單例模式》中，對在C#中實現單例模式進行了詳細闡述。我們在日常的開發中可以采用解決方案4或解決方案6來實現單例模式，但每個單例類都需要單獨實現。

我們再來看看使用單例模式的一些場景：

主要意圖：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點。
主要解決：一個全局使用的類頻繁地創建與銷毀。
何時使用：當您想控制實例數目，節省系統資源的時候。
使用場景：

1. 要求生產唯一序列號；
2. WEB 中的計數器，不用每次刷新都在數據庫里加一次，用單例先緩存起來；
3. 創建的一個對象需要消耗的資源過多，比如 I/O 與數據庫的連接等；
4. 全局配置文件訪問，單例類來保證數據唯一性；
5. 日志記錄幫助類，為節省資源，全局一個實例一般就夠了；
6. 桌面應用常常要求只能打開一個程序實例或一個窗口。

單例基類

可以看到單例模式在程序開發中是非常常見的。既然我們會頻繁的使用單例模式，那么有沒有什么方式可以更方便的生產我們的單例。當然有，我們往下看。

對於沒有基類的一些類的單例模式實現，可以考慮繼承自單例基類。由單例基類派生的類必須是密封類，它確保您不能從這個單例類創建子類。單例的生產就由基類來完成，派生類只需要定義一個無參數的私有構造函數即可，它確保不能在外部創建此類的實例。通過調用繼承的實例屬性訪問類的單例實例和公共成員。

    /// <summary>
    /// 總括來說，為了使用單例基類創建單例類，您需要執行以下操作:
    /// 
    /// 1) 定義一個派生自SingletonBase [T]的密封類，其中T是您定義的類名。 它確保您不能從此單例類創建子類。
    /// 2) 在類中定義一個無參數的私有構造函數。它確保不能在外部創建此類的實例。
    /// 3) 通過調用Instance屬性來訪問類的單例實例和公共成員。
    /// 
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class SingletonBase<T> where T : class
    {
        #region Properties

        /// <summary>
        /// 獲取該類的單例實例。
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
        public static T Instance => SingletonFactory.Instance;

        #endregion

        #region Constructors

        #endregion

        /// <summary>
        /// 創建單例實例的單例類工廠。
        /// </summary>
        private class SingletonFactory
        {
            #region Fields

            /// <summary>
            /// 定義弱引用實例。
            /// </summary>
            private static WeakReference _instance;

            #endregion

            #region Properties

            /// <summary>
            /// 獲取實例。
            /// </summary>
            internal static T Instance
            {
                get
                {
                    if (!(_instance?.Target is T comparer))
                    {
                        comparer = GetInstance();
                        _instance = new WeakReference(comparer);
                    }

                    return comparer;
                }
            }

            #endregion

            #region Constructors

            /// <summary>
            /// 防止編譯器生成默認構造函數。
            /// </summary>
            private SingletonFactory()
            {
            }

            /// <summary>
            /// 顯式靜態構造函數，告訴c#編譯器不要將類型標記為BeforeFieldInit。
            /// </summary>
            [SuppressMessage("Microsoft.Performance", "CA1810:InitializeReferenceTypeStaticFieldsInline")]
            static SingletonFactory()
            {
            }

            #endregion

            #region Methods

            /// <summary>
            /// 獲取特定類型的實例。
            /// </summary>
            /// <returns>The <see cref="T"/></returns>
            [SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId =
                    "System.Type.InvokeMember")]
            private static T GetInstance()
            {
                var theType = typeof(T);

                T inst;

                try
                {
                    inst = (T) theType.InvokeMember(theType.Name,
                            BindingFlags.CreateInstance | BindingFlags.Instance | BindingFlags.NonPublic,
                            null, null, null,
                            CultureInfo.InvariantCulture);
                }
                catch (MissingMethodException ex)
                {
                    throw new TypeLoadException(
                            string.Format(CultureInfo.CurrentCulture,
                                    "The type '{0}' must have a private constructor to be used in the Singleton pattern.",
                                    theType.FullName), ex);
                }

                return inst;
            }

            #endregion
        }
    }

在SingletonBase 中我們用到了WeakReference ，它表示弱引用，即在引用對象的同時仍然允許通過垃圾回收來回收該對象。一般使用場景：對象過大，並且不經常訪問。這樣我們就可以創建一個弱引用，當不常用該對象的時候，GC可以回收該對象，當需要引用對象，可以先判斷弱引用的對象是不是存在，如果存在，就直接使用，如果弱引用的對象已經被回收，那就重新創建一個對象來使用。對於單例對象來說，一般生命周期和應用程序域同步，是無法自動回收的。通過使用WeakReference 來確保單例對象在長時間未使用時可以自動釋放資源。

當然這里的WeakReference 也可以替換為Lazy ，根據是否需自動回收單例對象和子類是否包含屬性和字段這兩個方面來選擇。如子類中包含屬性和字段，則自動回收會導致屬性和字段值重置，從而出現不可預估的后果。

單例提供者

對於有基類的類來說，上面的單例基類顯然是不合適的。我們可以考慮實現一個單例提供者來生產我們的單例。

通過泛型類傳參的方式實現如下：

    /// <summary>
    /// 用於從另一個類創建或獲取單例的靜態助手。
    /// </summary>
    /// <typeparam name="T">要創建或獲取單例的類型。</typeparam>
    public static class SingletonProvider<T> where T : class, new()
    {
        #region Fields

        /// <summary>
        /// 獲取給定類型的單例。
        /// </summary>
        private static readonly Lazy<T> _lazy = new Lazy<T>(() => new T());

        #endregion

        #region Properties

        /// <summary>
        /// 獲取給定類型的單例。
        /// </summary>
        public static T Instance => _lazy.Value;

        #endregion
    }

除了泛型類傳參，還可以通過Get方法傳參，實現如下：

    /// <summary>
    /// 用於從另一個類創建或獲取單例的靜態助手。
    /// </summary>
    public static class SingletonProvider
    {
        #region Methods

        /// <summary>
        /// 獲取指定類型的單例。
        /// </summary>
        /// <typeparam name="TParameter">單例類型。</typeparam>
        /// <returns>The <see cref="TParameter" />單例對象。</returns>
        public static TParameter Get<TParameter>() where TParameter : class, new()
        {
            return SingletonProvider<TParameter>.Instance;
        }

        #endregion
    }

總結

有了以上兩種生產單例的方式，我們可以在開發中愉快的使用單例，而免除了具體的繁瑣實現。

wif 項目代碼：https://github.com/LeoYang-Chuese/wif