C# - The Sealed Keyword

The sealed Keyword in C#

The sealed keyword  in C# is a powerful construct that is used to restrict inheritance. It prevents other classes from deriving from a class or prevents a method from being overridden further in a derived class. This concept plays a crucial role in enforcing encapsulation, optimizing performance, and securing class designs. In this guide, we will explore the sealed keyword in-depth, examining its use in classes, methods, real-world applications, and best practices.

Understanding the sealed Keyword

The sealed keyword can be applied in two primary contexts:

• To a class, preventing it from being inherited.
• To a method in a derived class, preventing further overriding.

Why Seal Classes or Methods?

There are several reasons for using the sealed keyword:

• To maintain control over a class’s behavior.
• To improve performance by allowing method inlining.
• To prevent misuse of classes that are not designed for inheritance.
• To signal the developer’s intention that no further derivation is allowed.

Using sealed with Classes

When a class is marked as sealed, it cannot be used as a base class. This is useful for utility, helper, or internal classes that should not be extended.

Syntax

sealed class FinalClass
{
    public void Display()
    {
        Console.WriteLine("This is a sealed class.");
    }
}
    

Attempting to Inherit a Sealed Class

// This will cause a compile-time error
class DerivedClass : FinalClass
{
}
    

Trying to inherit from a sealed class will result in a compilation error: "Cannot derive from sealed type 'FinalClass'".

Using sealed with Methods

A method can be marked as sealed when it is part of a class hierarchy and has been overridden. Marking a method as sealed ensures that no further overriding can occur beyond the current class.

Syntax

class Base
{
    public virtual void Show()
    {
        Console.WriteLine("Base implementation");
    }
}

class Derived : Base
{
    public sealed override void Show()
    {
        Console.WriteLine("Derived sealed implementation");
    }
}

class SubDerived : Derived
{
    // Compile-time error: cannot override sealed method
    // public override void Show()
    // {
    //     Console.WriteLine("Attempting to override");
    // }
}
    

In this example, the method Show() in the Derived class is sealed and thus cannot be overridden in the SubDerived class.

Practical Applications of Sealed Classes

Security and Integrity

Sealing a class can protect critical business logic from being altered through inheritance. This ensures that the functionality remains consistent and secure.

Performance Optimization

Sealed methods are not subject to override, which allows the JIT compiler to optimize the method calls more aggressively through techniques like inlining.

Framework Design

In large frameworks, base classes are often sealed to prevent clients from extending them incorrectly, which could lead to maintenance challenges.

Utility Classes

Utility or static classes are often sealed to indicate that they are not intended to be inherited.

Example: Sealed Class in a Banking Application

sealed class BankTransaction
{
    public void ProcessTransaction()
    {
        Console.WriteLine("Processing transaction securely.");
    }
}
    

By sealing the BankTransaction class, the developer ensures that no other class can alter the logic through inheritance, thus preserving the security and correctness of the implementation.

Example: Sealed Method in Logging System

class Logger
{
    public virtual void Log(string message)
    {
        Console.WriteLine($"Base log: {message}");
    }
}

class FileLogger : Logger
{
    public sealed override void Log(string message)
    {
        Console.WriteLine($"File log: {message}");
    }
}
    

Here, the log method in FileLogger is sealed to prevent further customization, which can be important in compliance or audit scenarios.

Sealed vs Abstract vs Virtual

Best Practices When Using sealed

• Seal classes that are not intended for extension.
• Seal methods to lock down specific behavior when needed.
• Document the reasoning behind sealing for clarity to other developers.
• Avoid overusing sealed in APIs intended for extensibility.

Sealed Keyword in Combination with Other Modifiers

Sealed and Static

A class marked static is implicitly sealed. You cannot inherit from a static class.

static class Utility
{
    public static void DoWork()
    {
        Console.WriteLine("Work done.");
    }
}
    

Sealed and Abstract

Not allowed. You cannot mark a class as both sealed and abstract because it is a contradiction. An abstract class is meant to be extended, while a sealed class cannot be extended.

Real-World Examples of Sealed Classes in .NET

Many .NET framework classes are sealed. Examples include:

• System.String
• System.Int32
• System.DateTime
• System.Math (static and implicitly sealed)
• System.Convert

These classes are sealed to prevent modification of core behavior, improve performance, and maintain reliability across the .NET ecosystem.

Performance Considerations

Sealing methods or classes can provide small performance gains in tight loops or performance-critical applications, because:

• JIT (Just-in-Time) compiler can optimize calls more aggressively.
• Virtual method table lookups are avoided for sealed methods.
• Improved predictability for compilers and developers.

When Not to Use Sealed

• When designing base classes meant for extension.
• When future changes might require subclassing.
• When writing APIs or frameworks for third-party usage.

Alternative: Internal Classes

Sometimes sealing is confused with access restriction. If you simply want to prevent use outside of an assembly, consider using the internal modifier instead of sealing the class.

internal class InternalClass
{
    // Accessible only within the same assembly
}
    

Refactoring Sealed Classes

If a class was sealed but later you decide to allow extension, simply remove the sealed keyword. However, be cautious:

• Review how the class was used.
• Ensure documentation reflects the change.
• Write unit tests to protect against unexpected behaviors.

The sealed keyword in C# is a vital part of the language’s type safety and design principles. It provides developers the ability to finalize class hierarchies or lock down method behavior for security, clarity, and performance. Used correctly, it helps in maintaining strong object-oriented design by explicitly expressing intent and boundaries in your code.

• Use sealed classes to prevent inheritance where necessary.
• Use sealed methods to finalize behavior in a hierarchy.
• Understand when sealing aids performance versus when it hinders extensibility.
• Recognize sealed classes in the .NET library as trusted and optimized core components.

By mastering the use of the sealed keyword, developers can produce safer, more maintainable, and performant code.