September 23, 2013

Static Class and Static Constructor

Static class is the class having static member(s) only and it is called only once when it is loaded first time. The class loads at the time of its first use. It can have static contractor. Off course, static member cannot access non-static member (instance member) variable.

Static constructor is same as normal constructor which is used to initialize static variable(s), but the differences are- It cannot be overloaded nor takes any parameter as an argument. Normal constructor is used for instantiation of an object and to initialize it. It called as Instance Constructor where as Static Constructor is called as Class Constructor or Type Initializer. Static constructor is provided by C#.

Twist: In general, a constructor is called at the time of instantiation but we cannot create instance of a static class, then at what time it will execute? 

Answer is- only first time when it loads & being used to initialize its static variable.

public static class TestStatic
        public static string _stest = string.Empty;

        static TestStatic()
            _stest = "Hello! This is Static.";

public class TestNonStatic
        public string _nstest = "Hello! This is Non-Static.";

public partial class Form1 : Form
        public Form1()

        private void button1_Click(object sender, EventArgs e)
            // Only first time class will execute.
            // After, it will execute as a variable.
            textBox1.Text = TestStatic._stest;
            TestStatic._stest = "Hii";

        private void button2_Click(object sender, EventArgs e)
            // Each time constructor will be called.
            TestNonStatic t = new TestNonStatic();
            textBox2.Text = t._nstest;

Output for button1:
Ist time : Hello! This is Static.
After : Hii

Why Static Method Cannot Access Non-Static Variables?
Non-static variables are the instance variable, they can be accessible by its object only where as static variable can be accessible by class name only, there scope is completely different. Since, non-static members are instance meber and each instance is considered as different object. Class is independent to its obaject, changing value of an object does not reflect on its class whereas static members are class members and is global in that scope. Changin its value at any place will also reflects in its class. Consider the below example:

public class Employee
        public int Age { get; set; }
        public string Name { get; set; }

Employee emp1= new Employee();
emp1.Age = 28;
emp1.Name = "Employee_1";

Employee emp2 = new Employee();
emp2.Age = 30;
emp2.Name = "Employee_2";

In above example, emp2 is completely independent from emp1 and they will never overwrite each other’s values anyhow. But if we define it as static, then it will will consider as single entity and will always overwrite with newly assigned value.  Consider the given example below:

public static class Employee
        public static int Age { get; set; }
        public static string Name { get; set; }

Employee.Age = 28;
Employee.Name = "Employee_1";

Employee.Age = 30;
Employee.Name = "Employee_2";