Answer / shadab alam

static costructor of a class invoked automatically when
class is loded provided Main method is given.There is no
need to create instance of a class.

we can prove it by following program in c#

using System;
class aa
{
static aa()
{
Console.Write("without instance");
}
public static void Main()
{

}

}


output will be
---------------
without instance

Answer / deepthi

It is invoked only when the object for that particular
class is created for the first time

Answer / ganesh

A static constructor is used to initialize any static data,
or to perform a particular action that needs performed once
only. It is called automatically before the first instance
is created or any static members are referenced.

Static constructors have the following properties:
• A static constructor does not take access modifiers or
have parameters.
• A static constructor is called automatically to initialize
the class before the first instance is created or any static
members are referenced.
• A static constructor cannot be called directly.
• The user has no control on when the static constructor is
executed in the program.
• A typical use of static constructors is when the class is
using a log file and the constructor is used to write
entries to this file.
• Static constructors are also useful when creating wrapper
classes for unmanaged code, when the constructor can call
the LoadLibrary method.
public class Bus
{
// Static constructor:
static Bus()
{
System.Console.WriteLine("The static constructor
invoked.");
}

public static void Drive()
{
System.Console.WriteLine("The Drive method invoked.");
}
}

class TestBus
{
static void Main()
{
Bus.Drive();
}
}

Answer / vibhu

.NET Run time does not specify when it will invoke a static
constructor. This is one caveat about the static
constructors. Though, what we could be certain of is that
it will be invoked before the first instance of the
corresponding class is created.

Answer / yosh

C# supports two types of constructor, a class constructor
(static constructor) and an instance constructor (non-static
constructor).

Static constructor is used to initialize static data members
as soon as the class is referenced first time, whereas an
instance constructor is used to create an instance of that
class with <new> keyword. A static constructor does not take
access modifiers or have parameters and can't access any
non-static data member of a class.

Since static constructor is a class constructor, they are
guaranteed to be called as soon as we refer to that class or
by creating an instance of that class.

You may say, why not initialize static data members where we
declare them in the code. Like this :

private static int id = 10;
private static string name = "jack";

Static data members can certainly be initialized at the time
of their declaration but there are times when value of one
static member may depend upon the value of another static
member. In such cases we definitely need some mechanism to
handle conditional initialization of static members. To
handlesuch situation, C# provides static constructor.

Let me explain you with examples :

//File Name : Test.cs
using System;
namespace Constructor
{
class Test
{
//Declaration and initialization of static data member
private static int id = 5;
public static int Id
{
get
{
return id;
}
}
public static void print()
{
Console.WriteLine("Test.id = " + id);
}
static void Main(string[] args)
{
//Print the value of id
Test.print();
}
}
}

In the above example, static data member <id> is declared
and initialized in same line. So if you compile and run this
program your output would look similar to this :

Test.id = 5

Lets create one more class similar to class Test but this
time the value of its static data member would depend on the
value of static data member <id> of class Test.id.

//File Name : Test1.cs
using System;
namespace Constructor
{
class Test1
{
private static int id ;
//Static constructor, value of data member id is set
conditionally here.
//This type of initialization is not possible at the time of
declaration.
static Test1()
{
if( Test.Id < 10 )
{
id = 20;
}
else
{
id = 100;
}
Console.WriteLine("Static<Class> Constructor for Class Test1
Called..");
}
public static void print()
{
Console.WriteLine("Test1.id = " + id);
}
static void Main(string[] args)
{
//Print the value of id
Test1.print();
}
}
}

As you can see in the above static constructor, static data
member <id> is initialized conditionally. This type of
initialization is not possible at the time of declaration.
This is where static constructor comes in picture. So if you
compile and run this program your output would look similar
to this :

Static<Class> Constructor for Class Test1 Called..
id = 20

Since <id> in class Test was initialized with a value of 5,
therefore <id> in class Test1 got initialized to a value of 20.

Some important point regarding static constructor from C#
Language Specification and C# Programmer's Reference :

1) The static constructor for a class executes before any
instance of the class is created.
2) The static constructor for a class executes before any of
the static members for the class are referenced.
3) The static constructor for a class executes after the
static field initializers (if any) for the class.
4) The static constructor for a class executes at most one
time during a single program instantiation
5) A static constructor does not take access modifiers or
have parameters.
6) A static constructor is called automatically to
initialize the class before the first instance is created or
any static members are referenced.
7) A static constructor cannot be called directly.
8) The user has no control on when the static constructor is
executed in the program.
9) A typical use of static constructors is when the class is
using a log file and the constructor is used to write
entries to this file

Answer / abhay k pandey

Static constructors can invoke mainly at two ocasions
1. Just before the first instance of the class is created [
in case this static contructor is there in non static class]
2. At the time any static member is accessed [ in case of
either static or non static classes ]

Answer / sujai cn

A static constructor is executed when that class is loaded
in to memory for the first time . i.e., when ever an object
is created or a static method is invoked using class name.

Answer / nitin

When first time Object of CLass is created it called
automatically.

Answer / raviraj

we do not have concept static constructor in .net.a
constructor is one which is invoked when you create an
object for that class,hence by no chance there will exist a
static constructor.

What is the difference between selection and projection?

0 Answers  

Why would you use a class property in c#?

0 Answers  

Can int be null c#?

0 Answers  

What is private and shared assembly?

0 Answers  

how to deplaoy a project in the system?

1 Answers  

how to compare numbers and dispaly the largest ? *first thing I wanted to do is to input how many numbers to be compared *and then analyzed the largest then display it.

0 Answers  

Can we write one page in c# and other in vb in one application ?

3 Answers   Keane India Ltd,

Can you declare a class or a struct as constant?

0 Answers  

what are the files we need to deploay a project in the system?

2 Answers  

Is it possible to inline assembly or il in c# code?

0 Answers  

What do you know about Translate Accelerator?

0 Answers   C DAC,

List down the commonly used types of exceptions in .net

0 Answers