What Is a Static Constructor

What is the use of static constructors?

No you can't overload it; a static constructor is useful for initializing any static fields associated with a type (or any other per-type operations) - useful in particular for reading required configuration data into readonly fields, etc.

It is run automatically by the runtime the first time it is needed (the exact rules there are complicated (see "beforefieldinit"), and changed subtly between CLR2 and CLR4). Unless you abuse reflection, it is guaranteed to run at most once (even if two threads arrive at the same time).

What is a static constructor?

C++ doesn’t have static constructors but you can emulate them using a static instance of a nested class.

class has_static_constructor {
    friend class constructor;

    struct constructor {
        constructor() { /* do some constructing here … */ }
    };

    static constructor cons;
};

// C++ needs to define static members externally.
has_static_constructor::constructor has_static_constructor::cons;

C# static class constructor

C# has a static constructor for this purpose.

static class YourClass
{
    static YourClass()
    {
        // perform initialization here
    }
}

From MSDN:

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

MSDN link

static constructors in C++? I need to initialize private static objects

To get the equivalent of a static constructor, you need to write a separate ordinary class to hold the static data and then make a static instance of that ordinary class.

class StaticStuff
{
     std::vector<char> letters_;

public:
     StaticStuff()
     {
         for (char c = 'a'; c <= 'z'; c++)
             letters_.push_back(c);
     }

     // provide some way to get at letters_
};

class Elsewhere
{
    static StaticStuff staticStuff; // constructor runs once, single instance

};

What's the function of a static constructor in a non static class?

Do you use it to initialize static fields on your instance of the non-static type?

Pretty much, except that static fields (or static members of any kind) aren't associated with instances; they are associated with the type itself, regardless of whether it is a static class or a non-static class.

The documentation lists some properties of static constructors, one of which is:

A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.

Here, "before" means "immediately before", and whichever one of those things happens first. This is because a static constructor is only called once per type in a single program execution.

Are there any things to take into consideration when using a static constructor?

Here's the full list as given by the link above, which should give you an idea of what to expect when using a static constructor:

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.
If a static constructor throws an exception, the runtime will not invoke it a second time, and the type will remain uninitialized for the lifetime of the application domain in which your program is running.

Besides making sure you don't try to access non-static members, since you're not in an instance constructor, the other main thing you have to consider is that a static constructor is always called at a specific time during program execution. As stated, you cannot control this, other than by controlling when "the first instance is created or any static members are referenced."

How to invoke a static constructor inside a static class in c#

You can't. As it is written in MSDN Article about Static Classes :

A static class is basically the same as a non-static class, but there
is one difference: a static class cannot be instantiated. In other
words, you cannot use the new keyword to create a variable of the
class type. Because there is no instance variable, you access the
members of a static class by using the class name itself.

Also I will suggest you to read this article too

Static Constructors (C# Programming Guide)

As there is written you can't call static constructor

A static constructor is used to initialize any static data, or to
perform a particular action that needs to be 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

Below is example how the static constructor works.

using System; 
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication6 
{
    public class Program 
    { 
        public static void Main(string[] args) 
        { 
            A myClass1WithStaticConstructor = new A();
            A myClass2WithStaticConstructor = new A();
        } 
    } 
    public class A 
    { 
        public A()
        {
            Console.WriteLine("default constructor is called."); 
        }
        static A() 
        { 
            Console.WriteLine("static constructor is called."); 
        } 
    } 
}

And the output will be the following:

static constructor is called.

default constructor is called.

default constructor is called.

So from the output we see that the static constructor was called only for the first time.

Also in case if you want to use it with Static Class here is example for it:

using System; 
using System.Collections.Generic;
using System.Linq; 
using System.Text;
namespace ConsoleApplication6 
{
    public class Program 
    { 
        public static void Main(string[] args) 
        { 
            Console.WriteLine(A.abc);
        } 
    } 
    public static class A 
    { 
        public static int abc;

        static A() 
        { 
            abc=10;
            Console.WriteLine("static constructor is called."); 
        } 
    } 
}

The output will be the following:

static constructor is called.

10

So we see that the static constructor is automatically called in this case too.

When is a static constructor called in C#?

When the class is accessed for the first time.

Static Constructors (C# Programming Guide)

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.

How to gain Static Constructor's functionality in JAVA?

You may use static initialization block like this -

class SimpleClass
{
    static{

    }

}

The static block only gets called once, no matter how many objects of that type is being created.

You may see this link for more details.

Update: static initialization block is called only when the class is loaded into the memory.

Static constructor called after instance constructor?

Inline initializers for static fields run before the explicit static constructor.

The compiler transforms your class into something like this:

public class Test {
    .cctor {    //Class constructor
        Test.test = new Test();                //Inline field initializer
        Console.WriteLine("static Test()");    //Explicit static ctor
    }
    .ctor { ... }    //Instance constructor
}

Note that this is independent of the declaration order.

To quote the spec:

The static field variable initializers
of a class correspond to a sequence of
assignments that are executed in the
textual order in which they appear in
the class declaration. If a static
constructor (Section 10.11) exists in
the class, execution of the static
field initializers occurs immediately
prior to executing that static
constructor.