Surprising overload resolution with Class & Method generics

[jpieger]

Assuming I have the following code:

var a = "public";
var b = new Wrapper<string>("private");

Console.WriteLine("Direct call");

C<string>.Test(a); // [1] prints "Generic"
C<Wrapper<string>>.Test(b); // [2] prints "Specific"

Console.WriteLine("Using wrapper");

C<string>.Indirect(a); // [3] prints "Generic"
C<Wrapper<string>>.Indirect(b); // [4] prints "Generic"


public static class C<T1> {
	public static void Indirect(T1? data) {
		Test(data);
	}
	public static void Test<T>(T? data) {
		Console.WriteLine("Generic");
	}

	public static void Test<T>(Wrapper<T>? data) {
		Console.WriteLine("Specific");
	}
}

public class Wrapper<T> {
	public T data;

    public Wrapper(T data)
    {
        this.data = data;
    }
}

The first two calls ([1] and [2]) behave as expected. The method specialised for Wrapper<T> is called for the Wrapper<string> argument and the more generic version is called for the bare string.

What did surprise me was the behavior of call [4]. Even though the involved types should all be the same, overload resolution selected the "Generic" method.
Is this intended behavior or a bug? For my understanding, the generic method parameter T should be independent of the class parameter T1.

[TahirAhmadov]

This is intended behavior. The call to Test in the Indirect is resolved to Test<T>(T? data) during compilation, at which point there is no knowledge at all about what T1 can be at runtime.

[HaloFour]

As mentioned, all member resolution is performed at compile time using the type information available to the compiler, so the compiler chooses to bind to Test<T>(T? data) because it doesn't know that T is Wrapper<T>.

One way to emulate the behavior you're looking for is through dynamic dispatch, which can be done through:

	public static void Indirect(T1? data) {
		Test((dynamic?) data);
	}

This will cause the compiler to emit the binding machinery to find and invoke the method at runtime.