static, readonly, const

• static
  • Use the static modifier to declare a static member, which belongs to the type itself rather than to a specific object. The static modifier
    can be used with classes, fields, methods, properties, operators, events, and constructors, but it cannot be used with indexers, destructors, or types other than classes.
  • A constant or type declaration is implicitly a static member.
  • A static member cannot be referenced through an instance. Instead, it is referenced through the type name.
  • While an instance of a class contains a separate copy of all instance fields of the class, there is only one copy of each static field.
  • It is not possible to use this to reference static methods or property accessors.
  • If the static keyword is applied to a class, all the members of the class must be static.
  • Classes and static classes may have static constructors. Static constructors are called at some point between when the program starts and the class is instantiated.
  • A static class is basically the same as a non-static class, but there is one difference: a static class cannot be
    instantiated. In other words, you cannot use the new keyword to create a variable of the class type. Because
    there is no instance variable, you access the members of a static class by using the class name itself.
  • A static class can be used as a convenient container for sets of methods that just operate on input parameters and do not have to get or set any internal instance fields.
  • As is the case with all class types, the type information for a static class is loaded by the .NET Framework common language runtime (CLR) when the program that references the class is loaded. The program
    cannot specify exactly when the class is loaded. However, it is guaranteed to be loaded and to have its fields initialized and its static constructor called before the class is referenced for the first time in your program. A
    static constructor is only called one time, and a static class remains in memory for the lifetime of the application domain in which your program resides.
  • static class: Contains only static members, Cannot be instantiated, Is sealed, Cannot contain Instance Constructors.
  • Creating a static class is therefore basically the same as creating a class that contains only static members and a private constructor. A private constructor prevents the class from
    being instantiated. The advantage of using a static class is that the compiler can check to make sure that no instance members are accidentally added. The compiler will guarantee
    that instances of this class cannot be created.
  • Static classes are sealed and therefore cannot be inherited. They cannot inherit from any class except Object. Static
    classes cannot contain an instance constructor; however, they can contain a static constructor. Non-static classes should also define a static constructor if the class contains static members that require non-trivial
    initialization.
  • A non-static class can contain static methods, fields, properties, or events.
  • The static member is always accessed by the class name, not the instance name. Static methods and properties cannot access non-static
    fields and events in their containing type, and they cannot access an instance variable of any object unless it is explicitly passed in a method parameter.
  • It is more typical to declare a non-static class with some static members, than to declare an entire class as static.
  • Two common uses of static fields are to keep a count of the number of objects that have been instantiated, or to store a value that must be shared among all instances.
  • Static methods can be overloaded but not overridden, because they belong to the class, and not to any instance of the class.
  • Although a field cannot be declared as static const, a const field
    is essentially static in its behavior. It belongs to the type, not to instances of the type.
  • Static members are initialized before the static member is accessed for the first time and before the static constructor, if there
    is one, is called.

  • C# does not support static local variables (variables that are declared in method scope).

• const
  • The static modifier is not allowed in a constant declaration.
  • A const field can only be initialized at the declaration of the field. A readonly field can be initialized
    either at the declaration or in a constructor. Therefore,readonly fields can have different values depending on the constructor used. Also,
    although a const field is a compile-time constant, the readonly field can be used for run-time constants, as in this line: public static readonly uint l1 = (uint)DateTime.Now.Ticks;

Examples:

   public static class MyStaticClass : MyClass // error CS0713: Static classes must derive from object.
   {
      static MyStaticClass()
      {
         Console.WriteLine("MyStaticClass constructor");
      }
      public static void Test() { Console.WriteLine("MyStaticClass:Test"); }
   }

   public class Derived : MyStaticClass { } //'Derived': cannot derive from static class 'MyStaticClass'