Skip to main content

.NET Sealed Classes

Introduction​

In object-oriented programming, inheritance allows classes to extend functionality from other classes, creating a hierarchical structure. However, sometimes you might want to prevent other classes from inheriting from your class. This is where sealed classes come into play in .NET.

A sealed class is a class that cannot be used as a base class. Once a class is marked as sealed, no other class can inherit from it. This concept is an important part of .NET's object-oriented design, providing security, performance benefits, and design clarity.

Understanding Sealed Classes​

Basic Syntax​

In C#, you can create a sealed class by using the sealed keyword before the class definition:

csharp
sealed class MyClass
{
    // Class members
}

This simple declaration prevents any other class from using MyClass as a parent or base class.

How Sealed Classes Work​

To understand sealed classes better, let's look at an example of what happens when you try to inherit from a sealed class:

csharp
sealed class Vehicle
{
    public void StartEngine()
    {
        Console.WriteLine("Engine started");
    }
}

// The following code will cause a compilation error
class Car : Vehicle  // Error: Cannot derive from sealed type 'Vehicle'
{
    public void Drive()
    {
        Console.WriteLine("Car is moving");
    }
}

If you try to compile this code, you'll get an error indicating that you cannot derive from the sealed type Vehicle.

Why Use Sealed Classes?​

There are several reasons why you might want to use sealed classes in your .NET applications:

1. Security​

By sealing a class, you prevent potentially malicious or incorrect extensions of your class. This can be critical for classes that implement security functionality.

2. Performance Optimization​

The .NET runtime can optimize calls to sealed classes since it knows that virtual methods cannot be overridden. This can lead to performance improvements in some scenarios.

3. Design Intent​

Sealing a class clearly communicates to other developers that this class was designed to be used as is, and not as a base class for further extension.

4. Immutability Support​

Sealed classes often pair well with immutable designs, reinforcing the notion that a class's behavior should not change.

Practical Examples of Sealed Classes​

Example 1: Configuration Manager​

Here's a practical example of a sealed class that manages application configuration:

csharp
sealed class ConfigurationManager
{
    private static ConfigurationManager _instance;
    private Dictionary<string, string> _settings;
    
    private ConfigurationManager()
    {
        _settings = new Dictionary<string, string>();
        LoadSettings();
    }
    
    public static ConfigurationManager Instance
    {
        get
        {
            if (_instance == null)
                _instance = new ConfigurationManager();
            return _instance;
        }
    }
    
    private void LoadSettings()
    {
        // Load settings from a file or database
        _settings.Add("DatabaseConnection", "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;");
        _settings.Add("LogLevel", "Info");
    }
    
    public string GetSetting(string key)
    {
        if (_settings.ContainsKey(key))
            return _settings[key];
        return null;
    }
}

Usage:

csharp
class Program
{
    static void Main()
    {
        var dbConnection = ConfigurationManager.Instance.GetSetting("DatabaseConnection");
        Console.WriteLine($"Database Connection: {dbConnection}");
        
        // Output: Database Connection: Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;
    }
}

In this example, ConfigurationManager is sealed because:

  • It follows the Singleton pattern and shouldn't be extended
  • It manages critical application settings that shouldn't be altered by inheritance
  • Its behavior is designed to be consistent across the application

Example 2: Utility Classes​

Utility classes with static methods are often good candidates for sealed classes:

csharp
sealed class StringUtils
{
    // Private constructor prevents instantiation
    private StringUtils() { }
    
    public static string Reverse(string input)
    {
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
    
    public static bool IsPalindrome(string input)
    {
        string normalized = input.ToLower().Replace(" ", "");
        return normalized == Reverse(normalized);
    }
}

Usage:

csharp
class Program
{
    static void Main()
    {
        string original = "Hello World";
        string reversed = StringUtils.Reverse(original);
        
        Console.WriteLine($"Original: {original}");
        Console.WriteLine($"Reversed: {reversed}");
        
        string testPalindrome = "A man a plan a canal Panama";
        Console.WriteLine($"Is '{testPalindrome}' a palindrome? {StringUtils.IsPalindrome(testPalindrome)}");
        
        // Output:
        // Original: Hello World
        // Reversed: dlroW olleH
        // Is 'A man a plan a canal Panama' a palindrome? True
    }
}

Sealed Methods​

In addition to sealing entire classes, C# also allows sealing individual methods in a derived class that override methods from a base class. This prevents further derived classes from overriding those specific methods.

csharp
class BaseClass
{
    public virtual void Method1()
    {
        Console.WriteLine("BaseClass Method1");
    }
}

class DerivedClass : BaseClass
{
    public sealed override void Method1()
    {
        Console.WriteLine("DerivedClass Method1 - Cannot be overridden further");
    }
}

class FurtherDerivedClass : DerivedClass
{
    // This would cause a compilation error
    // public override void Method1() { }  // Error: Cannot override sealed method
}

When to Use Sealed Classes​

Sealed classes are best used in these scenarios:

  1. When the class represents an immutable entity: Like String in .NET
  2. When inheritance could compromise security or functionality: For security-critical components
  3. In utility classes with purely static methods: To prevent improper inheritance
  4. When implementing design patterns like Singleton: To maintain pattern integrity
  5. When a class's behavior must remain consistent: For classes where alterations could cause system instability

Best Practices​

  • Don't seal classes by default: Only seal classes when you have a specific reason to prevent inheritance
  • Document why a class is sealed: Help other developers understand your design decisions
  • Consider alternatives first: Interfaces and composition often provide better design solutions than inheritance
  • Understand the trade-off: Sealing restricts extensibility, which might not always be desirable

Common Sealed Classes in the .NET Framework​

The .NET Framework itself contains several sealed classes, including:

  • String: String operations are fundamental and require consistent behavior
  • Math: Contains only static utility methods
  • DateTime: Represents a specific point in time that shouldn't be alterable by inheritance
  • Uri: Ensures consistent URI parsing and handling

Summary​

Sealed classes in .NET prevent inheritance, which can lead to improved security, performance optimizations, and clearer design intent. By marking a class as sealed, you communicate that the class is not designed to be extended through inheritance.

Remember to use sealed classes judiciously, as they restrict one of the fundamental features of object-oriented programming. In many cases, other design approaches like interfaces, composition, or abstract classes might provide better solutions.

Exercises​

  1. Create a sealed class Logger that implements the Singleton pattern and provides methods for logging messages at different levels (Info, Warning, Error).

  2. Design a sealed utility class MathUtils with static methods for common mathematical operations not found in the standard Math class.

  3. Refactor an existing class in one of your projects to be sealed. Document your reasoning and any challenges you encountered.

  4. Create a base class with virtual methods, then create a derived class that seals some of those methods. Test to see what happens when you try to override the sealed methods.

Additional Resources​


If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)