Why can't I look up a specific generic method by its parameter types?

The System.Linq.Queryable type has a method named Contains with two overloads:

• bool Contains<TSource>(this IQueryable<TSource>, TSource)
• bool Contains<TSource>(this IQueryable<TSource>, TSource, IEqualityComparer<TSource>?)

I want to get the first overload, so I use the following code:

var queryableContainsMethod = typeof(Queryable).GetMethod(
    nameof(Queryable.Contains),
    new[] { typeof(IQueryable<T>), typeof(T), });

But this returns null. Why?

NOTE: I am not asking how to get a reference to this method; I am asking why the code that I expect to give me said reference, does not.

The reason is that the parameters are generic while IQueryable<T> is not, for reflection purposes. It uses the T type of the enclosing method.

Unlike what I assumed, there's no need to specify Static in the binding flags.

It's possible to use typeof on a generic type by omitting the type parameters, eg typeof(IQueryable<>)

Borrowing from this similar question about OrderBy, the following snippet can retrieve the Contains(TSource) overload:

var TSource = Type.MakeGenericMethodParameter(0);

var method=typeof(Queryable).GetMethod(
    nameof(Queryable.Contains),
    new[] { 
        typeof(IQueryable<>).MakeGenericType(TSource), 
        TSource 
    }
);

To get the second, we need to specify the IEqualityComparer<> parameter too:

var TSource = Type.MakeGenericMethodParameter(0);

var method=typeof(Queryable).GetMethod(
    nameof(Queryable.Contains),
    new[] { 
        typeof(IQueryable<>).MakeGenericType(TSource), 
        TSource,
        typeof(IEqualityComparer<>).MakeGenericType(TSource)
    }
);

My guess is that it is due to the generic type argument.

T will resolve to a specific type at runtime. So if T is an int it will look for a method with the signature Contains<int>(this IQueryable<int>, int). But no such method exists. You instead need to look for a generic method, without specifying the actual type of the generic method parameter type.

I'm not sure exactly how you should write that, but reflection with generic types tend to be even more complicated than regular reflection. There are a bunch of of reflection methods, like MakeGenericMethod to help convert from or to an open generic type and a type with the generic parameters specified.

As various commenters have noted, specifying binding flags might also be needed, but I would think you also need handle the generic types some other way.