C# generic math lets one algorithm work across numeric types without a separate overload for each type. In C# 11 and later, static abstract interface members make operators available through generic constraints; .NET 7 introduced the numeric interfaces in System.Numerics. For a method that needs ordinary arithmetic and comparison, INumber<T> is often a practical starting point—but the right constraint depends on the operations and numeric domain the algorithm actually needs.
How to add numbers in a generic C# method
Constrain the type parameter to a numeric interface that exposes addition, then use the operator directly:
As an Amazon Associate I earn from qualifying purchases.
using System.Numerics;
static T Add<T>(T left, T right)
where T : INumber<T>
=> left + right;The constraint tells the compiler that T supports the required operation. INumber<TSelf> inherits operator interfaces, including IAdditionOperators<TSelf, TOther, TResult>, so generic code can use + without knowing the concrete type. The built-in numeric types were updated to implement the generic interfaces in .NET 7. See Microsoft’s generic math overview and the INumber<TSelf> API reference.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →This works for types that satisfy the constraint, including suitable custom numeric types. It does not mean every type supports every numeric operation: the interface constraint defines what the method is allowed to assume.
#1 Best Overall
Why generic math works
Before static interface members, generic code could not use an operator just because its type parameter was generic. C# 11 and later supports static abstract and static virtual interface members, including operators. A type can implement those members, and code constrained to the interface can invoke them through its type parameter. The numeric interfaces in System.Numerics provide a standard set of such capabilities.
The interfaces arrived with .NET 7, while the language feature used to declare static interface members is available in C# 11 and later. Check both the target framework and language version when adopting generic math; the language feature alone does not guarantee that a target framework supplies the numeric interfaces. Microsoft’s static virtual interface members tutorial walks through the generic constraint model.
Choose the narrowest useful numeric constraint
INumber<T> is a broad choice for algorithms that need common comparable-number behavior, arithmetic, and comparison. It is not the only option. Microsoft documents a family of interfaces for distinct numeric domains and individual capabilities.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errors| Constraint or family | Use it when |
|---|---|
INumber<T> |
The algorithm needs common real-like numeric behavior, such as arithmetic and comparison. |
INumberBase<T> |
The algorithm needs broader number concepts, including concepts relevant to complex and imaginary numbers. |
IBinaryInteger<T> |
The algorithm specifically requires binary-integer behavior. |
Floating-point interfaces, including IFloatingPointIeee754<T> |
The algorithm requires floating-point-specific behavior or operations. For example, floor is a floating-point operation; Int32 does not implement IFloatingPointIeee754<T>. |
| Fine-grained operator, identity, parsing, or formatting interfaces | The algorithm needs only a specific capability, such as addition, comparison, identities, parsing, or formatting. |
The interface family also includes signed and unsigned integer interfaces and other specialized capabilities. A narrower constraint states the method’s actual requirements more precisely and can admit appropriate custom numeric types that do not implement a broader interface. Consult the official interface taxonomy and INumber<TSelf> inheritance details when selecting a constraint.
Use checked conversions carefully in generic formulas
Generic math provides conversion helpers as well as operators. For example, Microsoft’s midpoint illustration creates the divisor in the target type with T.CreateChecked(2). A checked conversion throws OverflowException if the source value cannot be represented by the target type.
static T Midpoint<T>(T left, T right)
where T : INumber<T>
=> (left + right) / T.CreateChecked(2);This formula is illustrative, not universally safe: left + right can overflow before division occurs. If inputs may approach the type’s limits, choose an alternative midpoint algorithm appropriate to the numeric domain and desired rounding behavior rather than assuming that dividing afterward prevents overflow. Microsoft’s tutorial on static virtual members calls out this caveat.
Rank #4
Implementing a custom numeric type
A custom type can implement the numeric interfaces it supports, allowing generic algorithms to operate on it. These interfaces use a self-referential type parameter, often called the CRTP pattern: an implementation supplies its own type as the interface’s self type. For example, a type named Measurement implementing an interface shaped as INumber<TSelf> uses Measurement for TSelf.
For projects using the .NET 10 analyzer configuration, CA2260 warns when generic math interfaces are implemented with an incorrect self type argument. The rule is documented for .NET 10; check the analyzer configuration and target version before assuming the same diagnostic applies elsewhere. See Microsoft’s CA2260 guidance.
When generic math is worth using
Generic math is especially useful when building reusable library algorithms that would otherwise need repeated overloads for each numeric type. Microsoft notes that library authors can simplify code by removing redundant overloads, while library consumers can benefit indirectly when APIs support more types. For a small one-off method with only one intended numeric type, a type-specific method may be clearer; use a generic constraint when reuse across supported numeric types is a real requirement.
Microsoft’s .NET base class library documentation says that 20 numeric types implement the generic interfaces; that count appears on its page last updated August 3, 2022, and should be read in that dated documentation context. See Generic interfaces in .NET.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Recommended Free Tools
