29

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

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() { .... }
}

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

单例模式存在以下挑战。

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

问题

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

4

8 回答 8

58

您可以使用自引用泛型类型约束和“ 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!
}

当然，如果您希望您的单例是通用的，您还应该稍微更改您的“创建单例实例”代码，以使用“双重检查锁”模式或Lazy类，使其成为线程安全的。

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

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

于 2013-05-25T02:06:10.887 回答
14

真正的解决方案是从 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() { }
}

完整的实现示例在这里

于 2017-09-24T01:37:05.867 回答
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;
        }
    }
}

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

于 2016-04-21T16:07:49.640 回答
4

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

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

于 2013-05-25T02:02:52.717 回答
2

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

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() { }
    }

}
于 2013-05-25T02:10:54.163 回答
2

我相信使用@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; } }

}
于 2019-02-13T17:40:02.120 回答
0

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

https://stackoverflow.com/a/20599467

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

于 2013-12-15T22:22:40.493 回答
0

我建议的例子：

基类

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();

有关更多信息，请参阅此链接中的我的答案来源

于 2018-05-08T04:24:19.797 回答