如何为泛型创建一个完全惰性的单例

Question

我的通用单例提供程序有以下代码实现：

public sealed class Singleton<T> where T : class, new()
{
     Singleton()
     {
     }

     public static T Instance
     {
          get { return SingletonCreator.instance; }
     }

     class SingletonCreator
     {
          static SingletonCreator()
          {
          }

          internal static readonly T instance = new T();
     }
}

此示例取自 2 篇文章，我合并了代码以获得我想要的：

http://www.yoda.arachsys.com/csharp/singleton.html 和 http://www.codeproject.com/Articles/11111/Generic-Singleton-Provider.

这就是我尝试使用上面代码的方式：

public class MyClass
{
     public static IMyInterface Initialize()
     {
          if (Singleton<IMyInterface>.Instance == null  // Error 1
          {
               Singleton<IMyInterface>.Instance = CreateEngineInstance();  // Error 2
               Singleton<IMyInterface>.Instance.Initialize();
          }

          return Singleton<IMyInterface>.Instance;
     }
}

还有界面：

public interface IMyInterface
{
}

Error 1 的错误是：

'MyProject.IMyInterace' must be a non-abstract type with a public parameterless constructor in order to use it as parameter 'T' in the generic type or method 'MyProject.Singleton<T>'

Error 2 的错误是：

Property or indexer 'MyProject.Singleton<MyProject.IMyInterface>.Instance' cannot be assigned to -- it is read only

我该如何解决这个问题，使其符合上述 2 篇文章？任何其他想法或建议表示赞赏。

我的实现是否打破了单例模式？

Answer 1

基本上，你已经在你的单例类上给出了一个类约束，以及 new() 约束。

写的时候

Singleton<IMyInterface>

您使用的接口类型为 T，这违反了您定义的类型约束。

对于错误 2，

Singleton<IMyInterface>.Instance = CreateEngineInstance();

您正在尝试为只读属性赋值。因此，您需要在您的 Instance 属性上定义一个 setter 才能使该行正常工作。

更新

这些方面的东西应该为你做：

public sealed class Singleton
{
     private static Hashtable bindings = new Hashtable();
     private static Hashtable instances = new Hashtable();

     private static void checkType(Type requested, Type bound)
     {
        if (requested.IsValueType)
            throw new Exception("Cannot bind a value type to a reference type");

        // also check type inheritance and other things...
     }

     private static void checkBinding(Type requested)
     {
        if (!(bindings.ContainsKey(requested)))
            throw new Exception(String.Format("Type {0} was not bound !", requested.FullName));
     }

     public static void Bind<T, U>() where U : class, new() 
     {
        checkType(typeof(T), typeof(U));
        bindings[typeof(T)] = typeof(U);
     }

     public static T GetInstance<T>() 
     {
        Type requested = typeof(T);
        Type bound = (Type) bindings[requested];

        checkBinding(requested);

        if (!instances.ContainsKey(requested)) {
            // We know that type "bound" was set with a new() class constraint
            instances[requested] = (T) Activator.CreateInstance(bound);
        }

        return (T) instances[requested];
     }
}

然后你可以写：

 Singleton.Bind<IMyInterface, MyClass>();
 IMyInterface instance = Singleton.GetInstance<IMyInterface>();

如果您想更进一步，您还可以指定此提供程序创建的对象的生命周期，以便您可以使用单例，或者让提供程序为每次调用返回一个新对象，等等。

您还应该看看依赖注入模式，它似乎接近您想要实现的目标，还应该看看已经这样做的现有 DI 框架（NInject、Nhibernate）等等。

Answer 2

当然，你有一个问题。你的通用是假设上课，而不是接口。

internal static readonly T instance = new T();

您的代码假设要创建该类的实例，您无法实例化接口类型。

所以，如果你需要某种类型作为单音，你应该写：

Singleton<MyInterface>.Instance

在哪里

public class MyInterface : IMyInterface { }

那么您的代码中不需要任何“if”，因为单例负责实例化一个对象并将其保留为一个实例。

与问题无关：目前 Singletone 被许多开发人员视为“代码气味”，因此通常您必须避免使用它们。试着认为你的应用程序根本没有 Singletone。