Sealed classes and methods in C Sharp (C#) - Deep Dive

Overview - Sealed classes and methods

What is it?

Sealed classes and methods in C# are special features that prevent other classes from inheriting or overriding them. A sealed class cannot be used as a base class, and a sealed method cannot be overridden by subclasses. This helps control how your code can be extended or changed by others.

Why it matters

Without sealed classes and methods, any part of your program could be changed or extended in unexpected ways, which can cause bugs or security issues. Sealing helps keep your code safe and predictable, especially in large projects or shared libraries. It also can improve performance by allowing the compiler to optimize calls.

Where it fits

Before learning sealed classes and methods, you should understand basic class inheritance and method overriding in C#. After this, you can explore advanced topics like abstract classes, interfaces, and design patterns that use sealing for better control.

Mental Model

Core Idea

Sealed classes and methods act like locked doors that stop others from changing or extending your code beyond what you allow.

Think of it like...

Imagine you build a toy model with parts that can be swapped or changed. A sealed class or method is like gluing some parts permanently so no one can replace or modify them later.

BaseClass
  │
  ├─ DerivedClass (can inherit)
  │    └─ sealed method (cannot override)
  └─ SealedClass (cannot inherit)

Legend:
- SealedClass: no inheritance allowed
- sealed method: no overriding allowed

Build-Up - 6 Steps

1

Foundation

Understanding class inheritance basics

Concept: Learn how classes can inherit from other classes and how methods can be overridden.

In C#, a class can inherit from another class to reuse code. For example: class Animal { public virtual void Speak() { Console.WriteLine("Animal sound"); } } class Dog : Animal { public override void Speak() { Console.WriteLine("Bark"); } } Dog inherits from Animal and changes the Speak method.

Result

Dog objects say "Bark" instead of "Animal sound" when Speak is called.

Understanding inheritance and overriding is essential because sealing controls how this behavior can be limited.

2

Foundation

What sealed means for classes

Concept: A sealed class cannot be inherited by any other class.

You can mark a class as sealed like this: sealed class Robot { public void Move() { Console.WriteLine("Moving"); } } Trying to inherit from Robot will cause a compile error: class Android : Robot {} // Error: cannot inherit sealed class

Result

The compiler prevents any class from extending Robot.

Sealing a class locks its design so no one can change or extend it, which helps keep your code safe.

3

Intermediate

Sealed methods prevent overriding

🤔Before reading on: do you think sealing a method stops inheritance or just overriding? Commit to your answer.

Concept: A sealed method can be overridden only up to a point, then sealed to stop further changes.

When a method is marked sealed, it means subclasses cannot override it further. This only works on methods that already override a base method. Example: class Base { public virtual void Show() { Console.WriteLine("Base"); } } class Mid : Base { public sealed override void Show() { Console.WriteLine("Mid"); } } class Leaf : Mid { public override void Show() { Console.WriteLine("Leaf"); } // Error: cannot override sealed method } Sealed stops Leaf from changing Show.

Result

The compiler forbids overriding sealed methods in further subclasses.

Sealing methods lets you allow some overriding but then lock the method to prevent unexpected changes deeper in the hierarchy.

4

Intermediate

Combining sealed with inheritance rules

Concept: Sealed classes stop inheritance entirely; sealed methods stop overriding but allow inheritance.

You can have a sealed class with no subclasses, or a class with sealed methods that subclasses can inherit but not override. Example: sealed class FinalClass { public void DoWork() { } } class Parent { public virtual void Work() { } } class Child : Parent { public sealed override void Work() { } } Child can be inherited, but Work cannot be changed further.

Result

Sealed classes and methods give you fine control over how your code can be extended.

Knowing the difference helps you design classes that are flexible where needed and locked down where safety matters.

5

Advanced

Performance benefits of sealing

🤔Before reading on: do you think sealing affects program speed or only code safety? Commit to your answer.

Concept: Sealing can help the compiler optimize calls because it knows no overrides exist beyond sealed points.

When a class or method is sealed, the compiler can call methods directly without checking for overrides at runtime. This reduces overhead. For example, calling a sealed method can be faster than a virtual method call because it avoids the virtual method table lookup.

Result

Programs using sealed classes or methods can run slightly faster and use less memory.

Understanding this shows sealing is not just about safety but also about making your code more efficient.

6

Expert

Sealed methods in complex inheritance chains

🤔Before reading on: can a sealed method be unsealed or overridden using tricks like new keyword? Commit to your answer.

Concept: Sealed methods cannot be overridden, but hiding them with new keyword creates a different method, not an override.

In C#, you can hide a sealed method by declaring a new method with the same name: class Base { public virtual void Run() { Console.WriteLine("Base"); } } class Mid : Base { public sealed override void Run() { Console.WriteLine("Mid"); } } class Leaf : Mid { public new void Run() { Console.WriteLine("Leaf"); } } Here, Leaf.Run hides Mid.Run but does not override it. Calls through Base or Mid references use Mid.Run, calls through Leaf use Leaf.Run.

Result

Sealed stops overriding but not method hiding, which can cause subtle bugs.

Knowing the difference between overriding and hiding prevents bugs and confusion in deep inheritance hierarchies.

Under the Hood

At runtime, C# uses a virtual method table (vtable) to decide which method to call for virtual methods. When a class or method is sealed, the compiler knows no further overrides exist, so it can call methods directly without vtable lookup. This reduces runtime overhead and improves performance. The sealed keyword modifies the metadata so the runtime enforces these restrictions.

Why designed this way?

Sealing was introduced to give developers control over inheritance and overriding, preventing unintended changes that could break code. It also allows the compiler to optimize calls. Alternatives like making classes or methods private or internal limit accessibility but do not control inheritance. Sealing balances flexibility and safety.

┌─────────────┐
│ Base Class  │
│ (virtual)   │
└─────┬───────┘
      │
┌─────▼───────┐
│ Derived     │
│ (sealed     │
│ override)   │
└─────┬───────┘
      │
┌─────▼───────┐
│ Further     │
│ subclass    │
│ (cannot     │
│ override)   │
└─────────────┘

Legend:
- Arrows show inheritance
- Sealed override stops further overrides

Myth Busters - 4 Common Misconceptions

Quick: Does sealing a class also seal its methods automatically? Commit to yes or no.

Common Belief: Sealing a class means all its methods are sealed and cannot be overridden.

Reality: Sealing a class prevents inheritance entirely, so no subclass can override methods, but the methods themselves are not individually sealed.

Why it matters: Confusing this can lead to misunderstanding how sealing controls behavior and when to seal methods versus classes.

Quick: Can you override a sealed method by using the new keyword? Commit to yes or no.

Common Belief: You can override a sealed method by declaring a new method with the same name in a subclass.

Reality: The new keyword hides the method but does not override it; calls through base references still use the sealed method.

Why it matters: This can cause bugs where the expected overridden method is not called, leading to unexpected behavior.

Quick: Does sealing a method improve performance? Commit to yes or no.

Common Belief: Sealing methods only affects code safety, not performance.

Reality: Sealing methods allows the compiler to optimize calls by avoiding virtual dispatch, improving performance.

Why it matters: Ignoring this misses an important benefit of sealing in performance-critical applications.

Quick: Can you inherit from a sealed class if you use interfaces? Commit to yes or no.

Common Belief: You can inherit from a sealed class by implementing its interfaces.

Reality: Sealed classes cannot be inherited at all, regardless of interfaces; interfaces are separate and do not affect sealing.

Why it matters: Misunderstanding this can cause design errors and compilation failures.

Expert Zone

1

Sealing a method only applies if it overrides a virtual method; sealing a non-virtual method is invalid.

2

Using sealed methods in combination with abstract classes allows partial locking of behavior while keeping some methods flexible.

3

Method hiding with new keyword can bypass sealing but breaks polymorphism, which can confuse maintenance and debugging.

When NOT to use

Avoid sealing classes or methods when you expect future extensions or plugin architectures. Instead, use interfaces or abstract classes to allow flexible extension. Sealing is not suitable for libraries meant to be widely extended by users.

Production Patterns

In production, sealed classes are common in utility or helper classes that should not change. Sealed methods are used in frameworks to lock down critical behavior after some customization. Sealing also helps in security-sensitive code to prevent tampering.

Connections

Final keyword in Java

Equivalent concept in another language

Understanding sealed in C# helps grasp final in Java, as both prevent inheritance or overriding, showing a common design pattern across languages.

Immutable objects in software design

Both enforce unchangeability but at different levels

Sealing locks class structure, while immutability locks object state; both improve reliability by preventing unwanted changes.

Legal contracts in law

Sealing is like a contract clause that forbids changes or extensions

Just as contracts can forbid modifications to agreements, sealed classes and methods forbid changes to code behavior, ensuring trust and predictability.

Common Pitfalls

#1 Trying to inherit from a sealed class

Wrong approach:

sealed class A {}
class B : A {}

Correct approach:

sealed class A {}
// No class inherits from A

Root cause:

Misunderstanding that sealed classes cannot be base classes for inheritance.

#2 Overriding a sealed method

Wrong approach:

class Base {
public virtual void M() {}
}
class Mid : Base {
public sealed override void M() {}
}
class Leaf : Mid {
public override void M() {} // Error
}

Correct approach:

class Leaf : Mid {
public new void M() {} // Hides method, does not override
}

Root cause:

Confusing method overriding with method hiding and ignoring sealing restrictions.

#3 Assuming sealing improves security by itself

Wrong approach:

sealed class SecureClass {
public void Sensitive() {}
}
// No other security measures

Correct approach:

// Use sealing with other security practices like access modifiers and validation

Root cause:

Believing sealing alone protects code from all misuse without other security controls.

Key Takeaways

Sealed classes prevent any inheritance, locking the class design completely.

Sealed methods stop further overriding but allow inheritance, giving fine control.

Sealing helps improve code safety, predictability, and can boost performance.

Misusing sealing or confusing it with method hiding can cause subtle bugs.

Sealing is a powerful tool but should be used thoughtfully considering future extension needs.