Write generic numeric code in C# using static abstract interface members and generic math (.NET 7+). Explain INumber<T> and the smaller interfaces, T.Zero and T.CreateChecked, IParsable<T>, how to make your own type participate (operators as static abstract members, the self-referencing constraint), checked operators, and the performance and design trade-offs.

1. Static abstract interface members

public interface IAdditiveIdentity<TSelf, TResult> where TSelf : IAdditiveIdentity<TSelf, TResult>
{
    static abstract TResult AdditiveIdentity { get; }
}

Implementations provide static members; generic code calls T.AdditiveIdentity. In IL, calls use constrained. !!T call ..., resolved per instantiation. They're not virtual dispatch at run time for value types.

2. Why the self-referencing constraint

Operators must be declared in terms of the implementing type (static TSelf operator +(TSelf l, TOther r)). Without TSelf, the interface couldn't express "the result is the same type as the implementer". The constraint where TSelf : IFoo<TSelf> ensures TSelf is the type implementing the interface (by convention; C# can't strictly enforce "self").

3. Conversion APIs

CreateChecked/Saturating/Truncating<TOther>(TOther value) are implemented via TryConvertFrom... and TryConvertTo... static abstract members, allowing conversions between arbitrary numeric types, including user-defined ones, in both directions.

4. Default interface methods in generic math

Some interfaces provide default implementations (e.g. INumber<T>.Clamp, Max, Min) built from other members, so custom types get them for free but can override for performance.

5. Interop with existing APIs

• LINQ's Sum/Average have generic-math-aware implementations in recent .NET versions.
• Vector<T>/Vector128<T> and TensorPrimitives work with numeric generic constraints for SIMD.
• Minimal API binding uses IParsable<T>/ISpanParsable<T> for custom route parameter types.

6. Pitfalls in numeric generic code

• Floating-point accumulation errors (use decimal where exactness matters, or compensated summation).
• Integer overflow in Sum for large inputs (use a wider accumulator type via CreateChecked into long/Int128).
• T.Zero vs default(T): for built-ins they're the same, but custom types may differ — always use T.Zero.

Try it yourself

1. Implement Sum<T> and benchmark with int, double, decimal vs hand-written loops.
2. Implement Money with addition interfaces and use it in Sum<T>.
3. Compare CreateChecked, CreateSaturating, CreateTruncating converting 300 to byte.
4. Add a checked operator and call it inside checked { }.

using System.Globalization;
using System.Numerics;

public readonly record struct Money(decimal Amount)
    : IAdditionOperators<Money, Money, Money>,
      IAdditiveIdentity<Money, Money>,
      IComparisonOperators<Money, Money, bool>
{
    public static Money AdditiveIdentity => new(0m);
    public static Money operator +(Money left, Money right) => new(left.Amount + right.Amount);
    public static bool operator <(Money left, Money right) => left.Amount < right.Amount;
    public static bool operator >(Money left, Money right) => left.Amount > right.Amount;
    public static bool operator <=(Money left, Money right) => left.Amount <= right.Amount;
    public static bool operator >=(Money left, Money right) => left.Amount >= right.Amount;
    public override string ToString() => Amount.ToString("C", CultureInfo.GetCultureInfo("en-AU"));
}

public static class Stats
{
    // Smallest constraint that expresses the algorithm
    public static T Sum<T>(ReadOnlySpan<T> values)
        where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
    {
        T total = T.AdditiveIdentity;
        foreach (T value in values) total += value;
        return total;
    }

    public static T Average<T>(ReadOnlySpan<T> values) where T : INumber<T>
    {
        if (values.IsEmpty) throw new ArgumentException("No values", nameof(values));
        T total = T.Zero;
        foreach (T value in values) total += value;
        return total / T.CreateChecked(values.Length);   // throws if Length does not fit in T
    }

    public static T Max<T>(ReadOnlySpan<T> values) where T : IComparisonOperators<T, T, bool>
    {
        T max = values[0];
        foreach (T value in values[1..]) if (value > max) max = value;
        return max;
    }

    public static T Setting<T>(IReadOnlyDictionary<string, string> settings, string key) where T : IParsable<T>
        => T.Parse(settings[key], CultureInfo.InvariantCulture);
}

public static class Program
{
    public static void Main()
    {
        Console.WriteLine(Stats.Sum<int>([1, 2, 3]));                     // 6
        Console.WriteLine(Stats.Average<double>([1.5, 2.5, 3.5]));        // 2.5
        Console.WriteLine(Stats.Average<decimal>([10m, 20m, 25m]));       // 18.333...
        Console.WriteLine(Stats.Sum<Money>([new(10m), new(5.5m)]));       // $15.50
        Console.WriteLine(Stats.Max<Money>([new(10m), new(25m), new(5m)])); // $25.00

        var settings = new Dictionary<string, string> { ["Retries"] = "3", ["Timeout"] = "00:00:30", ["Launch"] = "2026-11-01" };
        Console.WriteLine(Stats.Setting<int>(settings, "Retries"));
        Console.WriteLine(Stats.Setting<TimeSpan>(settings, "Timeout"));
        Console.WriteLine(Stats.Setting<DateOnly>(settings, "Launch"));

        try { Console.WriteLine(Stats.Average<byte>(new byte[300])); }
        catch (OverflowException) { Console.WriteLine("300 does not fit in a byte"); }
    }
}