Abstract Classes and Interfaces in C# Programming

Introduction

In C#, both abstract classes and interfaces are used to define the structure of a class or object. However, they serve different purposes and have different behaviors. Both are essential tools in object-oriented programming (OOP) and allow you to design and organize your code effectively.

This tutorial will explain:

• What abstract classes are and how they are used.
• What interfaces are and how they are used.
• The key differences between abstract classes and interfaces.

Abstract Classes

An abstract class is a class that cannot be instantiated directly. It can contain abstract methods (methods without implementation) that must be implemented by derived classes. Abstract classes can also have concrete methods (methods with implementation) that can be inherited by derived classes.

Key Points about Abstract Classes:

• An abstract class cannot be instantiated directly.
• It can contain both abstract methods (without implementation) and regular methods (with implementation).
• Abstract methods must be implemented in derived classes.

Syntax for Abstract Class

    abstract class ClassName
    {
        // Abstract method (must be implemented by derived class)
        public abstract void AbstractMethod();
           // Regular method (can be inherited)
        public void RegularMethod()
        {
            Console.WriteLine("This is a regular method.");
        }
    }
        

Example: Abstract Class

Let's create an abstract class called Shape with an abstract method Draw and a regular method DisplayInfo.

    using System;     abstract class Shape
    {
        // Abstract method
        public abstract void Draw();         // Regular method
        public void DisplayInfo()
        {
            Console.WriteLine("This is a shape.");
        }
    }     class Circle : Shape
    {
        // Implementing the abstract method
        public override void Draw()
        {
            Console.WriteLine("Drawing a circle.");
        }
    }     class Program
    {
        static void Main()
        {
            // Cannot instantiate an abstract class
            // Shape shape = new Shape();  // This will cause an error             Circle circle = new Circle();
            circle.Draw();      // Output: Drawing a circle.
            circle.DisplayInfo();  // Output: This is a shape.
        }
    }
        

Output:

    Drawing a circle.
    This is a shape.
        

Interfaces

An interface is a contract that defines a set of methods and properties that a class must implement. Unlike abstract classes, interfaces cannot have any method implementation—only method signatures. A class that implements an interface must provide the implementation for all of the methods defined in the interface.

Key Points about Interfaces:

• An interface cannot have any implementation (no method bodies).
• A class can implement multiple interfaces.
• A class that implements an interface must implement all its methods and properties.

Syntax for Interface

    interface IInterfaceName
    {
        void Method1();
        void Method2();
    }
        

Example: Interface

Let's create an interface IDrawable with a method Draw. We will then implement this interface in a Rectangle class.

    using System;     interface IDrawable
    {
        void Draw();  // Method signature without implementation
    }     class Rectangle : IDrawable
    {
        // Implementing the Draw method
        public void Draw()
        {
            Console.WriteLine("Drawing a rectangle.");
        }
    }     class Program
    {
        static void Main()
        {
            // Instantiate the Rectangle class that implements the IDrawable interface
            IDrawable drawable = new Rectangle();
            drawable.Draw();  // Output: Drawing a rectangle.
        }
    }
        

Output:

    Drawing a rectangle.
        

Differences Between Abstract Classes and Interfaces

While both abstract classes and interfaces provide a way to define a contract for classes to implement, they differ in several key areas:

Conclusion

In this tutorial, we have covered the basics of abstract classes and interfaces in C# programming:

• Abstract Classes: They allow you to define methods with or without implementations, and are used when you want to share common functionality among related classes.
• Interfaces: They define a contract for classes to implement, but cannot provide any implementation themselves. A class can implement multiple interfaces.

Both abstract classes and interfaces are essential tools in object-oriented design. By using them appropriately, you can create flexible, maintainable, and reusable code in C#.