Property or properties in C#

 What is Property in C#?

In C#, a property is a member of a class that encapsulates a private field and provides a way to read or write its value. Properties provide a more controlled way to access and modify the data within a class than simply exposing the private field directly.

A property is defined using a combination of a get accessor and/or a set accessor. The get accessor returns the value of the property, while the set accessor assigns a new value to the property.

Here's an example of a property:

public class clsPerson

{

    private string name;

    public string Name

    {

        get { return name; }

        set { name = value; }

    }

}

In this example, the "clsPerson" class has a private field called "name", which is encapsulated by a public property called "Name". The get accessor returns the value of the "name" field, while the set accessor assigns a new value to the field.

Properties can also have additional logic within their accessors to enforce constraints or perform other actions when the property is read or written. Here's an example of a property with additional logic:

public class clsBankAccount

{

    private decimal balance;

    public decimal Balance

    {

        get { return balance; }

        set

        {

            if (value < 0)

            {

                throw new ArgumentException("Balance cannot be negative");

            }

            balance = value;

        }

    }

}

In this example, the "clsBankAccount" class has a private field called "balance", which is encapsulated by a public property called "Balance". The set accessor includes a check to ensure that the value being assigned to the property is not negative. If the value is negative, an exception is thrown. This ensures that the balance of the bank account is always non-negative.

Difference between abstract class and interface

 Difference between abstract class and interface in C#

In C#, both abstract classes and interfaces provide a way to define a set of rules for how classes can interact with each other, but there are some key differences between them:

1. Implementation: An abstract class can have both abstract and non-abstract methods, while an interface can only define method signatures. This means that an abstract class can provide some implementation details, while an interface only defines a contract for how classes should behave.

2. Inheritance: A class can only inherit from one abstract class, but it can implement multiple interfaces. This means that interfaces provide a more flexible way to define behavior across multiple classes.

3. Accessibility: Members of an interface are public by default, while members of an abstract class can have any access modifier. This means that an abstract class can have members that are only visible within the class hierarchy, while an interface only defines public members.

4. Purpose: An abstract class is typically used to provide a base class for a set of related classes, while an interface is used to define a contract for how unrelated classes should behave. In other words, an abstract class defines a common set of behaviors for a family of related classes, while an interface defines a common set of behaviors for unrelated classes.

Here's an example of an abstract class:

public abstract class Shape

{

    public abstract double GetArea();

    public void PrintDetails()

    {

        Console.WriteLine($"Area: {GetArea()}");

    }

}

In this example, the "Shape" abstract class defines an abstract method called "GetArea", which must be implemented by any class that derives from the "Shape" class. The class also has a non-abstract method called "PrintDetails", which can be used by any derived class. The class hierarchy might look like this:

public class Rectangle : Shape

{

    public double Width { get; set; }

    public double Height { get; set; }

    public override double GetArea()

    {

        return Width * Height;

    }

}

public class Circle : Shape

{

    public double Radius { get; set; }

    public override double GetArea()

    {

        return Math.PI * Radius * Radius;

    }

}

In this example, both the "Rectangle" and "Circle" classes derive from the "Shape" abstract class and implement the "GetArea" method in their own way.

Here's an example of an interface:

public interface IShape

{

    double GetArea();

}

In this example, the "IShape" interface defines a method called "GetArea", which must be implemented by any class that implements the "IShape" interface. Classes might implement the interface like this:

public class Rectangle : IShape

{

    public double Width { get; set; }

    public double Height { get; set; }

    public double GetArea()

    {

        return Width * Height;

    }

}

public class Circle : IShape

{

    public double Radius { get; set; }

    public double GetArea()

    {

        return Math.PI * Radius * Radius;

    }

}

In this example, both the "Rectangle" and "Circle" classes implement the "IShape" interface and provide their own implementation for the "GetArea" method.

Interface in C#

 What is an interface in C#?

In C#, an interface is a contract that specifies a set of methods, properties, and events that a class must implement. An interface defines a set of rules for how classes can interact with each other, and provides a way to achieve polymorphism in object-oriented programming.

Here's an example of an interface:

public interface IShape

{

    double GetArea();

}

In this example, the "IShape" interface defines a method called "GetArea", which is used to calculate the area of a shape. Any class that implements the "IShape" interface must provide an implementation for the "GetArea" method.

Here's an example of a class that implements the "IShape" interface:

public class Rectangle : IShape

{

    public double Width { get; set; }

    public double Height { get; set; }

    public double GetArea()

    {

        return Width * Height;

    }

}

In this example, the "Rectangle" class implements the "IShape" interface and provides an implementation for the "GetArea" method. The class has properties for the width and height of the rectangle, and the "GetArea" method calculates the area of the rectangle by multiplying the width and height.

Interfaces are useful for creating a set of rules for how classes can interact with each other. They provide a way to define a common set of methods, properties, and events that classes must implement, while also allowing for different implementations of those members. Interfaces also provide a way to achieve polymorphism, allowing objects to be treated as different types at runtime based on their implementation of a shared interface.

Singleton class in C#

 What is singleton class in C#?

In C#, a singleton class is a class that can only have one instance, which is shared throughout the application. The singleton pattern is a design pattern that ensures that a class has only one instance, and provides a global point of access to that instance.

Here's an example of a singleton class:

public class Singleton

{

    private static Singleton _instance;

    private Singleton() { }

    public static Singleton Instance

    {

        get

        {

            if (_instance == null)

            {

                _instance = new Singleton();

            }

            return _instance;

        }

    }

    public void DoSomething()

    {

        // do something

    }

}

In this example, the "Singleton" class has a private constructor, which means that it cannot be instantiated directly from outside the class. The class also has a static property called "Instance", which returns the single instance of the class. The property first checks if an instance of the class has already been created; if not, it creates a new instance and returns it.

You can access the single instance of the class using the "Instance" property, like this:

Singleton singleton = Singleton.Instance;

singleton.DoSomething();

In this example, the "Instance" property of the "Singleton" class is used to retrieve the single instance of the class. The "DoSomething" method of the class is then called on the instance.

Singleton classes are useful in scenarios where you want to ensure that there is only one instance of a class throughout the application. They can be particularly useful in managing shared resources, such as database connections, file handles, or network connections, where multiple instances of a class could cause conflicts or performance issues.

Sealed class in C#

What is sealed class in C#?

 In C#, a sealed class is a class that cannot be inherited by other classes. Once a class is declared as sealed, it cannot be extended or derived from by any other class. This means that you cannot create a new class that inherits from a sealed class.

Here's an example of a sealed class:

sealed class clsEmployee

{

    public string Name { get; set; }

    public int Age { get; set; }

    public decimal Salary { get; set; }

}

In this example, the "clsEmployee" class is declared as sealed, which means that it cannot be inherited by any other class. The class has properties for the name, age, and salary of an employee.

Sealed classes are useful in scenarios where you want to restrict the inheritance of a class. By sealing a class, you can prevent other developers from extending or modifying the behavior of the class. This can be particularly useful when you are creating a class that has sensitive or critical functionality, where changes to the behavior of the class could have serious consequences.

It's important to note that you can only seal a class that is not already marked as abstract. Additionally, you cannot mark individual members of a class as sealed – only the entire class can be sealed.

Abstract class in C#

What is an abstract class in C#?

 In C#, an abstract class is a class that cannot be instantiated directly, but can be used as a base class for other classes. An abstract class is designed to be inherited by other classes, and it provides a base implementation for its derived classes.

An abstract class can contain both abstract and non-abstract members. An abstract member is a member that is declared without implementation, meaning that it has no method body. Derived classes must provide an implementation for all abstract members of the abstract class.

Here's an example of an abstract class:

abstract class clsShape

{

    public abstract double GetArea();

}

In this example, the "clsShape" class is declared as abstract, which means that it cannot be instantiated directly. The class has an abstract method called "GetArea", which is declared without implementation. This means that any class that derives from the "clsShape" class must provide an implementation for the "GetArea" method.

Here's an example of a class that derives from the "clsShape" class:

class clsRectangle : clsShape

{

    public double Width { get; set; }

    public double Height { get; set; }

    public override double GetArea()

    {

        return Width * Height;

    }

}

In this example, the "clsRectangle" class derives from the "clsShape" class and provides an implementation for the "GetArea" method. The class has properties for the width and height of the rectangle, and the "GetArea" method calculates the area of the rectangle by multiplying the width and height.

Abstract classes are useful for creating a hierarchy of related classes that share common functionality. They provide a way to define a set of methods and properties that derived classes must implement, while also providing a default implementation for those members that can be reused by the derived classes. Abstract classes cannot be instantiated directly, but they can be used as a type for variables, parameters, and return values.

Copy constructor in C#

 What is copy constructor in C#?

In C#, a copy constructor is a constructor method that creates a new object by copying the values of another object of the same type. The copy constructor is used to create a new instance of an object that has the same data as an existing object.

The copy constructor takes an object of the same type as a parameter, and it initializes the new object's data members with the same values as the existing object's data members.

Here's an example of a copy constructor:

class clsPerson

{

    public string Name { get; set; }

    public int Age { get; set; }

    public clsPerson()

    {

        // Default constructor

    }

    public clsPerson(Person other)

    {

        // Copy constructor

        Name = other.Name;

        Age = other.Age;

    }

}

```

In this example, the "clsPerson" class has a copy constructor that takes an object of the same type as a parameter. The constructor initializes the new object's "Name" and "Age" properties with the same values as the corresponding properties of the object passed in as a parameter.

You can create a new instance of the "clsPerson" class using the copy constructor as follows:

ClsPerson p1 = new clsPerson();

p1.Name = "Dheeraj Kumar";

p1.Age = 25;

ClsPerson p2 = new clsPerson(p1); // Create a copy of p1

In this example, the "p2" object is created using the copy constructor of the "clsPerson" class, which takes "p1" as a parameter. The "Name" and "Age" properties of "p2" are initialized with the same values as the corresponding properties of "p1".

Copy constructors are useful when you want to create a new object that is a copy of an existing object. They provide a way to create a new object with the same data as an existing object, without having to manually copy each data member or property.