C＃ - 静态类，私有构造函数，抽象类 - 都阻止实例创建 - 使用哪一个？

Question

I am bit confused in the usage of Static class, Private constructor and abstract class

to prevent instance creation.( Confused about the alternatives).

What is the scenario that fit the best for each ?

Answer 1

That depends on your needs.

• Static class may be considered "a bunch of methods" - you would use it, if you just need to group some methods, sample usage: MathHelpers, with methods like Sin, Cos, ConvertXToY (or to host extension methods).

• Private constructor - this one you would use, when you want to be able to control how the object is created, for example, if you want to make sure, that those objects can only be created by your static methods. An example:

class Robot
{
 public string Name { get; }
 private Robot() 
 { 
   // some code
 }

 public static Robot CreateAndInitRobot(string name)
 {
   Robot r = new Robot();
   r.Name = name;
   return r;
 }
}

• Abstract classes - Those you should use, when you are defining some abstract object, that shouldn't been initialized, because it's incomplete / abstract, and you want to further specialize it (by inheriting from it).

Answer 2

You use a static class when you only have static members. It doesn't work for any scenario when you want to inherit the class.

A private constructor ensures that only code inside the class itself can create instances of it, ie a static method or an instance method in an already existing instance. Even if you inherit from the class, it still has to call the creation process of the base class, so there is no way around it.

An abstract class is useless for preventing instance creation. You have to inherit the class to use it for anything, and you can add whatever constructor you like to the descendant class.

Answer 3

Static classes cannot be used as a base class for inheritance and can only contain static members.

Abstract classes cannot be instantiated at all and are useful only as a base class for inheritance. They can provide abstract memebers (with no implementation) that the derived class must override, they can provide virtual members (with default implementation) that the derived class may override, or they can provide regular (sealed) members that provide common functionality.

Private constructors (typically found in non-abstract, non-static classes) prevent the class from being instantiated with no parameters/initialization. They are most useful when the class requires specific information during initialization/construction to be in a valid state.

Answer 4

An abstract class means that you must inherit from the class to have something to instantiate. It's normally used where the base functionality is common, but where some specialisation will be provided in the derived class which cannot be defaulted - in other words, you have to provide your own behaviour.

A private constructor was the pre .NET 2 way of preventing somebody from instantiating a class using new - in .NET 2, the static constructor was introduced. This would be used where you want to have some form of factory method, eg

public static class MyClass
{
  static MyClass() {}
  private static MyClass LoadFromDatabase(int id)
  {
    // Get the data here....
  }
  public static MyClass LoadByKey(int id)
  {
    MyClass c = new MyClass();
    return c.LoadFromDatabase(id);
  }
}