封装：实现单例、多例模式，业务层继承调用

1、简介：采用继承的方法实现快速扩展单例、多例

2、目的：单例扩展方便、调用单例、多例方便

3、实现

using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using System.Text;

namespace HebianGu.ComLibModule.Factory
{

    /// <summary> 单例工厂父类</summary>
    public class BaseFactory<T> : IDisposableBF where T : class,new()
    {

        #region - Start 单例模式 -

        /// <summary> 单例模式 </summary>
        private static T t = null;

        /// <summary> 多线程锁 </summary>
        private static object localLock = new object();

        /// <summary> 创建指定对象的单例实例 </summary>
        public static T Instance
        {
            get
            {
                if (t == null)
                {
                    lock (localLock)
                    {
                        if (t == null)
                            return t = new T();
                    }
                }
                return t;
            }
        }

        #endregion - 单例模式 End -

        #region - Start 多例模式 -

        /// <summary> 多例模式 </summary>
        static Dictionary<string, T> cache = null;

        /// <summary> 通过名称得到多例实例 </summary>
        public static T InstanceByName(string strKey)
        {
            lock (localLock)
            {
                if (cache == null)
                    cache = new Dictionary<string, T>();

                if (!cache.ContainsKey(strKey))
                    cache.Add(strKey, new T());

                return cache[strKey];
            }

        }

        #endregion - 多例模式 End -

        /// <summary> 外部不可以构造 </summary>
        protected BaseFactory()
        { }



        #region - 资源清理 -

        /// <summary> 供程序员显式调用的Dispose方法 </summary>
        public void Dispose()
        {
            //  调用带参数的Dispose方法，释放托管和非托管资源
            Dispose(true);

            //  手动调用了Dispose释放资源，那么析构函数就是不必要的了，这里阻止GC调用析构函数
            System.GC.SuppressFinalize(this);
        }


        protected void Dispose(bool disposing)
        {
            if (disposing)
            {
                ///TODO:在这里加入清理"托管资源"的代码，应该是xxx.Dispose();
                t = null;
            }
            ///TODO:在这里加入清理"非托管资源"的代码
        }

        /// <summary> 清理指定名称的缓存和单例 </summary>
        public void Dispose(string name)
        {
            Dispose(true);

            if (cache != null && cache.ContainsKey(name))
            {
                cache.Remove(name);
            }
        }

        /// <summary> 清理指定名称的缓存和单例 </summary>
        public static void Dispose(Predicate<KeyValuePair<string, T>> macth)
        {
            foreach (KeyValuePair<string, T> v in cache)
            {
                if (macth(v))
                {
                    cache.Remove(v.Key);
                }
            }
        }

        /// <summary> 供GC调用的析构函数 </summary>
        ~BaseFactory()
        {
            //  释放非托管资源
            Dispose(false);
        }

        #endregion

    }

    public interface IDisposableBF : IDisposable
    {
        void Dispose(string name);
    }
}

4,、用例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;

namespace HebianGu.ComLibModule.Factory
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            TestDemo.Instance.WriteLine("使用Instance单例调用");

            TestDemo.InstanceByName("调用多例一").WriteLine(Environment.UserName);

            TestDemo.InstanceByName("调用多例二").WriteLine(Environment.UserName);
        }
    }

    class TestDemo : BaseFactory<TestDemo>
    {
        public void WriteLine(string str)
        {
            Console.WriteLine(MethodInfo.GetCurrentMethod().Name + "   :   " + str);
        }
    }
}