How to have a generic variable to INumber in .NET 7?

Question

We can use the new INumber<TSelf> interface in .NET 7 to reference any numeric type, like the following:

using System.Numerics;

INumber<int> myNumber = 72;
INumber<float> mySecondNumber = 93.63f;

However, because of the type constraint in INumber, we can't have a generic reference that can hold any numeric type. This following code is invalid:

using System.Numerics;

INumber myNumber = 72;
myNumber = 93.63f;

How can I have an array of any numeric objects and call a method that is expecting a INumber<TSelf> object.

using System.Numerics;

object[] numbers = new object[] { 1, 2.5, 5, 0x1001, 72 };

for (int i = 0; i < numbers.Length - 1; i++)
{
    Console.WriteLine("{0} plus {1} equals {2}", numbers[i], numbers[i + 1], AddNumbers(numbers[i], numbers[i + 1]));
}

static T AddNumbers<T>(T left, T right) where T : INumber<T> => left + right;

Answer 1

How can I have an array of any numeric objects and call a method that is expecting a INumber object.

The thing is that array must have all elements of the same type. Simply because array is just a memory block and i-th element is a place in memory located at address arrayStart + i*(elementSize). It just won’t work if sizes are different.

Therefore for value types it is not possible(they might have different sizes), but it is possible to have array of objects, then every element can have any type(will be boxed in case of value type).

So, you would need to create array of objects, where you can put float, int, whatever.

Also I don’t think it makes much sense to have common interface for all numbers, because if you you want to add float to long, how should you do that - cast to float or long? It is just much clearer to convert numbers to the most convenient type for the task.

Answer 2

It's not possible. The INumber<TSelf> type is declared like that:

public interface INumber<TSelf> : 
    IComparable, 
    IComparable<TSelf>, 
    IEquatable<TSelf>, 
    IParsable<TSelf>, 
    ISpanParsable<TSelf>,
    System.Numerics.IAdditionOperators<TSelf,TSelf,TSelf>,
    System.Numerics.IAdditiveIdentity<TSelf,TSelf>,
    System.Numerics.IComparisonOperators<TSelf,TSelf,bool>,
    System.Numerics.IDecrementOperators<TSelf>,
    System.Numerics.IDivisionOperators<TSelf,TSelf,TSelf>,
    System.Numerics.IEqualityOperators<TSelf,TSelf,bool>,
    System.Numerics.IIncrementOperators<TSelf>,
    System.Numerics.IModulusOperators<TSelf,TSelf,TSelf>, 
    System.Numerics.IMultiplicativeIdentity<TSelf,TSelf>, 
    System.Numerics.IMultiplyOperators<TSelf,TSelf,TSelf>, 
    System.Numerics.INumberBase<TSelf>,        
    System.Numerics.ISubtractionOperators<TSelf,TSelf,TSelf>, 
    System.Numerics.IUnaryNegationOperators<TSelf,TSelf>, 
    System.Numerics.IUnaryPlusOperators<TSelf,TSelf> 
    where TSelf : INumber<TSelf>

As you can see, all the interfaces use the TSelf type. So the INumber interface does not have a contract that supports operations between different types but only operations within the same type.

Since you have a list of mixed types, the compiler has no chance to check whether the actual types of operands at runtime are a supported combination.

Answer 3

tl;dr: you can't.

---

You noticed that there's no non-generic type INumber which INumber<TSelf> implements, because this would cause havoc.

You know something bad is happening in your code when you have to declare

var numbers = new object[] { 1, 2.5, 5, 0x1001, 72 };

to hold your INumber<T> values.

You also couldn't declare, e.g. something like

var numbers = new INumber<>[] { 1, 2.5, 5, 0x1001, 72 };

because you'd encounter CS7003: "Unexpected use of an unbound generic name"

---

Suppose that there exists a non-generic interface type INumber which is a base type of INumber<TSelf> (in the same way that IEnumerable is a base type of IEnumerable<T>).

For INumber to be useful it'd have to have things like operators - but these would also have to be non-generic - so, for instance, a non-generic version of the IAdditionOperators<TSelf,TOther,TResult> interface (which defines the + operator) would have to exist - it'd have to take INumber, INumber as its arguments.

Now, suppose you have a type, UserDefinedNumber : INumber<UserDefinedNumber> and you had

INumber a = 1d;
INumber b = new UserDefinedNumber(...);
var c = a + b;

Now - what would you expect a + b to do?

Since the left- and right-hand side of the operator are both typed as INumber, the compiler would use the implementation of the + operator on a (which is a double) but since that's a built-in type there's no way that it'd have any logic to handle adding a double to a UserDefinedNumber.

Answer 4

You can have a generic method which will work on any two arbitrary number types using Convert.ChangeType, provided Convert knows how to deal with both:

public static class AnyNumberAdder
{
    public static T1 AddNumbers<T1, T2>(T1 left, T2 right)
        where T1 : INumberBase<T1> where T2:INumberBase<T2> =>
        left + (T1)Convert.ChangeType(right, typeof(T1));
}

With some modifications this can be made to work on enumerables as well.