带参数的单例

Question

我需要使用一些参数来实例化一个单例类。我现在的做法是：

class SingletonExample
{
     private SingletonExample mInstance;
     //other members... 
     private SingletonExample()
     {

     } 
     public SingletonExample Instance
     {
         get
         {
              if (mInstance == null)
              {
                  throw new Exception("Object not created");
              }
              return mInstance;
         }
     }

     public void Create(string arg1, string arg2)
     {
         mInstance = new SingletonExample();
         mInstance.Arg1 = arg1;
         mInstance.ObjectCaller = new ObjectCaller(arg2);
         //etc... basically, create object...
     } 
}

实例是“延迟”创建的，这意味着我在应用启动时没有所有需要的参数。

一般来说，我不喜欢强制对方法调用进行排序，但在这里我看不到其他方法。 IoC 也不会解决它，因为我可以在容器中注册它，我也可以调用 Create()...

您认为这是一个可行的方案吗？你有别的想法吗？

编辑：我知道我写的例子不是线程安全的，线程安全不是问题的一部分

Answer 1

Singleton 很丑，但由于用户 whateva 懒得更正自己的代码...

public class Singleton 
{ 
    private static Singleton _instance = null; 

    private static Object _mutex = new Object();

    private Singleton(object arg1, object arg2) 
    { 
        // whatever
    } 

    public static Singleton GetInstance(object arg1, object arg2)
    { 
        if (_instance == null) 
        { 
          lock (_mutex) // now I can claim some form of thread safety...
          {
              if (_instance == null) 
              { 
                  _instance = new Singleton(arg1, arg2);
              }
          } 
        }

        return _instance;
    }
}  

Skeet 几年前在博客上写过，我认为它非常可靠。没有必要例外，您无需记住哪些对象应该是单例对象并在错误时处理后果。

编辑：类型不相关使用你想要的，object 只是为了方便而在这里使用。

Answer 2

一个带有参数的单例对我来说闻起来很腥。

考虑 whateva 的回答和以下代码：

Singleton x = Singleton.getInstance("hello", "world");
Singleton y = Singleton.getInstance("foo", "bar");

显然，x==y 和 y 与 x 的创建参数一起工作，而 y 的创建参数被简单地忽略。结果可能......至少令人困惑。

如果你真的、真的觉得你必须这样做，那就这样做吧：

class SingletonExample
{
     private static SingletonExample mInstance;
     //other members... 
     private SingletonExample()
     {  // never used
        throw new Exception("WTF, who called this constructor?!?");
     }
     private SingletonExample(string arg1, string arg2)
     {
         mInstance.Arg1 = arg1;
         mInstance.ObjectCaller = new ObjectCaller(arg2);
         //etc... basically, create object...    
     } 
     public static SingletonExample Instance
     {
         get
         {
              if (mInstance == null)
              {
                  throw new Exception("Object not created");
              }
              return mInstance;
         }
     }

     public static void Create(string arg1, string arg2)
     {
         if (mInstance != null)
         {
             throw new Exception("Object already created");
         }
         mInstance = new SingletonExample(arg1, arg2);             
     } 
}

在多线程环境中，添加同步以避免竞争条件。

Answer 3

更好的答案：

1. 创建一个界面：ISingleton（包含您希望它执行的任何操作）

2. 还有你的类型：Singleton : ISingleton

3. 假设您可以访问 UnityContainer：

IUnityContainer _singletonContainer = new UnityContainer(); // or whatever code to initialize the container

1. 当您准备好创建类型时（假设您使用 Unity for DI）：

_singletonContainer.RegisterType(typeof(ISingleton), new Singleton(params));

1. 如果您想获取单例，只需使用：

var localSingletonVar = _singletonContainer.Resolve<ISingleton>();

注意：如果容器没有为 ISingleton 接口注册类型，那么它应该要么抛出异常，要么返回 null。

旧答案：

public class Singleton
{

    private static Singleton instance = null;

    private Singleton(String arg1, String arg2)
    {
    }

    public static Singleton getInstance(String arg1, String arg2)
    {
        if (instance != null)
        {
            throw new InvalidOperationException("Singleton already created - use getinstance()");
        }
        instance = new Singleton(arg1, arg2);
        return instance;
    }

    public static Singleton getInstance()
    {
        if (instance == null)
            throw new InvalidOperationException("Singleton not created - use GetInstance(arg1, arg2)");
        return instance;
    }
}

我会使用类似的东西（您可能需要检查是否也创建了实例），或者，如果您的 DI 容器支持在未注册的类型上抛出异常，我会使用它。

ATTN：非线程安全代码:)

Answer 4

annakata 提供的双锁单例解决方案并非每次都适用于所有平台。这种方法有一个缺陷，有据可查。不要使用这种方法，否则你会遇到问题。

解决此问题的唯一方法是使用 volatile 关键字，例如

private static volatile Singleton m_instance = null;

这是唯一的线程安全方法。

Answer 5

/// <summary> Generic singleton with double check pattern and with instance parameter </summary>
/// <typeparam name="T"></typeparam>
public class SingleObject<T> where T : class, new()
{
    /// <summary> Lock object </summary>
    private static readonly object _lockingObject = new object();

    /// <summary> Instance </summary>
    private static T _singleObject;

    /// <summary> Protected ctor </summary>
    protected SingleObject()
    {
    }

    /// <summary> Instance with parameter </summary>
    /// <param name="param">Parameters</param>
    /// <returns>Instance</returns>
    public static T Instance(params dynamic[] param)
    {
        if (_singleObject == null)
        {
            lock (_lockingObject)
            {
                if (_singleObject == null)
                {
                    _singleObject = (T)Activator.CreateInstance(typeof(T), param);
                }
            }
        }
        return _singleObject;
    }
}

Answer 6

我实际上在您的代码中看不到单例。 使用静态的、参数化的 getInstance 方法，该方法返回单例并在之前未使用时创建它。