C# Sealed Tutorial - Easy Guide with Real-World Example

Introduction – What is Sealed in C#?

Imagine you just bought a brand-new mobile phone 📱. It works great, and you love it! But when you try to open it up and change the battery… guess what? It’s sealed! 🔒

Manufacturers don’t want you messing with the hardware, so they seal it.

In C#, we use the sealed keyword to do the same thing in code! When you seal a class, you prevent other classes from inheriting it. This ensures that no one can modify or extend its functionality, keeping it secure and stable.

What You Are Going to Learn in This Lesson

✔️ What is the sealed keyword in C#?
✔️ Why do we need it?
✔️ A real-world example to make it crystal clear.
✔️ A complete C# Sealed Example with code and output.
✔️ Fun explanations so you never forget it! 😃

What is a Sealed Class in C#?

A sealed class is a class that cannot be inherited. That’s it! If you try to inherit it, BOOM! C# throws an error.

Real-World Example – Bank Accounts! 🏦

Think of a bank account system. The bank has a special class BankAccount that holds critical financial data.

The bank doesn’t want anyone to extend or modify this class (for security reasons). So, they seal it! That way, no unauthorized changes can be made.

C# Sealed Example

				
					using System;

sealed class BankAccount  // Sealing the class
{
    public void ShowBalance()
    {
        Console.WriteLine("Your balance is $5000");
    }
}

// Trying to inherit from a sealed class (This will cause an error!)
// class SavingsAccount : BankAccount { } // ❌ ERROR

class Program
{
    static void Main()
    {
        BankAccount myAccount = new BankAccount();
        myAccount.ShowBalance();
    }
}

Output:

				
					Your balance is $5000

Code Explanation

sealed class BankAccount → We sealed the class, so no one can inherit from it.
ShowBalance() → A simple method to display balance.
BankAccount myAccount = new BankAccount(); → We created an object and called the method.
Trying to inherit from BankAccount → It throws an error! 🚫

Why Do We Need Sealed Classes?

Here’s why the sealed keyword is super useful:

🔒 Security: No one can inherit and create a fake account.
🚀 Performance: Sealed classes are optimized for performance.
⚡ Stability: Prevents unintended modifications in your system.

Example: Sealed Class Restricting Inheritance

				
					using System;

sealed class ParentClass
{
    public void Display()
    {
        Console.WriteLine("Hello from the sealed class!");
    }
}

// ❌ ERROR: Cannot inherit from a sealed class
class ChildClass : ParentClass  
{
    public void ShowMessage()
    {
        Console.WriteLine("Trying to inherit from a sealed class.");
    }
}

class Program
{
    static void Main()
    {
        ParentClass obj = new ParentClass();
        obj.Display();
    }
}

If you try to compile this, you’ll see an error like this:

				
					error CS0509: 'ChildClass': cannot derive from sealed type 'ParentClass'

🔍 Why This Happens?

ParentClass is marked as sealed, which means no other class can inherit from it.
When ChildClass tries to inherit ParentClass, C# immediately throws an error and stops compilation.
However, you can still create objects of a sealed class and use its methods, like we did in Main().

Conclusion – Why Sealed is Important?

The sealed keyword is like a lock on a bank vault. It prevents unauthorized modifications and inheritance, keeping your class safe and secure. It also improves performance because the compiler knows that the class won’t be extended.

Now you know why and when to use sealed classes in C#! 🚀

Next What?

In the next lesson, you’ll learn about the Dynamic Expression in C#! It’s going to be fun, so stay tuned! 🎉