http://www.csharphelp.com/archives/archive148.html
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:
ra******@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:
ra******@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:
ra******@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:
ra******@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:
ra******@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:
ra******@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.
"Jon Skeet" <sk***@pobox.com> wrote in message
news:MP************************@news.microsoft.com ...
kuvpatel <kp@geuk.co.uk> wrote: I want to refer a class called LogEvent, and use one of its methods
called WriteMessage without actually having to create an instance of Logevent.
I have tried using the word sealed with the class and this works but I
would also like to know of other ways to do this.
Also are there any performance implacations of using sealed?
Sealed is completely separate to what you want. I believe what you
actually mean is static, which exactly means "this method doesn't run
in the context of an instance, so you can run it without creating an
instance".
--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet/
If replying to the group, please do not mail me too
