.CS File Format – Interfaces and inheritance

Base classes

class_base:
    : class_type
    : interface_type_list
    : class_type , interface_type_list

public class Animal
{
    public virtual string Sound() => "...";
}

public class Dog : Animal, IComparable<Dog>
{
    public override string Sound() => "woof";
    public string Both() => base.Sound() + Sound();
    public int CompareTo(Dog? other) => 0;
}

• A class with no base class named derives from object. Every type ends at object, which gives it ToString, Equals, GetHashCode, GetType and MemberwiseClone.
• A class inherits every member of its base except constructors and finalizers. Private members are inherited but not accessible.
• base.Member reaches the inherited member, and base(…) calls a base constructor.
• A class may not derive from itself, or from System.Array, System.Delegate, System.Enum or System.ValueType.

Virtual dispatch

A virtual method can be overridden in a derived class (clause 15.6.4). A call is resolved in two steps: the compiler picks the overload using the variable’s compile-time type, and at run time the override is chosen from the object’s actual type. Calls to non-virtual members use the compile-time type only.

Animal a = new Dog();
a.Sound();              // "woof": virtual, the object's type decides

• An override has the same signature and return type as the member it overrides, and the same accessibility. It cannot change a member between static and instance.
• Since C# 9 an override may return a more derived type (covariant return).
• Methods, properties, indexers and events can be virtual. Fields cannot.
• A member that hides an inherited one should say new. Without it the code compiles with a warning. The two members coexist: which one is used depends on the variable’s type.

Abstract classes

An abstract class cannot be instantiated (clause 15.2.2). It may declare abstract members, and each must be overridden by a non-abstract derived class.

public abstract class Shape
{
    public abstract double Area { get; }
    public override string ToString() => $"area {Area}";
}

public class Circle(double r) : Shape
{
    public override double Area => Math.PI * r * r;
}

An abstract class may still have constructors, fields and normal members. abstract override forces a further-derived class to give a new implementation of a virtual member.

Sealed classes

A sealed class cannot be derived from (clause 15.2.2). It cannot be abstract. sealed override on a member stops further overriding of that member.

Closed classes

A closed class (C# 15) can have direct subclasses only in its own assembly and module. Because the direct subclasses are known at compile time, a switch expression that handles each of them needs no default arm (feature specification Closed hierarchies).

public closed record class GateState;
public record class Closed : GateState;
public record class Open(float Percent) : GateState;

string Describe(GateState state) => state switch
{
    Closed => "closed",
    Open(var percent) => $"{percent}% open",
    // no default arm: every direct subclass is handled
};

• A closed class is implicitly abstract. It cannot be combined with sealed, static or an explicit abstract.
• The restriction covers direct subclasses only. A subclass that is not itself closed or sealed can be derived from elsewhere.
• If a generic class derives directly from a closed class, every type parameter of the derived class must be used in its base class specification.
• closed applies to classes, including record classes.

Interfaces

An interface is a contract that classes and structs implement (clause 19). It may hold instance methods, properties, indexers and events, and, since C# 8, default implementations, static members and nested types. It has no instance fields.

public interface ILogger
{
    void Write(string message);                     // implementing types must define this
    void WriteLine(string message) => Write(message + "\n");   // default implementation, C# 8
    static ILogger Null { get; } = new NullLogger();           // static member
}

• Interface members are public by default. Since C# 8 they may also be private, protected, internal or protected internal.
• An interface can inherit from several interfaces: interface IB : IA, IDisposable.
• A class implements an interface member with a public instance member of the same signature, or with an explicit implementation.
• A struct converted to an interface is boxed.

public class Printer : IDocument, IPicture
{
    void IDocument.Print() { }
    void IPicture.Print() { }
}

((IDocument)printer).Print();

public interface IAddable<T> where T : IAddable<T>
{
    static abstract T Zero { get; }
    static abstract T operator +(T a, T b);
}

static T Sum<T>(IEnumerable<T> values) where T : IAddable<T>
{
    T total = T.Zero;
    foreach (var v in values) total += v;
    return total;
}