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()
{
InitializeComponent();
}
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";
