C# - Abstraction

Abstraction in C#

Abstraction is the concept of hiding the complex implementation details and showing only the necessary features of an object. It is achieved through abstract classes and interfaces.

Abstract Classes

An abstract class is a class that cannot be instantiated directly. It is meant to be inherited by other classes. Abstract classes can contain abstract methods, which are methods without implementation, as well as concrete methods with implementation.

public abstract class Animal
{
    public abstract void MakeSound();

    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

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

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

// Usage
Animal dog = new Dog();
dog.MakeSound(); // Output: Barking...
dog.Sleep();     // Output: Sleeping...

Animal cat = new Cat();
cat.MakeSound(); // Output: Meowing...
cat.Sleep();     // Output: Sleeping...

In this example, the Animal class is abstract and cannot be instantiated. It has an abstract method MakeSound which must be implemented by any non-abstract class that inherits from Animal. The Sleep method is a concrete method that provides a default implementation.

Interfaces

An interface is a completely abstract class that defines a set of methods and properties that a class must implement. Unlike abstract classes, interfaces do not contain any implementation.

public interface IAnimal
{
    void MakeSound();
    void Sleep();
}

public class Dog : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Barking...");
    }

    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

public class Cat : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Meowing...");
    }

    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

// Usage
IAnimal myDog = new Dog();
myDog.MakeSound(); // Output: Barking...
myDog.Sleep();     // Output: Sleeping...

IAnimal myCat = new Cat();
myCat.MakeSound(); // Output: Meowing...
myCat.Sleep();     // Output: Sleeping...

In this example, the IAnimal interface defines the contract for MakeSound and Sleep methods. Both Dog and Cat classes implement this interface and provide their own implementations for the methods.

Key Differences Between Abstract Classes and Interfaces

1. Implementation:

• Abstract classes can provide both abstract methods (without implementation) and concrete methods (with implementation).
• Interfaces can only provide method and property signatures (no implementation).

2. Multiple Inheritance:

• A class can inherit from only one abstract class due to C#'s single inheritance model.
• A class can implement multiple interfaces.

3. Use Cases:

• Use abstract classes when you want to provide common functionality to all derived classes.
• Use interfaces when you want to define a contract that multiple classes can implement.

Conclusion

Abstraction is a powerful concept in C# that helps in creating a clear separation between what an object does and how it does it. By using abstract classes and interfaces, you can design flexible and maintainable code that can easily adapt to changes and extensions.