c#单例代码重用

我有许多类在做不同的事情，但使用的是相同的单例模式

有没有人有一个简洁的方法可以让我在不同的类之间尽可能多地重用常见的单例代码

例如，如果我有SingletonJob1和SingletonJob2，我希望只有在移动到另一个Singleton模式时，才能在适当的位置更改代码

编辑：是的，正如人们指出的，方法5的代码更少。我确实读到了这一页的结尾！我选择方法2是因为单例对象与硬件设备相关，我只想初始化其中的两个，并在任何给定的程序运行中使用它们。方法5将立即对它们进行初始化。

试试看：

公共静态类单例，其中T:new（）
{
静态T实例=null；
静态只读对象挂锁=新对象（）；
公共静态T实例
{
得到
{
锁（挂锁）
{
if（实例==null）
{
实例=新的T（）；
}
返回实例；
}
}
}
}

因此，您可以对所有类使用单例：

Singleton<YourClass>.Instance.YourMethod();

Singleton.Instance.YourMethod（）；

像这样的东西

public sealed class Singleton<T>
{
static T instance=null;
static readonly object padlock = new object();
static Func<T> createInstance;

Singleton(Func<T> constructor)
{
   createInstance = constructor;
}

public static T Instance
{
    get
    {
        lock (padlock)
        {
            if (instance==null)
            {
                instance = createInstance();
            }
            return instance;
        }
    }
}
}

公共密封类单例
{
静态T实例=null；
静态只读对象挂锁=新对象（）；
静态Func创建实例；
单例（Func构造函数）
{
createInstance=构造函数；
}
公共静态T实例
{
得到
{
锁（挂锁）
{
if（实例==null）
{
instance=createInstance（）；
}
返回实例；
}
}
}
}

您使用该版本而不是仅在声明中初始化实例的更简单版本有什么原因吗

public class Singleton
{
    private static Singleton instance = new Singleton();
    public static Singleton Instance { get { return instance; } }

    // Only use this if you really need it - see the page for details
    static Singleton() {}

    private Singleton()
    {
        // I assume this logic varies
    }
}

这个模式足够短，所以我不认为在任何地方都包含它是一个很大的问题

我劝你考虑一下你是否真的需要那么多单身汉；它们通常不适合测试性等

编辑：如果你真的非常想要懒惰，并且你正在使用.NET 4，那么你可以使用第6种模式来获得它，该模式为：

公共密封类单例
{
私有静态只读惰性=
新的懒惰（（）=>newsingleton（））；
公共静态单例实例{get{return lazy.Value；}}
私人单身人士（）
{
}
}

我相信这就是你想要的。然而，我强烈建议避免这种单例（大写S）模式，因为它会压碎所有单元测试的灵魂，并使大量的事情难以控制

public class Singleton<T> where T : new()
{
  private static T _Instance;
  private static readonly object _InstanceLock = new object();

  public static T Instance
  {
    get
    {
      if (_Instance == null)
      {
        lock (_InstanceLock)
        {
          if (_Instance == null)
          {
            _Instance = new T();
          }
        }
      }
      return _Instance;
    }
  }

}

public class Foo : Singleton<Foo>
{
  public void Something()
  {
  }
}

public class Example
{
  public static void Main()
  {
    Foo.Instance.Something();
  }
}

公共类单例，其中T:new（）
{
私有静态T_实例；
私有静态只读对象_InstanceLock=new object（）；
公共静态T实例
{
得到
{
if（_Instance==null）
{
锁定（_InstanceLock）
{
if（_Instance==null）
{
_实例=新的T（）；
}
}
}
返回_实例；
}
}
}
公共课Foo：单身
{
公之于众
{
}
}
公开课范例
{
公共静态void Main（）
{
Foo.Instance.Something（）；
}
}

什么是重用？实现其他单例？当查看该页面时，您是否注意到首选第4/5版？这是第二个版本。。。特别是第四版的代码太少了，复制它根本没有什么坏处；“通用单例”不具备使其成为单例的基本保证。这只是一个“通用静态默认实例”——而不是same@dig，程序员应该在单音成为片段的那一天自杀。使用IoC，摆脱以这种方式编写的单例。我不认为这是他想要的，但在这一点上，

YourClass

必须有一个公共的无参数构造函数，这意味着它不是真正的单例。它应该是“static t instance=default（t）；”或“public static class singleton where t:class，new（）”为了避免错误，这是如何使它成为单身的呢？简单地说：没有。谢谢你的回答，Jon，但我不想在代码第一次运行时对它们进行初始化，这发生在方法5中。方法2在该区域提供了更多的控制。@Richard:别忘了，它只会在首次使用该类型时运行。你真的在使用类型的其余部分而不使用它的实例吗？@Guillaume:问题中引用的页面。单元测试？那是什么？开玩笑，但谢谢你的建议。

public class Singleton
{
    private static Singleton instance = new Singleton();
    public static Singleton Instance { get { return instance; } }

    // Only use this if you really need it - see the page for details
    static Singleton() {}

    private Singleton()
    {
        // I assume this logic varies
    }
}

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy =
        new Lazy<Singleton>(() => new Singleton());

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

    private Singleton()
    {
    }
}

public class Singleton<T> where T : new()
{
  private static T _Instance;
  private static readonly object _InstanceLock = new object();

  public static T Instance
  {
    get
    {
      if (_Instance == null)
      {
        lock (_InstanceLock)
        {
          if (_Instance == null)
          {
            _Instance = new T();
          }
        }
      }
      return _Instance;
    }
  }

}

public class Foo : Singleton<Foo>
{
  public void Something()
  {
  }
}

public class Example
{
  public static void Main()
  {
    Foo.Instance.Something();
  }
}