Abstract and Sealed Classes in C#

What are Abstract Classes in C#?

Understanding abstract and sealed classes in C# is crucial for mastering object-oriented programming (OOP) concepts. These class types provide developers with powerful tools for controlling inheritance and designing scalable, maintainable code. In this comprehensive guide, we will explore the differences between abstract and sealed classes, their real-world applications, and practical C# examples.

An abstract class in C# is a class that cannot be instantiated on its own and is meant to serve as a base class for other classes. Abstract classes can contain:

• Abstract methods (methods without implementation)
• Non-abstract methods (methods with implementation)
• Properties, fields, and constructors

Features of Abstract Classes

• Cannot create an object of an abstract class directly
• Can include both abstract and concrete methods
• Supports inheritance and polymorphism
• Useful for defining a common interface for derived classes

Example of Abstract Class in C#

📄
using System;

abstract class Vehicle
{
    public abstract void Start();
    
    public void Honk()
    {
        Console.WriteLine("Honking...");
    }
}

class Car : Vehicle
{
    public override void Start()
    {
        Console.WriteLine("Car is starting...");
    }
}

class Program
{
    static void Main()
    {
        Car myCar = new Car();
        myCar.Start();  // Output: Car is starting...
        myCar.Honk();   // Output: Honking...
    }
}

In this example, the Vehicle class is abstract and cannot be instantiated directly. The Car class inherits from Vehicle and provides an implementation for the abstract Start method.

What are Sealed Classes in C#?

A sealed class in C# is a class that cannot be inherited. Sealed classes are useful when you want to restrict further derivation, ensuring that the implementation remains final and unmodified.

Features of Sealed Classes

• Cannot be used as a base class
• Helps improve security and encapsulation
• May improve performance slightly due to method call optimizations

Non-Abstract Methods in C#

In C#, a non-abstract method is a method that has a complete implementation in the class where it is defined. Unlike abstract methods, which only define the method signature and require derived classes to provide an implementation, non-abstract methods can be called directly on an object of the class (if the class itself is not abstract or is instantiated through a derived class).

Features of Non-Abstract Methods

• Has a complete implementation with a method body.
• Can be called directly using an object of the class.
• Can be inherited by derived classes and optionally overridden if marked with
  📄
  virtual.
• Provides common functionality that can be shared across derived classes.

Example of Non-Abstract Methods in C#

📄
using System;

abstract class Animal
{
    // Abstract method (must be implemented in derived class)
    public abstract void MakeSound();

    // Non-abstract method (has implementation)
    public void Sleep()
    {
        Console.WriteLine("The animal is sleeping...");
    }
}

class Dog : Animal
{
    // Implementation of abstract method
    public override void MakeSound()
    {
        Console.WriteLine("Dog says: Woof Woof!");
    }
}

class Program
{
    static void Main()
    {
        Dog myDog = new Dog();
        myDog.MakeSound(); // Output: Dog says: Woof Woof!
        myDog.Sleep();     // Output: The animal is sleeping...
    }
}

In this example:

• Sleep() is a non-abstract method and provides a default behavior for all animals. Derived classes like Dog can use it directly without modification.

When to Use Non-Abstract Methods

• To provide shared functionality across multiple derived classes.
• When you want to avoid repeating code in every derived class.
• To give default behavior that can optionally be overridden (if marked virtual).

Non-Abstract Methods with Inheritance

📄
using System;

class Vehicle
{
    public void Start()
    {
        Console.WriteLine("Vehicle is starting...");
    }
}

class Car : Vehicle
{
    // Inherits Start() from Vehicle
}

class Program
{
    static void Main()
    {
        Car myCar = new Car();
        myCar.Start(); // Output: Vehicle is starting...
    }
}

Here, Start() is a non-abstract method in the base class Vehicle. The derived class Car inherits it directly without needing to implement it, demonstrating code reuse.

Example of Sealed Class in C#

📄
using System;

sealed class Logger
{
    public void Log(string message)
    {
        Console.WriteLine($"Log entry: {message}");
    }
}

// The following line would produce an error
// class AdvancedLogger : Logger {}

class Program
{
    static void Main()
    {
        Logger logger = new Logger();
        logger.Log("Application started.");  // Output: Log entry: Application started.
    }
}

The Logger class is sealed and cannot be extended. This is particularly useful for classes that provide critical functionality you don’t want altered.

Abstract vs Sealed Classes in C#

When to Use Abstract Classes in Real-World C# Applications

• Defining a common interface for multiple related classes, like Vehicle, Animal, or Shape
• Implementing template methods where the base class provides the skeleton of an algorithm
• Encapsulating shared code while allowing flexibility for derived classes

When to Use Sealed Classes in Real-World C# Applications

• Creating utility classes like Logger, MathHelper, or ConfigurationManager that should not be extended
• Preventing inheritance to avoid misuse or maintain security in sensitive classes
• Improving performance slightly for critical sections of code

Tips for Using Abstract and Sealed Classes in C#

• Use abstract classes when you need polymorphism and shared functionality across multiple derived classes.
• Use sealed classes when you want to restrict further inheritance.
• Abstract classes can have constructors, fields, and methods; sealed classes can only have fully implemented members.
• Combine abstract classes with interfaces for flexible and maintainable designs.

Understanding abstract and sealed classes in C# is essential for any C# developer. Abstract classes enable polymorphism, code reuse, and a clear design structure, while sealed classes ensure security, performance, and controlled inheritance. By knowing when and how to use these concepts, developers can write cleaner, maintainable, and more efficient code.

FAQs About Abstract and Sealed Classes in C#

1. Can an abstract class be sealed in C#?

No, a class cannot be both abstract and sealed because abstract classes are designed for inheritance, while sealed classes prevent it.

2. Can a sealed class implement an interface in C#?

Yes, a sealed class can implement one or more interfaces. Only inheritance from another class is restricted.

3. Can an abstract class have constructors?

Yes, abstract classes can have constructors, which are called when a derived class is instantiated.

4. Is it possible to inherit a sealed class indirectly?

No, sealed classes cannot be inherited, either directly or indirectly, in C#.

5. When should I choose an abstract class over an interface in C#?

Use an abstract class when you want to share code among related classes and provide common functionality. Use an interface when you want to define a contract without implementation.