Interfaces and Abstract Classes in C#

Interfaces and abstract classes are essential components of object-oriented programming in C#. They provide a way to define contracts and templates that other classes must follow, ensuring consistency and flexibility in your code.

1. Interfaces

An interface in C# is a contract that defines a set of methods, properties, events, or indexers that a class must implement. An interface does not provide any implementation; it only defines the signature of the members. Multiple interfaces can be implemented by a single class, allowing for a high degree of flexibility.

Example:

interface IShape
{
    double CalculateArea();
    double CalculatePerimeter();
}

class Circle : IShape
{
    private double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public double CalculateArea()
    {
        return Math.PI * radius * radius;
    }

    public double CalculatePerimeter()
    {
        return 2 * Math.PI * radius;
    }
}

In this example, the IShape interface defines two methods: CalculateArea and CalculatePerimeter. The Circle class implements this interface, providing its own implementation for these methods.

2. Abstract Classes

An abstract class in C# is a class that cannot be instantiated on its own and is meant to be subclassed. It can contain both abstract and non-abstract members. Abstract members do not have an implementation in the abstract class and must be implemented by derived classes. Abstract classes provide a partial implementation and can serve as a base for other classes.

Example:

abstract class Animal
{
    public abstract void MakeSound();

    public void Sleep()
    {
        Console.WriteLine("Animal is sleeping.");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks.");
    }
}

In this example, the Animal class is abstract and contains an abstract method MakeSound and a non-abstract method Sleep. The Dog class inherits from Animal and provides an implementation for the MakeSound method.

3. Key Differences

While both interfaces and abstract classes provide a way to define contracts and templates, they have key differences:

• Multiple Inheritance: A class can implement multiple interfaces but can only inherit from one abstract class.
• Implementation: Interfaces cannot have any implementation, while abstract classes can have both abstract and non-abstract members.
• Usage: Use interfaces when you want to define a contract that multiple unrelated classes can implement. Use abstract classes when you want to provide a base implementation and enforce certain behavior in derived classes.

Conclusion

Understanding interfaces and abstract classes is crucial for writing flexible and maintainable code in C#. Interfaces allow you to define contracts that multiple classes can implement, while abstract classes provide a base for other classes with partial implementation. By mastering these concepts, you can create more robust and scalable applications.