Sealed Property

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

​

Syntax and Declaration

public sealed override DataType PropertyName { get; set; }

sealed DataType PropertyName { get => defaultValue; }

​

Technical Constraints and Rules

1. Class Context (Requires Override): Within a class, a property can only be sealed if it is actively overriding a virtual, abstract, or previously overridden property from a base class. You cannot declare a new property as sealed in a class, nor can you seal a virtual property at the point of its initial declaration.
2. Interface Context (Default Implementations): Within an interface, a property can be declared as sealed at its initial declaration, provided it includes a default implementation (a body). This prevents implementing classes or structs from explicitly redefining the property for that interface.
3. Compile-Time Enforcement:
   • In classes, if a derived class attempts to use the override keyword on a sealed property, the compiler throws error CS0239.
   • In interfaces, if a type implementing the interface attempts to provide an explicit interface implementation for the sealed property, the compiler throws error CS8704. If the type defines a public property with the exact same signature, the compiler simply ignores it during interface mapping. Because Default Interface Members (DIMs) are never inherited into the implementing class’s public API, the class property is treated as a completely independent member. It does not hide or shadow the interface member, and the compiler does not emit a hiding warning (CS0108).
4. Property-Level Application: The sealed modifier applies to the property as a single unit. You cannot seal an individual get or set accessor independently; both accessors share the sealed state of the property.
5. Hiding via new: While a derived type cannot override a sealed class property, it can hide it using the new keyword (public new DataType PropertyName). This creates a completely separate property that does not participate in the original polymorphic chain.

​

Code Visualization

public class BaseEntity
{
    public virtual string Identifier { get; set; }
}

public class IntermediateEntity : BaseEntity
{
    // Overriding and sealing the property
    public sealed override string Identifier 
    { 
        get => base.Identifier; 
        set => base.Identifier = value; 
    }
}

public class LeafEntity : IntermediateEntity
{
    // COMPILE-TIME ERROR CS0239: 
    // 'LeafEntity.Identifier': cannot override inherited member 'IntermediateEntity.Identifier' because it is sealed.
    /*
    public override string Identifier 
    { 
        get => "New ID"; 
        set { }
    }
    */

    // Valid: Hiding the sealed property instead of overriding
    public new string Identifier { get; set; }
}

public interface IEntity
{
    // Sealing a default interface property implementation
    sealed string EntityType => "Standard";
}

public class ConcreteEntity : IEntity
{
    // COMPILE-TIME ERROR CS8704: 
    // 'ConcreteEntity' cannot implement interface member 'IEntity.EntityType' because it is sealed.
    /*
    string IEntity.EntityType => "Custom";
    */

    // Valid: This creates a completely independent property. 
    // Because default interface members are not inherited into the class's public API, 
    // this does not hide or shadow the interface member, and no CS0108 warning is emitted.
    public string EntityType => "Custom";
}