public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();
    static Singleton() {} // Make sure it s truly lazy
    private Singleton() {} // Prevent instantiation outside

    public static Singleton Instance { get { return instance; } }
}

这并不困难。

单吨对静态成员的优势是,这一类别能够实施接口等。 有时,这种情况是有益的,但有时,静态成员也确实如此。 此外,从单一州到非单一州通常比较容易,例如,在单一州作为“组合”反对依赖等级,而不是那些直接静态电话的依赖等级。

我个人设法尽可能避免使用单一州,除了别的以外,它们使检测更加困难。 有时它们可能有用。

有几个模式可能适合你,一个单一州是更糟糕的。

<>Registry

struct Data {
  public String ProgramName;
  public String Parameters;
}

class FooRegistry {
  private static Dictionary<String, Data> registry = new Dictionary<String, Data>();
  public static void Register(String key, Data data) {
     FooRegistry.registry[key] = data;
  }
  public static void Get(String key) {
     // Omitted: Check if key exists
     return FooRegistry.registry[key];
  }
}

Advantages

• Easy to switch to a Mock Object for automated testing
• You can still store multiple instances but if necessary you have only one instance.

Disadvantages

• Slightly slower than a Singleton or a global Variable

<>Static Level

class GlobalStuff {
  public static String ProgramName {get;set;}
  public static String Parameters {get;set;}
  private GlobalStuff() {}
}

Advantages

• Simple
• Fast

Disadvantages

• Hard to switch dynamically to i.e. a Mock Object
• Hard to switch to another object type if requirements change

<>光度>

class DataSingleton {
  private static DataSingleton instance = null;
  private DataSingleton() {}
  public static DataSingleton Instance {
     get {
         if (DataSingleton.instance == null) DataSingleton.instance = new DataSingleton();
         return DataSingleton;
     }
  }
}

Advantages

• None really

Disadvantages

• Hard to create a threadsafe singleton, the above Version will fail if multiple threads access the instance.
• Hard to switch for a mock object

我个人喜欢书记官处模式,但YMMV。

你们应当研究依赖性注射,因为它通常被认为是最佳做法,但太大了在这里解释的话题:

我知道这个问题是老的,但这里是另一个使用4.Net(包括网络核心和网络标准)的解决办法。

第一,界定你们的等级,将变成一个单一州:

public class ClassThatWillBeASingleton
{
    private ClassThatWillBeASingleton()
    {
        Thread.Sleep(20);
        guid = Guid.NewGuid();
        Thread.Sleep(20);
    }

    public Guid guid { get; set; }
}

在“第一”类例中,对一名睡觉的建筑商进行了定义,然后制作一部新的指南,将其公有财产排除在外。 (睡仅作一致测试)

通知说,施工者是私人的,因此没有人能够提出这一类别的新案例。

现在, 我们需要确定将这一类变为单一吨的包装:

public abstract class SingletonBase<T> where T : class
{
    private static readonly Lazy<T> _Lazy = new Lazy<T>(() =>
    {
        // Get non-public constructors for T.
        var ctors = typeof(T).GetConstructors(System.Reflection.BindingFlags.Instance |
                                              System.Reflection.BindingFlags.NonPublic);
        if (!Array.Exists(ctors, (ci) => ci.GetParameters().Length == 0))
            throw new InvalidOperationException("Non-public ctor() was not found.");
        var ctor = Array.Find(ctors, (ci) => ci.GetParameters().Length == 0);
        // Invoke constructor and return resulting object.
        return ctor.Invoke(new object[] { }) as T;
    }, System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);

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

通知说,它使用拉齐创建“外地代码”——Lazy,该编码知道如何用它作为私人建筑商对某类进行即时处理。

并且界定了一条“财产编码”,以获取拉齐油田的价值。

通知<代码>LazyThreadSafetyMode 输往拉齐的建筑商。 正在使用<代码>ExecutionAndPublication。 因此,只有一条路子才能开始拉齐地区的价值。

现在,我们必须做的是确定一个单一州:

public class ExampleSingleton : SingletonBase<ClassThatWillBeASingleton>
{
    private ExampleSingleton () { }
}

这里是使用的一个例子:

ExampleSingleton.Instance.guid;

还有一个检验标准,就是说两条镜子会得到单一州同样的检查:

[Fact()]
public void Instance_ParallelGuid_ExpectedReturnSameGuid()
{
    Guid firstGuid = Guid.Empty;
    Guid secondGuid = Guid.NewGuid();

    Parallel.Invoke(() =>
    {
        firstGuid = Singleton4Tests.Instance.guid;
    }, () =>
    {
        secondGuid = Singleton4Tests.Instance.guid;
    });

    Assert.Equal(firstGuid, secondGuid);
}

这一检验标准同时称为拉齐地区的价值,我们要说,从这一财产(Lazy的Value)中归还的两种情况相同。

然而,我建议,单一州是真正的丑恶模式...... 我认为他们是一位反家长。

对我来说,我更喜欢像一个保存人,执行《保存人》。 您的班子可以宣布附属于建筑商的保存机构,并且可以采用依赖性注射或一种方法: