防止类被实例化的最佳方法？

Question

I need to know how to prevent a class from being Instantiated in .net?

I know few methods like making the class Abstract and Static.

Is there any more way to achieve this?

Answer 1

Making the class static is the best approach, if you absolutely don't want any instances. This stops anyone from creating instances. The class will be both sealed and abstract, and won't have any constructors.

Additionally, the language will notice that it's a static class and stop you from using it in various places which imply instances, eg type arguments and variables. This indicates the intention more clearly than just having a private constructor - which could mean that there are instances, created within that class (eg for a singleton implementation).

Oh, and making the class static will stop you from introducing any pointless instance members in the class, too :)

See MSDN for more information about static classes.

Answer 2

将构造函数标记为private ， protected或者如果从另一个程序集中使用，则标记为internal

Answer 3

Marking the constructor private . Of course, this doesn't prevent the class from instantiating itself through a static method, for example...

More practically, what's the purpose of disallowing class instantiation. If it's to have a singleton , then a private constructor is appropriate. If it's to force subclassing, making the class abstract is better; if it's to have a class with utility methods, making it static is one way (then you can only have static methods).

Answer 4

I need to know how to prevent a class from being Instantiated in .net?

Your question is not clear.

Do you mean instantiated at runtime? Make the class abstract or static .

Do you mean that the constructor is not accessible in code? Make the constructor private . But note that someone could still use reflection to grab a handle on a constructor and instantiate an instance at runtime.

So, which do you mean?

Answer 5

If the question is:

How can you make your class not be instanced without having your class be static or abstract ?

Then the answer to this is to implement the singleton pattern , which in .NET 4+ this is done easily with:

public sealed class myClass
{
    private static readonly Lazy<myClass> lazyInstance = 
        new Lazy<myClass>(() => new myClass());

    public static Instance
    {
        get
        {
            return lazyInstance.Value;
        }
    }

    private myClass()
    {
        // constructor logic here
    }
}

The singleton pattern allows you to pass your class around as a reference to methods, while still ensuring that you have only a single instance of your class. It also makes testing much easier as you can have a ImyClass instance which myClass implements, this is very helpful when making mock objects.

Without .NET4 you can still implement the singleton pattern, for example:

private static readonly myClass instance = new myClass();

public static Instance
{
    get
    {
        return instance;
    }
}

// rest of code remains the same

Which doesn't have deferred loading until it's called, there's lots of other ways as well (I think about 6 different ways), but the above two are the most common ones.

In summary the question is likely asking if you know the singleton pattern and if you recognise it's importance over static classes for unit tests and mock objects.

As others have already pointed out, static fields, even those marked readonly can be set with reflection, in addition the private constructor can be called using reflection. If you need to prevent these, either you need to make the calling code run in a less trusted app-domain space, or you will need to implement your class as static .

Generally though, people don't bother with such levels of reflection to get around your constraints unless they 'really need to' for example, writing obscure / extreme fringe case unit tests.