为什么这个 singleton 代码示例中有两个构造函数

Question

I need to implement a singleton pattern in code and found this version (#4) that seems to fit my needs.

public sealed class Singleton
{
private static readonly Singleton instance = new Singleton();

// Explicit static constructor to tell C# compiler
// not to mark type as beforefieldinit
static Singleton()
{
}

private Singleton()
{
}

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

}

Why does the example have two constructors? I did put Debug.Write in each of the constructors and saw that both were executed on class initialition.

Do I need to keep both? Which one is preferred to use for my own code?

Answer 1

If you have a type that is not marked as beforefieldinit , then it's static constructor will be called right before you need it, which means, if you don't use your singleton, it won't get instantiated.

To be more specific, the specification states that

The semantics of when and what triggers execution of such type initialization methods, is as follows: The semantics of when and what triggers execution of such type initialization methods, is as follows:

1. A type can have a type-initializer method, or not.
2. A type can be specified as having a relaxed semantic for its type-initializer method (for convenience below, we call this relaxed semantic BeforeFieldInit).
3. If marked BeforeFieldInit then the type's initializer method is executed at, or sometime before, first access to any static field defined for that type.
4. If not marked BeforeFieldInit then that type's initializer method is executed at (ie, is triggered by):

a. first access to any static field of that type, or

b. first invocation of any static method of that type, or

c. first invocation of any instance or virtual method of that type if it is a value type or

d. first invocation of any constructor for that type.

The non-static constructor is needed so that compiler does not create default constructor with no parameters.

If a class contains no instance constructor declarations, a default instance constructor is automatically provided. That default constructor simply invokes the parameterless constructor of the direct base class. If the direct base class does not have an accessible parameterless instance constructor, a compile-time error occurs. If the class is abstract then the declared accessibility for the default constructor is protected. Otherwise, the declared accessibility for the default constructor is public. Thus, the default constructor is always of the form

Answer 2

The static constructor is called when your class is called the very first time, no matter if by a static call like SingleTon.MyMember or by creating a new instance of it. The other one is always called, when you instantiate a new instance (which in case of a singleton however is only once). You should set the access-modifier of the latter to private to avoid creating instances.

EDIT: IF you have a singleton-class you won´t need both constructor. All your initializations can be done by the default one, where you set all important members of that instance whereas the static one can be omitted.

Answer 3

If you leave the private constructor out. The default constructor is public. And you will not have a singleton. That's why you need to explicitly also have a private constructor.