What are constructors in C#?

Basically, there are five types of constructors:

• Static constructor
• Private constructor
• Copy constructor
• Default constructor
• Parameterized constructor

Explanation:

1. Default constructor: It is the constructor with no parameters. It is automatically generated by the compiler if no other constructors are defined in a class.
2. Parameterized constructor: It is the constructor with one or more parameters. It allows the developer to pass initial values for the object's properties or fields when creating an instance of the class.
3. Static constructor : is a constructor that is used to initialize a class, it is invoked only once, it is the first thing that is executed in a class before an instance of the class is created or any static method is invoked.
4. Private Constructor : Private constructors are typically used in classes that contain only static members.

Static constructor is used to initialize static data members as soon as the class is referenced first time.

class SimpleClass
{
    // Static variable that must be initialized at run time.
    static readonly long baseline;

    // Static constructor is called at most one time, before any
    // instance constructor is invoked or member is accessed.
    static SimpleClass()
    {
        baseline = DateTime.Now.Ticks;
    }
}

A static constructor is used to initialize any

Method overloading is mechanism to create multiple methods with the same name and unique signature in the same class. When you go for compilation, the compiler uses overload resolution to determine the specific method to be invoked.

With method overloading, multiple methods can have the same name with different parameters:

Example

int MyMethod(int x)
float MyMethod(float x)
double MyMethod(double x, double y) 

Consider the following example, which have two methods that add numbers of different type:

Example

using System;

namespace MyApplication
{
  class Program
  {
    static int PlusMethodInt(int x, int y)
    {
      return x + y;
    }

    static double PlusMethodDouble(double x, double y)
    {
      return x + y;
    }

    static void Main(string[] args)
    {
      int myNum1 = PlusMethodInt(8, 5);
      double myNum2 = PlusMethodDouble(4.3, 6.26);
      Console.WriteLine("Int: " + myNum1);
      Console.WriteLine("Double: " + myNum2);
    }  
  }
}

Output

Int: 13
Double: 10.559999999999999

Instead of defining two methods that should do the same thing, it is better to overload one. In the example below, we overload the PlusMethod method to work for both int and double:

Example

using System;

namespace MyApplication
{
  class Program
  {
    static int PlusMethod(int x, int y)
    {
      return x + y;
    }

    static double PlusMethod(double x, double y)
    {
      return x + y;
    }

    static void Main(string[] args)
    {
      int myNum1 = PlusMethod(8, 5);
      double myNum2 = PlusMethod(4.3, 6.26);
      Console.WriteLine("Int: " + myNum1);
      Console.WriteLine("Double: " + myNum2);
    }  
  }
}

Output

Int: 13
Double: 10.559999999999999

Note: Multiple methods can have the same name as long as the number and/or type of parameters are different.

no, not possible

An array is a set of related instances either value or reference types.

There are three types of array supported by C#:

• Single Dimensional Array: It contains a single row. It is also known as a vector array.
• Multi-Dimensional Array: It is rectangular and contains rows and columns.
• Jagged Array: It also contains rows and columns but it has an irregular shape.

ArrayList is a dynamic array. You can add and remove the elements from an ArrayList at runtime. In the ArrayList, elements are not automatically sorted.

A collection works as a container for instances of other classes. All classes implement ICollection interface.

Interface is an abstract class that has only public abstract method. These methods only have declaration not the definition. These abstract methods must be implemented in the inherited classes.

Lock statement is used to ensure that one thread doesn't enter a critical section of code while another thread is in the critical section. If another thread attempts to enter a locked code it will wait, block, until the object is released.

If you want to transport an object through network then you have to convert the object into a stream of bytes. The process of converting an object into a stream of bytes is called serialization.