Downcast of generic types

[TobiasKnauss]

Generic math has given us a ton of functionality to write clean and elegant code that required a bunch of ugly workarounds before.

However, it's difficult (or impossible?) to write a generic method that takes an INumber<T> and casts it to a derived interface like IBinaryInteger<T> or IFloatingPoint<T> and continue on different paths based on the actual type.

This works, but is useless, because the generic types must be specified in the call:

public static void Test<TNum, TInt, TFloat> (TNum i_Number)
  where TNum : INumber<TNum>
  where TInt : IBinaryInteger<TInt>
  where TFloat : IFloatingPoint<TFloat>
{
  if (i_Number is IBinaryInteger<TInt> binaryInteger)
  {
    Console.WriteLine (binaryInteger.GetByteCount ());
  }
  else if (i_Number is IFloatingPoint<TFloat> floatingPoint)
  {
    Console.WriteLine (floatingPoint.GetSignificandByteCount ());
  }
}

This would be useful, but does not compile, because INumber<T> cannot be casted to IBinaryInteger<T> because the T of INumber<T> does not implement IBinaryInteger<T>:

public static void Test<TNum> (TNum i_Number)
  where TNum : INumber<TNum>
{
  if (i_Number is IBinaryInteger<TNum> binaryInteger)
  {
    Console.WriteLine (binaryInteger.GetByteCount ());
  }
  else if (i_Number is IFloatingPoint<TNum> floatingPoint)
  {
    Console.WriteLine (floatingPoint.GetSignificandByteCount ());
  }
}

It isn't possible either to write 2 methods that only differ in the used generic type constraint (this seems to be #129350):

  public static void Test<TNum> (TNum i_Number)
    where TNum : IBinaryInteger<TNum>
  {
    Console.WriteLine (i_Number.GetByteCount ());
  }

  public static void Test<TNum> (TNum i_Number)
    where TNum : IFloatingPoint<TNum>
  {
    Console.WriteLine (i_Number.GetSignificandByteCount ());
  }

So, what workarounds exist to solve this problem?
Could a new functionality or enhancement in the runtime solve it?

My usage scenario actually is a little different, it would require even more enhancements or further workarounds, because I don't have a function with generic typed arguments, but with generic return values only:

class Data<T>
where T : INumber<T>
{
    void Work ()
    {
        T x;
        var type = typeof (T);
        if (type.IsAssignableTo (typeof (IBinaryInteger<>)))  // this would actually be more complex, but could work
            x = Assistant.Parse_Int<IBinaryInteger<T>> ();  // <-- this cast is not possible
        if (type.IsAssignableTo (typeof (IFloatingPoint<>)))
            x = Assistant.Parse_Float<IFloatingPoint<T>> ();  // <-- this cast is not possible
        throw new InvalidOperationException ();
    }
}

static class Assistant   // pseudo-code
{
    public static T Parse_Int<T> ()
    where T : IBinaryInteger<T>
    {
        ... read text
        ... check for "0x"
        return T.Parse (...);
    }

    public static T Parse_Float<T> ()
    where T : IFloatingPoint<T>
    {
        ... read text
        x = T.Parse (...)
        ... check for NaN and Inf.
        return x;
    }    
}

[Muguett-DBY]

The pattern fails at compile time: C# has to be able to construct IBinaryInteger<T> before it can evaluate is. A runtime test does not strengthen where T : INumber<T>.

For your return-only parser, a JIT workaround is to keep Parse_Int<T>() and Parse_Float<T>() with their existing constraints and bodies, then cache a closed delegate for each T.

Add this inside Assistant (using System, System.Linq, System.Numerics and System.Reflection):

public static T Parse<T>() where T : INumber<T> => Parser<T>.Run();

private static class Parser<T> where T : INumber<T>
{
    internal static readonly Func<T> Run = Create();

    private static Func<T> Create()
    {
        Type t = typeof(T);
        bool Has(Type definition) => t.GetInterfaces().Any(i =>
            i.IsGenericType && i.GetGenericTypeDefinition() == definition &&
            i.GenericTypeArguments[0] == t);

        string name = Has(typeof(IBinaryInteger<>)) ? nameof(Parse_Int)
            : Has(typeof(IFloatingPoint<>)) ? nameof(Parse_Float)
            : throw new NotSupportedException($"No parser for {t}.");

        return (Func<T>)typeof(Assistant)
            .GetMethod(name, BindingFlags.Public | BindingFlags.Static)!
            .MakeGenericMethod(t)
            .CreateDelegate(typeof(Func<T>));
    }
}

Data<T>.Work() can then use T x = Assistant.Parse<T>();. Has checks the implemented constructed interfaces by generic definition and self type; IsAssignableTo(typeof(IBinaryInteger<>)) does not do that check. The helper's type argument is the numeric T, not IBinaryInteger<T>.

I compiled the original pattern and got CS0314 for both interfaces. The dispatcher passed checks with int, long, uint, BigInteger, float, double, Half and decimal on .NET 10, including hex integers and floating NaN/infinity rejection in the helper. Reflection runs when that closed cache initializes; parsing calls use the delegate and retain the original parsing exception type.

This is not automatically trimming/NativeAOT-safe: MakeGenericMethod carries dynamic-code and trimming annotations. For those deployments, explicit registration of supported numeric types or generated dispatch is the safer design.

Also, the NaN/infinity check alone does not require a floating-point constraint: T.IsFinite(value) is already available through INumberBase<T> under your original INumber<T> constraint.

For the language enhancement in your last question, the constraint-bridging proposal, linked in Xiao's reply, describes allowing a checked branch to satisfy a stronger generic constraint. The dispatcher above provides a workaround on .NET 10.

[Xiao-0x41]

This is a common problem, and have been widely discussed in #6308. However,I don't know when runtime will support this feature