What is an Abstract Class in C#

Abstraction refers to the process of hiding implementation details while revealing essential features of a program. It helps in building complex software systems by simplifying their structure and making them more manageable. C# provides two ways to implement abstraction: interfaces and abstract classes.

An interface defines a contract and a class must implement that, while an abstract class provides a base implementation that can be extended by derived classes. Abstraction in C# helps in achieving loose coupling, modular design, and code reuse.

Abstract class cannot be instantiated and serves as a base class for other classes. It is declared using the abstract keyword in C#. Abstract classes give us way to define a base set of functionality that can be shared by multiple derived classes.

Abstract classes are used in C# for several reasons, including

1. Providing a common base class for related classes
2. Defining default behavior that can be overridden by derived classes
3. Enforcing a contract that derived classes must implement

Abstract class differs from a concrete class in that it cannot be instantiated. It may contain both abstract and non-abstract methods and properties. Abstract methods are declared using the "abstract" keyword and do not provide an implementation. They must be implemented by the derived classes.

Abstract classes have several key features in C#. They include

1. The ability to declare both abstract and non-abstract methods and properties
2. The ability to implement constructors and destructors
3. The ability to use access modifiers such as public, private, protected, and internal
4. The ability to use other keywords with abstract classes, such as "struct", "partial", "seal", and "static"

The "struct" keyword can be used to create a value type that contains both data and behavior. The "partial" keyword is used to split the definition of a class across multiple files. We can use "seal" keyword to prevent further derivation of a class, and the "static" keyword can be used to create a class that can only contain static members. By applying these keywords to the class, the class will become a C# sealed class, C# partial class, and C# static class !

Abstract classes and static classes are two different constructs in C#. While both provide a way to define a set of functionality that can be shared by multiple classes, they have some key differences.

Abstract class cannot be instantiated, while a static class can be. Abstract class can contain both abstract and non-abstract methods, while a static class can only contain static members. And the abstract class is used as a base class for derived classes, while a static class is used to contain helper functions and other utility methods.

Creating an abstract class in C# is almost similar to creating any other class. The only difference is that the abstract keyword is used to declare the class as abstract.

public abstract class MyAbstractClass
{
    // Members and methods of the abstract class
}

To use an abstract class in C#, you must inherit from it and provide implementations for all its abstract methods.

public abstract class Shape
{
    public abstract void Display();
}

public class Rectangle : Shape
{
    public override void Display()
    {
        Console.WriteLine("This is a rectangle.");
    }
}

public class Circle : Shape
{
    public override void Display()
    {
        Console.WriteLine("This is a circle.");
    }
}

In this example, we have two concrete classes Rectangle and Circle that inherit from the abstract class Shape. Both classes provide an implementation for the Display method defined in the abstract class.

An abstract method is declared in an abstract class but does not provide an implementation. It is declared by using the "abstract" keyword and must be implemented by the derived classes. Abstract methods help in defining a contract that derived classes must implement.

Example of an abstract method in C#:

public abstract void Display();

An abstract method is always declared in an abstract class. It does not have an implementation, and its signature ends with a semicolon instead of curly braces. Subclasses that inherit the abstract class must provide an implementation for all abstract methods defined in the base abstract class.

Example of an abstract class that defines an abstract method:

public abstract class Shape
{
    public abstract void Display();
}

In this example, the abstract class Shape has an abstract method Display. Any class that inherits from Shape must have to implement the Display method.

Let's define a concrete class Rectangle that inherits from Shape and provides an implementation for the Display method:

public class Rectangle : Shape
{
    public override void Display()
    {
        Console.WriteLine("This is a rectangle.");
    }
}

It's important to note that if a subclass does not provide an implementation for an abstract method, it must also be declared as abstract. This means that any class that inherits from the subclass must provide an implementation for the abstract method.

public abstract class Quadrilateral : Shape
{
    // No implementation provided for Display method
}
public class Square : Quadrilateral
{
    public override void Display()
    {
        Console.WriteLine("This is a square.");
    }
}

In this example, the Quadrilateral class is also abstract because it does not provide an implementation for the Display method. The Square class provides an implementation for the Display method, but it also inherits the abstract nature of its base class.

There are several benefits of abstract class in C#. Some of these benefits include:

1. Encourages code reuse: Abstract classes provide a way to define common functionality that can be shared across multiple subclasses.
2. Promotes consistency: By defining a common contract through the abstract class, it helps ensure that subclasses adhere to a consistent design and behavior. lement constructors and destructors
3. Provides a level of abstraction: Abstract classes allow developers to work at a higher level of abstraction, focusing on the overall design and functionality of the code rather than getting bogged down in implementation details.