C# Sealed Class (How It Works For Developers)

What are Sealed Classes and Sealed Methods?

Sealed Class: In C#, a sealed class is a class that cannot be inherited. By using the sealed keyword, developers can prevent other classes from deriving or extending from the sealed class. This deliberate restriction ensures that the sealed class cannot be used as a base class for any other class, limiting the scope of the inheritance hierarchy. Sealed classes are often employed when a developer wants to control and finalize the structure of a class, preventing unintended modifications through inheritance.

Consider the following example:

public sealed class Animal
{
    public string Species { get; set; }

    public void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

// The following code will cause a compilation error because 'Animal' is sealed and cannot be inherited:
// public class Dog : Animal // Error: Cannot inherit from sealed class 'Animal'
// {
// }

public sealed class Animal
{
    public string Species { get; set; }

    public void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

// The following code will cause a compilation error because 'Animal' is sealed and cannot be inherited:
// public class Dog : Animal // Error: Cannot inherit from sealed class 'Animal'
// {
// }

Unlike structs, which are implicitly sealed, the sealed class has to be declared using the sealed keyword as shown above. In this example, the Animal class is declared as sealed, making it impossible for any other class to inherit from it.

Sealed Method: In addition to sealing entire classes, C# also allows developers to seal individual methods within a class. A sealed method is a method that any derived class cannot override. This ensures that the behavior of the method remains consistent across all subclasses, providing a level of predictability in the application's logic.

To seal a method, use the sealed modifier:

public class Animal
{
    public string Species { get; set; }

    // A virtual method allows derived classes to override it.
    public virtual void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

public class Dog : Animal
{
    // The sealed override prevents further overriding of this method.
    public sealed override void MakeSound()
    {
        Console.WriteLine("Bark!");
    }
}

public class Animal
{
    public string Species { get; set; }

    // A virtual method allows derived classes to override it.
    public virtual void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

public class Dog : Animal
{
    // The sealed override prevents further overriding of this method.
    public sealed override void MakeSound()
    {
        Console.WriteLine("Bark!");
    }
}

The virtual keyword allows the method to be overridden in derived classes, while the sealed keyword prevents further overriding the base class virtual method in any subsequent subclasses.

Sealed Class and Class Members: Sealed classes can also include sealed members, such as properties, methods, and events. This combination of sealed class and sealed members ensures a high degree of control over the class's behavior and structure.

Consider the following example:

public sealed class ControlledClass
{
    // A sealed property that prevents overriding.
    public sealed string ControlledProperty { get; set; }

    // A method that cannot be redefined by derived classes.
    public virtual sealed void ControlledMethod()
    {
        // Method implementation
        Console.WriteLine("Executing controlled method.");
    }

    // A sealed event that cannot be subscribed to or raised by derived classes.
    public sealed event EventHandler ControlledEvent;

    // Sealed indexers, if applicable
    public sealed string this[int index]
    {
        get { return "Value"; }
        set 
        { 
            // Setter implementation 
        }
    }
}

public sealed class ControlledClass
{
    // A sealed property that prevents overriding.
    public sealed string ControlledProperty { get; set; }

    // A method that cannot be redefined by derived classes.
    public virtual sealed void ControlledMethod()
    {
        // Method implementation
        Console.WriteLine("Executing controlled method.");
    }

    // A sealed event that cannot be subscribed to or raised by derived classes.
    public sealed event EventHandler ControlledEvent;

    // Sealed indexers, if applicable
    public sealed string this[int index]
    {
        get { return "Value"; }
        set 
        { 
            // Setter implementation 
        }
    }
}

In this example, every aspect of the ControlledClass is sealed – the property, method, event, and even an indexer if applicable. This level of sealing provides a robust and unalterable structure, ideal for scenarios where the class's design should remain fixed.

The Rationale Behind Sealed Class

Code Security: Sealed classes contribute to code security by preventing unauthorized access and modification. When a class is sealed, it serves as a closed entity with a well-defined interface and behavior. This encapsulation minimizes the risk of unintended side effects or alterations that could potentially compromise the stability and security of the codebase.

Design Integrity: In larger codebases or frameworks, maintaining design integrity is paramount. A sealed class acts as a foundational building block with fixed structures, reducing the chances of unintended modifications. This is particularly beneficial in scenarios where a class serves as a core component of a system, and its behavior should remain consistent across different modules.

Best Practices for Using Sealed Class

1. Use the Sealed Class Sparingly: While the sealed class offers benefits, they should be employed judiciously. Overuse of sealed classes can lead to rigid and less maintainable code.
2. Document Intent: When sealing a class or method, it's crucial to document the intent behind this decision. Explain why a particular class is sealed and what design considerations led to that choice.
3. Consider Future Extensibility: Before sealing a class, consider whether future requirements might necessitate extensibility. If there's a likelihood that a class will need to be extended, sealing it may hinder future development.
4. Use Sealed Methods for Stability: Sealing methods can be beneficial when the core behavior of a method should remain stable across different subclasses. This can enhance the predictability of the code.
5. It Cannot Also be Abstract: A sealed class/sealed methods cannot also be an abstract class/abstract methods as abstract classes are designed to be inherited by other classes while sealed classes restrict inheritance.

Introducing IronPDF

IronPDF is a C# PDF library from Iron Software and is a modern PDF generator and reader.

Installation

IronPDF can be installed using the NuGet Package Manager console or using the Visual Studio package manager. Below is the command for the console:

Install-Package IronPdf

Or, to install IronPDF using NuGet Package Manager, search "ironpdf" in the search bar of NuGet Package Manager.

namespace OrderBy
{
    public class Program
    {
        static void Main()
        {
            Console.WriteLine("Demo Sealed Class and IronPdf");
            var dog = new Dog();
            dog.MakeSound();
            dog.Print();
        }
    }

    // Base class
    public class Animal
    {
        public string Species { get; set; }

        public virtual void MakeSound()
        {
            Console.WriteLine("Generic animal sound");
        }

        public virtual void Print()
        {
            Console.WriteLine("Generic animal Print");
        }
    }

    public class Dog : Animal
    {
        // Sealed override ensures method cannot be overridden in further derived classes.
        public sealed override void MakeSound()
        {
            Console.WriteLine("Bark!");
        }

        public sealed override void Print()
        {
            var pdfRenderer = new ChromePdfRenderer();
            string content = @"
            <!DOCTYPE html>
            <html>
            <body>
                <h1>Hello, Dog!</h1>
                <p>This is Print from Derived class.</p>
                <p>Print Animal Dog</p>
                <p>Print Animal Sound: Bark</p>
            </body>
            </html>";

            pdfRenderer.RenderHtmlAsPdf(content).SaveAs("dog.pdf");
        }
    }
}

namespace OrderBy
{
    public class Program
    {
        static void Main()
        {
            Console.WriteLine("Demo Sealed Class and IronPdf");
            var dog = new Dog();
            dog.MakeSound();
            dog.Print();
        }
    }

    // Base class
    public class Animal
    {
        public string Species { get; set; }

        public virtual void MakeSound()
        {
            Console.WriteLine("Generic animal sound");
        }

        public virtual void Print()
        {
            Console.WriteLine("Generic animal Print");
        }
    }

    public class Dog : Animal
    {
        // Sealed override ensures method cannot be overridden in further derived classes.
        public sealed override void MakeSound()
        {
            Console.WriteLine("Bark!");
        }

        public sealed override void Print()
        {
            var pdfRenderer = new ChromePdfRenderer();
            string content = @"
            <!DOCTYPE html>
            <html>
            <body>
                <h1>Hello, Dog!</h1>
                <p>This is Print from Derived class.</p>
                <p>Print Animal Dog</p>
                <p>Print Animal Sound: Bark</p>
            </body>
            </html>";

            pdfRenderer.RenderHtmlAsPdf(content).SaveAs("dog.pdf");
        }
    }
}

{
    "IronPdf.LicenseKey": "your license key"
}

Conclusion

C# sealed classes offer developers a powerful mechanism to control the inheritance hierarchy and ensure that certain classes and their members cannot be extended or overridden. While the use of sealed classes should be carefully considered, they provide an effective means of encapsulating functionality and preventing unintended modifications. By understanding the concept of sealed classes and methods, developers can make informed decisions about when and where to apply this restriction, contributing to creating maintainable, secure, and predictable software systems. Together with IronPDF, we can also print PDF documents.