All About Static Method, Constructor And Class In C#

A static class cannot be derived from a non-static as well as static class. Static classes are by default sealed so you cannot inherit them. It can only inherit the Object class.

 

Code Snippet

public class NormalClassA
{
}
public static class StaticClassC : NormalClassA //Error -cannot inherit from NormalClassA class
{
}
public static class StaticClassD : StaticClassC  //Error -cannot inherit a static class as static class is sealed by //default
{
}

Below is error description.

 

You cannot declare an instance field inside static class(outside non-static method and constructor).But you can use an instance variable inside static constructor and static method.

You can declare a read-only static variable in static class but it can only be changed in a non-static constructor. But you cannot change the read-only static variable from inside a static method.

You can declare and initialize a constant variable inside static class once and thereafter it can't be changed.

You cannot have non-static constructor inside a static class. Since we can't create an object of the static class to invoke it.

You can declare a static variable at first inside the static class which can be later initialized/changed from inside a constructor and/or from a static method.

Below is code snippet.

public static class StaticClassD
{
   // All commented code below gives error on compile time and their reason is written against each of them
   //readonly int j; //Error - cannot declare an instance member in static class
   // int z; //Error - cannot have instance field outside static function or constructor

            readonly static int k; //default value is 0
            static int n;               //default value is 0
            const int i = 90;        //need to initialize at declaration and cannot change later

   //k++; //Error - readonly static can only change in static constructor
   //test() { } //Error - cannot have instance/non-static constructor

            static StaticClassD() { k++; n++; int data = 9; } //by default constructor is public //can use instance field insdie ctor

   //public void add() { } //Error - cannot have instance method inside static class

public static void ChangedTextStaticMethod()
{
            int d = 88;
   //k++; //Error - static readonly can only change in static constructor
            n++;
            Console.WriteLine("Value of static readonly variable k is :"+ k);
            Console.WriteLine("Value of static variable n is :" + n);
            Console.WriteLine("Value of constat variable i is :" + i);
            Console.WriteLine("Value of instance variable d is :" + d);
}

class Program
{
      static void Main(string[] args)
         {
            StaticClassD.ChangedTextStaticMethod();
         }
}

Below is output.

 

Static default constructor execution order is from bottom to top (child to parent). And, Non-Static default constructor execution order is from top to bottom (parent to child).

 

Below is the code snippet.

class NormalClassB
{
            static NormalClassB()
               {
Console.WriteLine("Static constructor of NormalClassB Called");
               }
            public NormalClassB()
              {
Console.WriteLine("Non-Static constructor of NormalClassB Called");
               }
}

class NormalClassC :NormalClassB
{
         static NormalClassC()
            {
         Console.WriteLine("Static constructor of NormalClassC Called");
            }
         public NormalClassC()
            {
Console.WriteLine("Non-Static constructor of NormalClassC Called");
            }
}

class Program
{
static void Main(string[] args)
         {
      // static constructor will be called first - bottom to top
      // non-static constructor will be called after all static constructor - top to bottom
               NormalClassC normalClassC = new NormalClassC();
         }
}

Below is output screen.