Static Class VS Private Constructor

Question

Today, I have been reading about static class and private constructor.

Static Class - We cannot create an instance on the static class. we cannot inherit the static class. Only single instance is generated.

Private Constructor - We cannot create an instance. We cannot inherit. (I Don't know about how many instance is generated.)

I created two console application i.e. One for static Class, One for Private constructor.

Static Class Code

I understood single object in generated as constructor is called once.

Private Constructor Code

Now, I didn't understand that whether any object is generated or not.

I have two question.

Question 1. I didn't find any particular difference between Private constructor and Static class. Can you please suggest me that in which scenario where I should use Private Constructor and where should I use Static class as I can use both of them.

Question 2. If I use private constructor, how many objects is generated?

Thanks.

EDIT :

I think that people didn't understand my question. I know that static constructor always call once on the first reference. Static constructor is used to initialize static members of the class.

Question 1. I have a situation : I need to create a class which cannot be instantiated.I can do this by either static class or private constructor. So my question is that "Is there any difference between both of them? which one I should use??"

Question 2. If I use private constructor, how many object is created? If answer is 0 then how private constructor's memory allocation works in the CLR. There is no memory allocation if I use private constructor.

Answer 1

Both of you examples you are calling static methods the difference between the two is that the first method is being called within a static class which cannot be instantiated. The second class could be instantiated however you did not choose to.

The static constructor in the first example is run automatically at runtime when it is needed, it is generally only run once.

The private constructor is never run as you never instantiated a testPrivateConstructor object. not because it is private.

The Edit:

Q1: If you need a class that cannot be instantiated use a static class. Only use a private constructor instead of a static class if you need to initialise static members (or a singleton pattern).

Q2: If you use a private constructor you can instantiate an instance of your class within the class itself so the number of objects that are created depend on how many times you instantiate new objects.

Answer 2

your mixing up a few different things here

a static class public static class MyClass can only contain static elements and never be initialised

a constructor (whether public or private) always creates in instance of the class the public or private only says the visibility of the constructor.

this is commonly used when implementing a singleton design

private MyClass()
{
}
private static MyClass _Singleton;
public static MyClass Singleton
{
    get
    {
        if(_Singleton==null) _Singleton = new MyClass();
        return _Singleton
    }
}

}

the other is a Class Initialiser, this is a little confusing because its syntax is very similar to a constructor baring the adding of a static keyword and lack of parameters

static MyClass()
{
    //configure static variables on first us only
    b = //read value from file or other resource not avalable at compile time
    a = b.Lenth; //can't be be done in class body as b would not have been initialised yet
}
private static int a;
private static string b;

ergo if your class can't be instantiated then you can only declare is as static nothing else will do that,

if you call a private constructor then every call creates an instance

a class initialiser can never be called its fired automatically on the first use of a class and does not create an instance

EDIT: here is a revised version of your test program

public static class StaticClassExample
{
    public static void ClassFunction()
    {
        Console.WriteList("This is a class function")
    }
}
public static class InitialisedStaticClassExample
{
    static InitialisedStaticClassExample()
    {
        Console.WriteList("This class has been initialised")
    }
    public static void ClassFunction()
    {
        Console.WriteList("This is a class function")
    }
}
public class PrivateConstuctorClassExample
{
    static PrivateConstuctorClassExample()
    {
        Console.WriteList("This class has been initialised")
    }
    private PrivateConstuctorClassExample()
    {
        Console.WriteList("This class has been Instantiated")
    }
    public static void ClassFunction()
    {
        Console.WriteList("This is a class function");
        var instance = new PrivateConstuctorClassExample();
        instance.InstanceFunction();
    }
    public void InstanceFunction()
    {
        Console.WriteList("This is a instance function")
    }
}