如何抽象一个单例类？

Question

这就是我编写单例类的方式。

public class MyClass
{
    /// <summary>
    /// Singleton
    /// </summary>
    private static MyClass instance;

    /// <summary>
    /// Singleton access.
    /// </summary>
    public static MyClass Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new MyClass();
            }
            return _instance;
        }
    }

    private MyClass() { .... }
}

如何创建可重用的单例模式？

单例模式存在以下挑战。

• 构造函数是private或protected。
• 基类不能实例化继承类。所以你可以重用一个通用的摘要MyAbstractSingletonClass。
• 它必须具有本地只读属性才能获取实例。

问题

我在许多类上都使用了这种模式，并且总是必须编写相同的代码。当我需要一个单例时，如何编写可以重用的东西？

Answer 1

真正的解决方案是从 BTownTKD 的方法开始，但通过 Activator.CreateInstance 方法对其进行扩充，该方法允许您的子类保留私有构造函数。

父类

public abstract class SingletonBase<T> where T : SingletonBase<T>
{
    private static readonly Lazy<T> Lazy =
        new Lazy<T>(() => Activator.CreateInstance(typeof(T), true) as T);

    public static T Instance => Lazy.Value;
}

儿童班

public sealed class MySingleton : SingletonBase<MySingleton>
{
    private MySingleton() { }
}

Full Implementation Example Here

Answer 2

您可以使用self-referencing generic type constraint 和“new()”类型约束的组合来实现此目的。

“new”约束确保任何子类始终具有无参数构造函数，因此_instance = new T(); 将始终有效。

自引用类型约束确保“Instance”静态属性始终返回正确的类型；不是“基础”类型。你的单例基类看起来像这样：

public abstract class SingletonBase<T> 
    where T : SingletonBase<T>, new()
{
    private static T _instance = new T();
    public static T Instance
    {
        get
        {                
            return _instance;
        }   
    }
}

您的子类将如下所示：

public class MyChildSingleton : SingletonBase<MyChildSingleton>
{
    //Done!
}

当然，如果你想让你的单例是通用的，你也应该稍微改变你的“创建单例实例”代码，使用“double-check lock”模式，或者Lazy类来实现线程安全。

最大的警告：如果你使用这个方法，“new()”约束几乎可以确保你的类总是有一个公共的、无参数的构造函数。这意味着您的最终用户可以随时调用new MyChildSingleton()，如果他们真的想要，完全绕过您的单例实例。您的单身人士将是“按照惯例”，而不是严格执行。要解决这个问题需要更多的工程。在上述场景中，约定似乎是您应该将静态实例命名为“Default”而不是“Instance”。这巧妙地传达了这样一个事实，即您的类提供了一个“建议的”单例实例，但使用它在技术上是可选的。

我做了一些尝试来严格执行单例模式，最终结果是使用反射来手动调用私有构造函数。你可以看到我的完整代码尝试here。

Answer 3

在基类中实现单例模式是一种值得商榷的做法。

但是，您可以实现其他可能适合您要完成的任务的创建设计模式。例如，看看Abstract Factory。

Answer 4

我相信通过@Buvy 的解决方案，您将获得每个线程的一个实例，这可能是他想要的。您必须稍微修改一下才能跨线程获取单个实例。

public abstract class BaseSingleton<T> 
    where T : BaseSingleton<T>
{
    private static readonly Lazy<T> lazy =
                    new Lazy<T>(() => Activator.CreateInstance(typeof(T), true) as T);

    public static T Instance { get { return lazy.Value; } }

}

Answer 5

添加到 BTownTKD 的答案，在运行时限制构造函数调用实际上非常简单（在编译中不确定可能）。您所做的只是在 SingletonBase 中添加一个受保护的构造函数，如果 _instance 不为空，它会引发异常。即使构造函数是从外部调用的第一件事，也会抛出异常。

我设法在单例基础上应用了这项技术，并使其变得惰性和线程安全，如下所述：http://csharpindepth.com/Articles/General/Singleton.aspx

结果（附用法说明）：

/// <summary>
/// Generic singleton class, providing the Instance property, and preventing manual construction.
/// Designed as a base for inheritance trees of lazy, thread-safe, singleton classes.
/// Usage:
/// 1. Sub-class must use itself, or its sub-class, as the type parameter S.
/// 2. Sub-class must have a public default constructor (or no constructors).
/// 3. Sub-class might be abstract, which requires it to be generic and demand the generic type
///    have a default constructor. Its sub-classes must answer all these requirements as well.
/// 4. The instance is accessed by the Instance getter. Using a constructor causes an exception.
/// 5. Accessing the Instance property in an inner initialization in a sub-class constructor
///    might cause an exception is some environments.
/// </summary>
/// <typeparam name="S">Lowest sub-class type.</typeparam>
public abstract class Singleton<S> where S : Singleton<S>, new()
{
    private static bool IsInstanceCreated = false;
    private static readonly Lazy<S> LazyInstance = new Lazy<S>(() =>
        {
            S instance = new S();
            IsInstanceCreated = true;
            return instance;
        });

    protected Singleton()
    {
        if (IsInstanceCreated)
        {
            throw new InvalidOperationException("Constructing a " + typeof(S).Name +
                " manually is not allowed, use the Instance property.");
        }
    }

    public static S Instance
    {
        get
        {
            return LazyInstance.Value;
        }
    }
}

我必须说我没有做过密集的多线程测试，但正如一些人已经说过的，你总是可以使用旧的双重检查技巧。

Answer 6

我建议的例子：

基类

public abstract class SingletonBase<T> where T : class
{
  private static readonly Lazy<T> sInstance = new Lazy<T>(() => CreateInstanceOfT());

  public static T Instance { get { return sInstance.Value; } }

  private static T CreateInstanceOfT()
  {
    return Activator.CreateInstance(typeof(T), true) as T;
  }
}

用法

public class yourClass : SingletonBase<yourClass>
{
   public yourMethod()
   {
   }
}

像这样使用你的单例类：

yourClass.Instance.yourMethod();

有关更多信息，请参阅我在this link 中的答案来源

Answer 7

你是对的——就目前的情况而言，你无法做到这一点。但是您可以使用泛型来处理它，请注意，使用这种方法您将获得每个唯一派生类型的一个单例实例：

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            var x = new MyDerivedClass();
            Console.WriteLine(x.ToString());
            Console.WriteLine(x.Instance.ToString());

            Console.ReadKey();
        }
    }


    public abstract class MyBaseClass<T> where T : class, new()
    {
        protected T GetInstance()
        {
            if (_instance == null)
            {
                lock (_lockObj)
                {
                    if (_instance == null)
                        _instance = new T();
                }
            }
            return _instance;
        }

        public T Instance
        {
            get { return GetInstance(); }
        }

        private volatile static T _instance;
        private object _lockObj = new object();
    }

    public class MyDerivedClass : MyBaseClass<MyDerivedClass>
    {
        public MyDerivedClass() { }
    }

}

Answer 8

我最近对一个相关问题提出了这个答案：

https://stackoverflow.com/a/20599467

使用此方法，基类管理派生类的所有实例的创建，因为所有派生类构造函数都需要一个只有基类可以提供的对象，并且不需要无参数构造函数的限制。