Attribute Inheritance on Interfaces

[BN-KS]

Proposal: Attribute Inheritance on Interfaces with Fine-Grained Control

This proposal introduces a new language feature in C# allowing developers to specify how attributes defined on interfaces are inherited by implementing classes. The feature uses keywords such as :inherit, :virtual, :override, and :none to provide control over attribute propagation, making codebases more flexible, readable, and compatible with existing patterns.

Keywords
:inherit: Inherit this attribute unconditionally, regardless of whether the property is explicitly overridden in the implementing class.
:virtual: Inherit this attribute only if the property is not explicitly implemented or overridden in the class.
:override: Apply this attribute only if the class explicitly overrides the property.
:none: Prevent this attribute from being inherited, even if it's defined on the interface.

Syntax Proposal for Attribute Inheritance
Interface-Level Attribute Declaration
In this syntax, attributes are applied to properties in interfaces with specific inheritance rules using :inherit, :virtual, :override, and :none.

public interface IExample
{
    [SomeAttribute]:inherit    // Always inherited by the implementing class
    [AnotherAttribute]:virtual // Inherited only if the property isn't explicitly implemented
    [OverrideAttribute]:override // Only applied when the property is explicitly implemented
    [NoInheritAttribute]:none   // Never inherited, even if the property isn't explicitly implemented
    string Description { get; }

    [PropertyAttribute]:inherit // Inherited by implementing classes unconditionally
    int Id { get; }
}

Class-Level Attribute Inheritance Control
Classes implementing interfaces can declare their intent to inherit all attributes from interface properties or customize which interface attributes to inherit.

// Inherit all attributes from interface properties
public class ExampleImplementation : [inherit] IExample
{
    public string Description { get; set; } // Inherits all attributes from IExample properties
    public int Id { get; set; } // Inherits [PropertyAttribute]
}

// Inherit attributes only if not overridden
public class ExampleImplementation2 : [virtual] IExample
{
    public string Description { get; set; } // Inherits attributes from IExample if not explicitly overridden
}

// Fine-grained control to inherit attributes only from specific interfaces
public class AnotherImplementation : [inherit] ISomeOtherInterface, IExample
{
    public string Description { get; set; } // Inherits attributes only from ISomeOtherInterface, but not from IExample
}

Compact Syntax for Attribute Application
To maintain clarity and compactness, this syntax allows for marking class declarations or individual interface property overrides for inheritance. By default, inheritance is not assumed unless explicitly specified.

// Per-property control for inheritance in a class
public class ExampleImplementation : IExample
{
    [SomeAttribute]:inherit // Inherits attributes from the interface
    public string Description { get; set; }

    [inherit] // Sets default inheritance for attributes on this property
    [InheritedAttribute] // Inherits [InheritedAttribute]
    [OtherAttribute]:none // Doesn't inherit [OtherAttribute]
    public int Id { get; set; } // Doesn't inherit attributes from the interface
}

Summary of Syntax
Interface-Level: Mark attributes in interface properties with :inherit, :virtual, :override, or :none to control inheritance behavior.
Class-Level: Use [inherit] or [inheritAttributesFrom] to globally or selectively inherit attributes from interfaces in class implementations.
Compact Property Syntax: Attributes can be inherited on a per-property basis using :inherit, :virtual, :override, or :none keywords directly on class properties.

This approach introduces flexibility to define attribute inheritance, offering developers a powerful tool to streamline attribute handling in interface-based design patterns while keeping C# syntax compact and readable.

Looking for feedback or potentially alternatives to the proposed syntax.
For example we could do [.inherit] before a property to apply to all the properties

[HaloFour]

What are some use cases for wanting this kind of inheritance, and why would it need such fine-grained control?

The runtime already provides a facility for attributes to be inherited by derived types and overriding members through attribute inheritance, which is specified on the attribute by the AttributeUsage.Inherited flag.

[BN-KS]

Ooh nice find, I didn't know that! Does this work on interfaces though? Or maybe it can be augmented to support interfaces.
I was just frustrated today hooking up interfaces and having to do redundant attributes when implementing the interface