Learn about Sealed Classes in C#

Introduction

In the world of C# programming, sealed classes are a powerful construct that provides control over inheritance. When a class is sealed, it cannot be inherited, which has benefits such as performance optimization and security. However, there may be situations where the strictness of sealed classes can be limiting, especially when it comes to modifying or extending their behavior. This article explores various techniques for unlocking sealed classes in C# programming, along with practical examples to illustrate each approach.

Sealed Classes in C#

In C#, the sealedthe keyword marks a class as sealed, meaning other classes cannot inherit it. Sealed classes are often used to prevent further derivation for various reasons like ensuring a class's integrity or optimization. Here's a basic example of a sealed class:

sealed class SealedClass
{
    public void Method1()
    {
        Console.WriteLine("Method1 called from sealed class.");
    }
}

The Challenge: Extending Sealed Classes

Suppose we have a scenario where we need to extend the functionality of the SealedClass without modifying its source code. This situation is common in software development when dealing with third-party libraries or legacy code. Let's explore different techniques to address this challenge.

1. Extension Methods

Extension methods allow adding new methods to existing types without altering their structure. While they cannot directly access private members of sealed classes, they offer a convenient way to extend functionality.

static class SealedClassExtensions
{
    public static void NewMethod(this SealedClass sealedObj)
    {
        Console.WriteLine("NewMethod called from extension method.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        SealedClass sealedObj = new SealedClass();
        sealedObj.Method1(); // Output: Method1 called from sealed class.
        sealedObj.NewMethod(); // Output: NewMethod called from extension method.
    }
}

2. Decorator Pattern

The decorator pattern involves wrapping an object within another object to dynamically add behavior. This approach maintains the open/closed principle by allowing extension without modification.

class SealedClassDecorator
{
    private SealedClass _sealedObj;

    public SealedClassDecorator(SealedClass sealedObj)
    {
        _sealedObj = sealedObj;
    }

    public void NewMethod()
    {
        Console.WriteLine("NewMethod called from decorator.");
    }

    // Pass through original method
    public void Method1()
    {
        _sealedObj.Method1();
    }
}

class Program
{
    static void Main(string[] args)
    {
        SealedClass sealedObj = new SealedClass();
        SealedClassDecorator decorator = new SealedClassDecorator(sealedObj);

        decorator.Method1(); // Output: Method1 called from sealed class.
        decorator.NewMethod(); // Output: NewMethod called from decorator.
    }
}

Conclusion

Sealed classes play a crucial role in C# development, ensuring code integrity and performance optimization. However, they can present challenges when the need arises to extend or modify their behavior. By leveraging techniques such as extension methods and the decorator pattern, developers can effectively unlock the capabilities of sealed classes without compromising code integrity. These approaches foster code reuse, maintainability, and flexibility, allowing for seamless integration of new features into existing codebases. Whether dealing with sealed classes from external libraries or within your own projects, understanding these techniques empowers developers to overcome limitations and build more extensible software solutions.