Interfaces

public interface IShape
{
    double Area { get; }                     // property
    double Perimeter { get; }
    string Describe();                       // method
    event EventHandler? Changed;             // event
}

public sealed class Rectangle : IShape
{
    public Rectangle(double width, double height) => (Width, Height) = (width, height);

    public double Width { get; }
    public double Height { get; }

    public double Area => Width * Height;
    public double Perimeter => 2 * (Width + Height);

    public string Describe() => $"{Width} x {Height}";

    public event EventHandler? Changed;

    private void Raise() => Changed?.Invoke(this, EventArgs.Empty);
}

public interface IJsonSerializable
{
    string Serialize();
}

public interface IXmlSerializable2
{
    string Serialize();          // same signature, different contract
}

public sealed class Document : IJsonSerializable, IXmlSerializable2
{
    // Explicit implementation disambiguates two identically-named members.
    string IJsonSerializable.Serialize() => """{"kind":"document"}""";

    string IXmlSerializable2.Serialize() => "<document/>";

    // A public method of your own choosing can still exist alongside them.
    public string ToText() => "document";
}

public static class ExplicitDemo
{
    public static void Run()
    {
        var doc = new Document();

        // doc.Serialize();                       // error: no such public member
        Console.WriteLine(((IJsonSerializable)doc).Serialize());
        Console.WriteLine(((IXmlSerializable2)doc).Serialize());
        Console.WriteLine(doc.ToText());
    }
}

public interface IReadable
{
    string Read();
}

public interface IWritable
{
    void Write(string value);
}

// An interface may extend any number of others.
public interface IReadWrite : IReadable, IWritable
{
    void Clear();
}

public sealed class MemoryStore : IReadWrite
{
    private string _value = "";

    public string Read() => _value;
    public void Write(string value) => _value = value;
    public void Clear() => _value = "";
}

public interface ILogger2
{
    void Log(string level, string message);

    // Default implementations -- added later without breaking implementers.
    void Info(string message) => Log("INFO", message);
    void Warn(string message) => Log("WARN", message);

    void Error(string message, Exception? exception = null)
        => Log("ERROR", exception is null ? message : $"{message}: {exception.Message}");

    // A static member on an interface, also legal since C# 8.
    static ILogger2 Null { get; } = new NullLogger2();

    private sealed class NullLogger2 : ILogger2
    {
        public void Log(string level, string message) { }
    }
}

public sealed class ConsoleLogger : ILogger2
{
    // Only the one abstract member needs implementing.
    public void Log(string level, string message) => Console.WriteLine($"[{level}] {message}");
}

public static class DefaultMemberDemo
{
    public static void Run()
    {
        ILogger2 logger = new ConsoleLogger();
        logger.Info("hello");                 // uses the default implementation
        logger.Log("DEBUG", "explicit");

        // A default member is callable only through the interface, never through the class.
        // new ConsoleLogger().Info("no");    // error CS1061
    }
}

public interface IIdentity<TSelf> where TSelf : IIdentity<TSelf>
{
    static abstract TSelf Zero { get; }
    static abstract TSelf Combine(TSelf left, TSelf right);

    // static virtual: a default the implementer may replace.
    static virtual string Describe() => typeof(TSelf).Name;
}

public readonly record struct Meters(double Value) : IIdentity<Meters>
{
    public static Meters Zero => new(0);
    public static Meters Combine(Meters left, Meters right) => new(left.Value + right.Value);
}

public static class Folding
{
    // The constraint gives the algorithm access to the static members.
    public static T Sum<T>(IEnumerable<T> values) where T : IIdentity<T>
    {
        T total = T.Zero;                    // calling a static abstract member!
        foreach (T value in values)
        {
            total = T.Combine(total, value);
        }
        return total;
    }
}

public sealed class Version3 : IEquatable<Version3>, IComparable<Version3>, IFormattable
{
    public Version3(int major, int minor) => (Major, Minor) = (major, minor);

    public int Major { get; }
    public int Minor { get; }

    public bool Equals(Version3? other)
        => other is not null && other.Major == Major && other.Minor == Minor;

    public override bool Equals(object? obj) => Equals(obj as Version3);
    public override int GetHashCode() => HashCode.Combine(Major, Minor);

    public int CompareTo(Version3? other)
    {
        if (other is null)
        {
            return 1;
        }

        int byMajor = Major.CompareTo(other.Major);
        return byMajor != 0 ? byMajor : Minor.CompareTo(other.Minor);
    }

    public override string ToString() => ToString(null, CultureInfo.CurrentCulture);

    public string ToString(string? format, IFormatProvider? provider) => format switch
    {
        null or "G" => $"{Major}.{Minor}",
        "M" => Major.ToString(provider),
        _ => throw new FormatException($"Unknown format '{format}'."),
    };
}