Перегрузка операторов в обобщенном классе. Сложение, вычитание типов T

interface INumber {
    int Value { get; }
}
 
struct MyNumber : INumber {
    public int Value { get; set; }
}
 
int Add<T>(T l, T r) where T : INumber {
    return l.Value + r.Value;
}

public static T Add<T>(T x, T y) {
    return (T)typeof(T).GetMethod("op_Addition", BindingFlags.Static | BindingFlags.Public).Invoke(null, new object[] { x, y });
}

public static T Add<T>(T x, T y) {
    return (T)Convert.ChangeType((dynamic)x + (dynamic)y, typeof(T));
}

class Number<T> where T : struct {
    private T _value;
    private static DynamicMethod _add = GenAdd();
 
    public Number(T value) {
        _value = value;
    }
 
    private static DynamicMethod GenAdd() {
        var method = new DynamicMethod("__Add", typeof(T), new[] { typeof(T), typeof(T) });
        var gen = method.GetILGenerator();
        gen.Emit(OpCodes.Ldarg_0);
        gen.Emit(OpCodes.Ldarg_1);
        gen.Emit(OpCodes.Add);
        gen.Emit(OpCodes.Ret);
        return method;
    }
 
    public static Number<T> operator+(Number<T> left, Number<T> right) {
        return new Number<T>((T)_add.Invoke(null, new object[] { left._value, right._value }));
    }
}

public static Number<T> Method<T>(Number<T> val1, Number<T> val2) where T : struct => val2 + val1;

static void Main(string[] args)
{
    Console.WriteLine(Method(new Number<int>(10), new Number<int>(5)));
    Console.ReadLine();
}

private static DynamicMethod GenMultyply()
{
    var method = new DynamicMethod("__Multyply", typeof(T), new[] { typeof(T), typeof(T) });
    var gen = method.GetILGenerator();
    gen.Emit(OpCodes.Ldarg_0);
    gen.Emit(OpCodes.Ldarg_1);
    gen.Emit(OpCodes.Mul);
    gen.Emit(OpCodes.Ret);
    return method;
}
 
public static Number<T> operator *(Number<T> left, Number<T> right)
{
    return new Number<T>((T)_multyply.Invoke(null, new object[] { left._value, right._value }));
}

internal class Number<T> where T : struct
{
    public Number(T value) => _value = value;
 
    private readonly T _value;
    private static DynamicMethod _add = GenOperation("__Add");
    private static DynamicMethod _multyply = GenOperation("__Multyply");
    private static DynamicMethod _subtraction = GenOperation("__Subtraction");
    private static DynamicMethod _division = GenOperation("__Division");
 
    private static DynamicMethod GenOperation(string operation)
    {
        var method = new DynamicMethod(operation, typeof(T), new[] { typeof(T), typeof(T) });
        ILGenerator gen = method.GetILGenerator();
        gen.Emit(OpCodes.Ldarg_0);
        gen.Emit(OpCodes.Ldarg_1);
        gen.Emit(
            object.Equals(operation, "__Subtraction") ? OpCodes.Sub :
                object.Equals(operation, "__Division")    ? OpCodes.Div :
                    object.Equals(operation, "__Multyply")    ? OpCodes.Mul :
                        object.Equals(operation, "__Add")    ? OpCodes.Add : default(OpCode)
                );        
        gen.Emit(OpCodes.Ret);
        return method;
    }
 
    public static Number<T> operator - (Number<T> left, Number<T> right) => 
        new Number<T>((T)_subtraction.Invoke(null, new object[] { left._value, right._value }));
 
    public static Number<T> operator * (Number<T> left, Number<T> right) => 
        new Number<T>((T)_multyply.Invoke(null, new object[] { left._value, right._value }));
 
    public static Number<T> operator + (Number<T> left, Number<T> right) => 
        new Number<T>((T)_add.Invoke(null, new object[] { left._value, right._value }));
 
    public static Number<T> operator / (Number<T> left, Number<T> right) =>
        new Number<T>((T)_division.Invoke(null, new object[] { left._value, right._value }));
}
 
 
public static Number<T> MethodAdd<T>(Number<T> val1, Number<T> val2) 
    where T : struct => val2 + val1;
 
public static Number<T> MethodMul<T>(Number<T> val1, Number<T> val2)
    where T : struct => val2 * val1;
 
public static Number<T> MethodSub<T>(Number<T> val1, Number<T> val2)
    where T : struct => val2 - val1;
 
public static Number<T> MethodDiv<T>(Number<T> val1, Number<T> val2)
    where T : struct => val2 / val1;