Static Class and Static Constructor

Static constructors have the following properties:

• A static constructor does not take access modifiers or have parameters.
• A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.
• A static constructor cannot be called directly.
• The user has no control on when the static constructor is executed in the program.
• A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.
• Static constructors are also useful when creating wrapper classes for unmanaged code, when the constructor can call the LoadLibrary method.

A Constructor is usually used to initialize data. However Static Constructor is used to initialize only static members. Here I am just talking about the Constructors. How they get initialized and how they behave.

Things to know about Static Constructor

1. It is used to initialize static data members. 
   
2. Can't access anything but static members.
   
3. Can't have parameters
   
4. Can't have access modifiers like Public, Private or Protected.

Now once you understand the above points, you can appreciate the difference between Static Class and Unstatic Class

1. Static Class cannot be instantiated unlike the unstatic class. You should directly access its Method via the ClassName.MethodName
   
2. A Program can't tell when it is going to load static class but its definitely loaded before the call.
   
3. A Static class will always have the static constructor and its called only once since after that its in the memory for its lifetime.
   
4. A Static class can contain only static members. So all the members and functions have to be static.
   
5. A Static class is always sealed since it cannot be inherited further. Further they cannot inherit form any other class (except Object)

Let's look at a normal Constructor

class Program{    static void Main(string[] args)
      { 

         /* Note two things

        1.Here you get to instantiate the Constructor in the code wherever you like.

        2.If you debug you get to goto the Constructor and see what is being done.

         */         MyExample myExample = new MyExample();
         myExample.Print();
      }
}
public class MyExample{    private static int StaticVariable ;    public MyExample()
       {             if (StaticVariable < 10)
             {
                    StaticVariable = 20; 
             }            else             {
                   StaticVariable = 100; 
             }
       }  

    public void Print()
    {        Console.WriteLine(StaticVariable);
    } 
}

Now consider this second example for static class
class Program{    static void Main(string[] args)
    {

       /* Note the following

            1.You dont get to instantiate for sure so you dont know when the constructor was called.

            2.Secondly you can access your method directly.

       */

      //MyExampleStatic myExampleStatic = new MyExampleStatic();       MyExampleStatic.Print();
}
}

static class MyExampleStatic{    private static int StaticVariable;    static MyExampleStatic()
   {        if (StaticVariable < 10)
          {
          StaticVariable = 20;
          }    else     {
          StaticVariable = 100;
      }
  }    public static void Print()
   {        Console.WriteLine(StaticVariable);
    }
}