Differentiation of the general and non-generic versions of the overloaded method using reflection

Question

I am having problems using reflection to distinguish between a non-generic and a generic method for a generic class. Here's a test case I'm working with:

public class Foo<T>
{
  public string Bar( T value ) { return "Called Bar(T)"; }

  public string Bar( int value ) { return "Called Bar(int)"; }

  public static void CallBar<TR>(Foo<TR> foo)
  {
      var fooInfo = foo.GetType()
         .GetMethods()
         .Where(x => !x.IsGenericMethod && // doesn't filter out Bar(T)!
                 x.Name == "Bar" &&
                 x.GetParameters().First().ParameterType == typeof(int))
         // !Two identical MethodInfo results, how to choose between them?
         // Is there a gauranteed canonical ordering? Or is it undefined?
         .First();

      Console.WriteLine(fooInfo.Invoke(foo, new object[]{ 0 }));
  }
}

// prints Bar(T)...
Foo<int>.CallBar( new Foo<int>() );

Answer 1

Unfortunately, System.Reflection does not provide a good way to map a method of the constructed type to the corresponding method of determining the general type from which it was created. There are two solutions that I know of, none of them are perfect:

№1: static TypeBuilder.GetMethod. GetMethod TypeBuilder, generic built type MethodInfo . TypeBuilder.GetMethod(Foo<int>, Foo<T>.Bar(T)) Foo<int>.Bar(T-as-int), Foo<int>.Bar(int).

( , , Foo<int> Foo<T>.Bar(T) Type MethodInfo, , ).

, , - TypeBuilder, .

№2: MetadataToken.. , Token . , Foo<T>.Bar(T) Foo<int>.Bar(T-as-int) Token. :

var barWithGenericParameterInfo = typeof(Foo<>).GetMethods()
   .Where(mi => mi.Name == "Bar" && 
          mi.GetParameters()[0].ParameterType.IsGenericParameter);

var mappedBarInfo = foo.GetType().GetMethods()
    .Where(mi => mi.MetadataToken == genericBarInfo.MetadataToken);

( , :))

, MetadataToken (, ), . , .

Answer 2

Foo <int> , Bar (T) Bar (int), int, .

Bar (T), typeof (Foo < gt;) typeof (Foo <int> ).

. :

    public static void CallBar<TR>(Foo<TR> foo)
    {
        Func<MethodInfo, bool> match = m => m.Name == "Bar";

        Type fooType = typeof(Foo<>);
        Console.WriteLine("{0}:", fooType);
        MethodInfo[] methods = fooType.GetMethods().Where(match).ToArray();

        foreach (MethodInfo mi in methods)
        {
            Console.WriteLine(mi);
        }

        Console.WriteLine();

        fooType = foo.GetType();
        Console.WriteLine("{0}:", fooType);
        methods = fooType.GetMethods().Where(match).ToArray();

        foreach (MethodInfo mi in methods)
        {
            Console.WriteLine(mi);
        }
    }

:

System.String(T)
System.String(Int32)

System.String(Int32)
System.String(Int32)

Answer 3

: typeof (Foo < > ). .

  public class Foo<T> {
    public string Bar(T value) { return "Called Bar(T)"; }
    public string Bar(int value) { return "Called Bar(int)"; }
    public static void CallBar<TR>(Foo<TR> foo) {

      var footinfo = typeof(Foo<>).GetMethods();
      int i;
      for (i = 0; i < footinfo.Count(); ++i) {
        if (footinfo[i].Name == "Bar" && footinfo[i].GetParameters()[0].ParameterType.IsGenericParameter == false)
          break;
      }

      Console.WriteLine(foo.GetType().GetMethods()[i].Invoke(foo, new object[] { 0 }));
    }
  }
  // prints Bar(int)...
  Foo<int>.CallBar( new Foo<int>() );

ContainsGenericParameters Foo < > false Foo, .

Answer 4

, ContainsGenericParameters - , , :

http://msdn.microsoft.com/en-us/library/system.reflection.methodinfo.isgenericmethod.aspx http://msdn.microsoft.com/en-us/library/system.reflection.methodinfo.containsgenericparameters.aspx

Answer 5

, ; , - . , .

,

foo.GetType()

to

foo.GetGenericTypeDefinition()

. MSDN.