C# - The Sealed Keyword

Sealed Class in C#

The sealed keyword in C# is used to prevent a class or method from being inherited or overridden further. It can be applied to:

• Classes: A sealed class cannot be inherited.
• Methods: A sealed method in a derived class cannot be overridden again.

1. Sealed Classes

A sealed class is useful when you want to restrict the class from being a base class, ensuring no other class can derive from it.

public sealed class ClassName
{
    // Members of the class
}

Real-Time Example: Logger Utility

A logging utility class is often made sealed to ensure it cannot be extended, preserving its behavior.

public sealed class Logger
{
    private static Logger _instance;

    // Private constructor to prevent instantiation
    private Logger() { }

    public static Logger Instance => _instance ??= new Logger();

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

Usage

var logger = Logger.Instance;
logger.Log("Application started.");
// Inheriting Logger is not allowed due to the sealed keyword

2. Sealed Methods

A sealed method is used in a derived class to prevent further overriding. This is useful when you want to finalize a method’s behavior in a derived class.

public class BaseClass
{
    public virtual void Display()
    {
        Console.WriteLine("Base Class Display");
    }
}

public class DerivedClass : BaseClass
{
    public sealed override void Display()
    {
        Console.WriteLine("Derived Class Display");
    }
}

public class SubDerivedClass : DerivedClass
{
    // Cannot override Display method as it is sealed in DerivedClass
}

Real-Time Example: Payment Processing System

Imagine a payment system where a ProcessPayment method in a derived class should not be overridden further for security reasons.

public class PaymentProcessor
{
    public virtual void ProcessPayment(decimal amount)
    {
        Console.WriteLine($"Processing payment of {amount:C}");
    }
}

public class SecurePaymentProcessor : PaymentProcessor
{
    public sealed override void ProcessPayment(decimal amount)
    {
        // Add security checks
        Console.WriteLine($"Securely processing payment of {amount:C}");
    }
}

// Any further derived class cannot override ProcessPayment

Usage

PaymentProcessor processor = new SecurePaymentProcessor();
processor.ProcessPayment(100.00m);
// Further overrides of ProcessPayment are not allowed

When to Use the sealed Keyword?

• Prevent Extensibility: When you have a class or method that must not be changed.
• Security: For methods that implement critical logic (e.g., authentication or payment processing).
• Optimization: Sealing classes or methods allows the compiler to optimize certain operations for better performance.
  

Key Points:

• A sealed class cannot act as a base class.
• A sealed method can only exist in a class that is marked override.
• You cannot use sealed with abstract because abstract requires inheritance, and sealed prevents it.