What is the final keyword in C#?

While there is no keyword named "final" in C#, the same functionality, particularly in preventing inheritance, is achieved using the sealed keyword. In C#, sealed is a crucial keyword for controlling extensibility and ensuring type immutability.

Understanding the sealed Keyword in C

The sealed keyword in C# is used to prevent inheritance for classes or to prevent further overriding of methods and properties. It plays a role similar to the final keyword found in languages like Java.

Sealed Classes

When a class is declared as sealed, it means that no other class can inherit from it. This provides a way to restrict the extensibility of a class hierarchy.

Syntax:

public sealed class MySealedClass
{
    // Class members
}

// Attempting to inherit from a sealed class will result in a compile-time error:
// public class AnotherClass : MySealedClass // Error: Cannot inherit from sealed type 'MySealedClass'

Practical Use Cases for Sealed Classes:

• Security: Prevents malicious subclasses from altering the behavior of a base class.
• Performance: The Just-In-Time (JIT) compiler can optimize calls to methods of sealed classes more effectively because it knows there won't be any further overrides. This can lead to minor performance improvements.
• Design Control: Ensures that the class's design and implementation remain consistent and are not altered by subclasses, which is particularly useful for framework classes or foundational components.
• Immutable Types: Classes designed to be immutable (e.g., string) are often sealed to prevent modifications through inheritance.

Sealed Methods and Properties

The sealed keyword can also be applied to an override method or property. When a method or property in a derived class is declared as sealed override, it prevents any further derived classes from overriding that specific method or property.

Syntax:

public class BaseClass
{
    public virtual void MyMethod()
    {
        // Base implementation
    }
}

public class DerivedClass : BaseClass
{
    public sealed override void MyMethod()
    {
        // Sealed override implementation
    }
}

public class FurtherDerivedClass : DerivedClass
{
    // Attempting to override MyMethod here will result in a compile-time error:
    // public override void MyMethod() // Error: Cannot override sealed member 'DerivedClass.MyMethod()'
    // {
    //     // Further implementation
    // }
}

This is useful when you want to provide a specific implementation in a derived class that cannot be changed by subsequent derivations.

sealed and Structs

It's important to note that all struct types in C# are implicitly sealed. This means you cannot inherit from a struct, nor can a struct inherit from a class or another struct. This behavior aligns with the value type nature of structs, which are designed to be lightweight and typically immutable.

Comparison: C# sealed vs. Java final

While C# uses sealed and Java uses final, their purposes in restricting inheritance are similar. Here's a brief comparison:

Feature	C# (sealed)	Java (final)
Class	Prevents inheritance of the class.	Prevents inheritance of the class.
Method	Prevents further overriding of a virtual or override method.	Prevents overriding of a method.
Variable	Not applicable directly (use const for compile-time constants, readonly for runtime constants).	Makes a variable a constant (cannot be reassigned after initialization).
Parameter	Not applicable.	Not applicable (effectively final for lambdas in Java 8+).
Implicit Behavior	Structs are implicitly sealed.	N/A

Key Takeaways

• C# does not have a final keyword.
• The sealed keyword serves a similar purpose, primarily for preventing inheritance.
• sealed can be applied to classes and override methods/properties.
• All struct types in C# are inherently sealed, preventing inheritance from them.