A private constructor is a special instance constructor. It is generally used in classes that contain static members only. If a class has one or more private constructors and no public constructors, other classes (except nested classes) cannot create instances of this class.

By default the parameters passed in methods are by value.

Ref is bidirectional

Out is unidirectional before c#7 it was needed to get initialized out is also passed by ref

var :

1. it should be initialized
2. We can not pass var in method as argument.
3. Once the type is initialized it can not be changed. It become a strongly type.
4. Var type is known at compile time. e.g var x = “strng1”; int len= x.Length, here compiler know that x is string type.

Object:

1. It is not needed to initialize
2. We can change and pass any type data in object.
3. Type is resolved at run-time.

Dynamic:

1. It is not needed to initialize.
2. We can pass dynamic as argument in method.
3. Has overhead on compiler for casting.
4. Dynamic type is known at run time. e.g var x = “strng1”; int len= x.Length, here compiler uses reflection to know the type of x at run time and then check for length method in string.Dynamic internally uses reflection.

Yes.Finally will always be called whatever happens in try catch block.

Early binding also known as compile time polymorphism or method overloading.
In OverLoading – We have same class, different parameters and same method name.

Late binding also known as dynamic polymorphism or method overriding and is achieved through parent and child classes by virtual keyword.
In Overriding – We have same method name,same parameters but different classes.

The yield keyword effectively creates a lazy enumeration over collection items that can be much more efficient. 

Traditional way to return Ienumerator

IEnumerable<int> getnumber()
{
var i = 0; var list = new List<int>();
while (i<5)
list.Add(++i); return list;
}
foreach(var number in getnumber()) Console.WriteLine(number);

Loop with Yield

IEnumerable<int> getnumber()
{
var i = 0;
while (i<5) yield return ++i;
}
foreach(var number in getnumber()) Console.WriteLine(number);

Static Class :

1. Static class has no instance
2. We can not implement interface.
3. A static class can not have instance members, only static member it can have.

Singleton class :

1. We have a single instance of class.
2. you can implement interfaces or derive from other classes.
3. A singleton class can have instance members,

Default modifier for class internal.

Default modifier for interface public.

Default modifier for property is private.

No, it is not compulsory to override, it is optional.