By Rajesh
A C# class can contain both static and non-static members. When we declare a
member with the help of the keyword static, it becomes a static member. A static
member belongs to the class rather than to the objects of the class. Hence static
members are also known as class members and non-static members are known as
instance members.
In C#, data fields, member functions, properties and events can be declared either
as static or non-static. Remember that indexers in C# can't declared as static.
Static Fields
Static fields can be declared as follows by using the keyword static.
class MyClass
{
public static int x;
public static int y = 20;
}
When we declare a static field inside a class, it can be initialized with a value as
shown above. All un-initialized static fields automatically get initialized to their
default values when the class is loaded first time.
For example
// C#:static & non-static
// Author: rajeshvs@msn.com
using System;
class MyClass
{
public static int x = 20;
public static int y;
public static int z = 25;
public MyClass(int i)
{
x = i;
y = i;
z = i;
}
}
class MyClient
{
public static void Main()
{
Console.WriteLine("{0},{1},{2}",MyClass.x,MyClass.y,MyClass.z);
MyClass mc = new MyClass(25);
Console.WriteLine("{0},{1},{2}",MyClass.x,MyClass.y,MyClass.z);
}
}
The C# provides a special type of constructor known as static constructor to initialize
the static data members when the class is loaded at first. Remember that, just like
any other static member functions, static constructors can't access non-static data
members directly.
The name of a static constructor must be the name of the class and even they don't
have any return type. The keyword static is used to differentiate the static
constructor from the normal constructors. The static constructor can't take any
arguments. That means there is only one form of static constructor, without any
arguments. In other way it is not possible to overload a static constructor.
We can't use any access modifiers along with a static constructor.
// C# static constructor
// Author: rajeshvs@msn.com
using System;
class MyClass
{
public static int x;
public static int y;
static MyClass ()
{
x = 100;
Y = 200;
}
}
class MyClient
{
public static void Main()
{
Console.WriteLine("{0},{1},{2}",MyClass.x,MyClass.y);
}
}
Note that static constructor is called when the class is loaded at the first time.
However we can't predict the exact time and order of static constructor execution.
They are called before an instance of the class is created, before a static member is
called and before the static constructor of the derived class is called.
Static Member Functions
Inside a C# class, member functions can also be declared as static. But a static
member function can access only other static members. They can access non-static
members only through an instance of the class.
We can invoke a static member only through the name of the class. In C#, static
members can't invoked through an object of the class as like in C++ or JAVA.
// C#:static & non-static
// Author: rajeshvs@msn.com
using System;
class MyClass
{
private static int x = 20;
private static int y = 40;
public static void Method()
{
Console.WriteLine("{0},{1}",x,y);
}
}
class MyClient
{
public static void Main()
{
MyClass.Method();
}
}
Static Properties
The properties also in C# can be declared as static. The static properties are
accessing using the class name. A concrete example is shown below.
// C#:static & non-static
// Author: rajeshvs@msn.com
using System;
class MyClass
{
public static int X
{
get
{
Console.Write("GET");
return 10;
}
set
{
Console.Write("SET");
}
}
}
class MyClient
{
public static void Main()
{
MyClass.X = 20; // calls setter displays SET
int val = MyClass.X;// calls getter displays GET
}
}
Static Indexers
In C# there is no concept of static indexers, even though static properties are there.
Static Members & Inheritance
A derived class can inherit a static member. The example is shown below.
// C#:static
// Author: rajeshvs@msn.com
using System;
class MyBase
{
public static int x = 25;
public static void Method()
{
Console.WriteLine("Base static method");
}
}
class MyClass : MyBase
{
}
class MyClient
{
public static void Main()
{
MyClass.Method(); // Displays 'Base static method'
Console.WriteLine(MyClass.x);// Displays 25
}
}
But a static member in C# can't be marked as override, virtual or abstract. However
it is possible to hide a base class static method in a derived class by using the
keyword new.
An example is shown below.
// C#:static & non-static
// Author: rajeshvs@msn.com
using System;
class MyBase
{
public static int x = 25;
public static void Method()
{
Console.WriteLine("Base static method");
}
}
class MyClass : MyBase
{
public new static int x = 50;
public new static void Method()
{
Console.WriteLine("Derived static method");
}
}
class MyClient
{
public static void Main()
{
MyClass.Method(); // Displays 'Derived static method'
Console.WriteLine(MyClass.x);// Displays 50
}
}
Finally remember that it is not possible to use this to reference static methods.
Conclusion
I've given you enough information to use static members in your code and shown
you some examples. The feedback is always welcome. Feel free to contact me for
any questions or comments you may have about this article at rajeshvs@msn.com
