How should we bypass constraint check for generic types/methods?

[acaly]

I think it's quite difficult now to fully utilize the power of some constraint interfaces (by "constraint interfaces" I mean interfaces that are used primarily as generic constraint), especially for struct types. For example, if I want to provide different implementation for a type T depending on whether it implements some interface IHaveSomeOperation<T>, then it would either need to box the value to call interface methods (note that this doesn't work for static abstract methods now), or to go for reflection to create a generic method bypassing constraint check. Ideally the compiler and runtime should understand some type check patterns and allow user to use generic methods/types with the same constraints that have been checked. For example:

void DoSomething<T>(T value) where T : IHaveSomeOperation<T> {}

void TryDoSomething<T>(T value)
{
    if (default(T) is IHaveSomeOperation<T>)
    {
        //here we should be allowed to call DoSomething<T>(value).
    }
}

If the compiler generates the wrong code and runtime finds T is not IHasSomeOperation<T>, then simply throwing an exception is acceptable.

There are many constructs in the runtime that I think exists just for this reason, for example, EqualityComparer<TKey>.Default is to use T : IEquatable<T>, RuntimeHelpers.IsReferenceOrContainsReferences is to use T : unmanaged. If we are to extend the usage of constraint interfaces, I think we should be allowed to use them in a more comfortable way, without writing something like SomeOperationDoer<T>.Default for each IHaveSomeOperation<T> interface.

Also in Linq, there are many usages like

return source is IIListProvider<TSource> arrayProvider
        ? arrayProvider.ToArray()
        : EnumerableHelpers.ToArray(source);

This kind of code is fine for Linq, since they only accept interface instances, which are already boxed. However, once we have structs implementing interfaces, I think we should have some better syntax to call methods without limited by constraints.

Probably related to dotnet/csharplang#3050, but here everything is known, and it is not asking for declaring a completely unknow generic type to use inside a method.

[Joe4evr]

void TryDoSomething<T>(T value)
{
    if (value is IHaveSomeOperation<T> hso)
    {
        DoSomething(hso);
    }
}

[acaly]

void TryDoSomething<T>(T value)
{
    if (value is IHaveSomeOperation<T> hso)
    {
        DoSomething(hso);
    }
}

1. It simply does not work. Let's call T in DoSomething to be T1, and T in TryDoSomething to be T2. Here hso is IHaveSomeOperation<T2>, but IHaveSomeOperation<T2> as a T1 does not meet the requirement of where T1 : IHaveSomeOperation<T1>, which translates to where IHaveSomeOperation<T2> : IHaveSomeOperation<IHaveSomeOperation<T2>>.
2. Even if it works, as I said, it will cause boxing of value to hso. Not to mention the overhead of dynamically checking implementation list of interfaces, which, given T, can be determined statically.
3. It won't call a specialized version of DoSomething, only a interface's version, i.e. DoSomething<IHaveSomeOperaiont<???>>. This eliminates all the good thing of writing generic code. I should indead write a non generic DoSomething(IHaveSomeOperation obj). Besides, this won't allow static abstract members to be called.

[huoyaoyuan]

I think this should be solved by self type instead of CRTP.

[acaly]

Could you elaborate? Even if CRTP is replaced by self type, I think we still cannot call a method with where T : IHaveSomeOperation if starting with a T without any constraint. Note that the generic method should be called without boxing and with the generic argument beingT instead of the interface type.

[huoyaoyuan]

if (value is IHaveSomeOperation hso) should work then. This approach does box and may be canceled by JIT.

The desired solution is to combine constraints in method body, if (T is IHaveSomeOperation) or if (T is IHaveSomeOperation<T>). I looks like a bit hard for the type system.

[acaly]

if (value is IHaveSomeOperation hso) should work then. This approach does box and may be canceled by JIT.

The problem is, DoSomething(hso) will always be DoSomething<IHaveSomeOperation>(hso), which completely loses its generic property. This might be fine for some cases, but not all.

1. As I said, this will not allow static abstract methods to be called.
2. This always calls the same generic version of the method. While this might be fine for reference types (as JIT internally shares those implementations anyway), it will make a difference for value types. If the caller is optimized to be used with different Ts (for example, cache some value for each different T in static readonly variables), those optimization won't take effect.
3. If DoSomething has another constraint of struct (where T : struct, IHaveSomeOperation) then you cannot use this method.

[acaly]

I agree it will be hard, no matter its for the language or the runtime. But since we have been allowing many unsafe things to exist in C#, I think it's not impossible to allow programmer to specify that the constraint check can be skipped. The runtime can just throw or do whatever if the programmer is wrong.

[hez2010]

Use reflection (and you can use a generic dictionary for optimization):

new Test().Do();

interface IHaveSomeOperation<T> { }

struct Foo : IHaveSomeOperation<Foo> { }

class Test
{
    private static Dictionary<Type, Delegate> genericDict = new();
    
    void DoSomething<T>(T value) where T : IHaveSomeOperation<T>
    { 
        Console.WriteLine("Hello");
    }

    void TryDoSomething<T>(T value) where T : struct
    {
        if (default(T) is IHaveSomeOperation<T>)
        {
            var f = genericDict.ContainsKey(typeof(T)) ? (Action<T>)genericDict[typeof(T)] : 
                (Action<T>)(genericDict[typeof(T)] = typeof(Test)
                    .GetMethod(nameof(DoSomething), BindingFlags.NonPublic | BindingFlags.Instance)!
                    .MakeGenericMethod(typeof(T))
                    .CreateDelegate<Action<T>>(this));
            f(value);
        }
    }
    
    public void Do()
    {
        TryDoSomething(new Foo());
    }
}