C# MethodInfo.MakeGenericMethod方法代码示例

 private static MethodInfo GetMethodInfo(MethodInfo mi, MemberInfo memberInfo)
 {
     if (memberInfo is FieldInfo) {
         return mi.MakeGenericMethod ((memberInfo as FieldInfo).FieldType);
     }
     if (memberInfo is PropertyInfo) {
         return mi.MakeGenericMethod ((memberInfo as PropertyInfo).PropertyType);
     }
     return null;
 }

        public object InvokeGenericMethod(MethodInfo genericMethodDefinition, Type[] genericArguments, object instance, object[] arguments)
        {
            Debug.Assert(genericMethodDefinition.IsGenericMethodDefinition);

              var method = genericMethodDefinition.MakeGenericMethod(genericArguments);
              return InvokeMethod(method, instance, arguments);
        }

 private static Expression CreateCall(MethodInfo method, ParameterExpression handler, ParameterExpression context, Type handlerType)
 {
     if (method.IsGenericMethod)
     {
         var handlerParameterType = method.GetParameters()[0].ParameterType;
         if (handlerParameterType.IsGenericType)
         {
             var @interface =
                 handlerType.GetInterfaces().FirstOrDefault(
                     i =>
                     i.IsGenericType &&
                     i.GetGenericTypeDefinition() == handlerParameterType.GetGenericTypeDefinition());
             if (@interface != null)
             {
                 method = method.MakeGenericMethod(@interface.GetGenericArguments().Single());
             }
         }
         else
         {
             // bind handler as generic type?
             method = method.MakeGenericMethod(typeof(object));
             //Debugger.Break();
         }
     }
     return Expression.Call(method, handler, context);
 }

        public void Method(
            MethodInfo mi
            , int argToTest)
        {
            var genericArgsInfo = mi.GetGenericArguments();
            int aggregateCount = genericArgsInfo.Count(t => Regex.IsMatch(t.Name, "^TA"));
            if (genericArgsInfo.Length > 0)
                mi = mi.MakeGenericMethod(genericArgsInfo.Select(
                    p => p.Name == "TSourceAggregates" ? typeof(Tuple<int, int>) : typeof(int)).ToArray());

            var paramInfos = mi.GetParameters();
            var callArguments = paramInfos.Select((p, i) =>
                {
                    object arg = null;
                    if (p.ParameterType.IsValueType)
                        arg = Activator.CreateInstance(p.ParameterType);
                    else if (i < argToTest)
                        arg = ConstructArgument(p.ParameterType, aggregateCount);
                    return Expression.Constant(arg, p.ParameterType);
                });

            Action callWithBoundArguments = Expression.Lambda<Action>(Expression.Call(mi, callArguments)).Compile();
            Assert.That(new TestDelegate(callWithBoundArguments), Throws.TypeOf(typeof(ArgumentNullException))
                .With.Property("ParamName").EqualTo(paramInfos[argToTest].Name));
        }

 private static bool ArgsMatch(MethodInfo m, ReadOnlyCollection<Expression> args, Type[] typeArgs)
 {
     ParameterInfo[] parameters = m.GetParameters();
     if (parameters.Length != args.Count)
     {
         return false;
     }
     if ((!m.IsGenericMethod && (typeArgs != null)) && (typeArgs.Length > 0))
     {
         return false;
     }
     if ((!m.IsGenericMethodDefinition && m.IsGenericMethod) && m.ContainsGenericParameters)
     {
         m = m.GetGenericMethodDefinition();
     }
     if (m.IsGenericMethodDefinition)
     {
         if ((typeArgs == null) || (typeArgs.Length == 0))
         {
             return false;
         }
         if (m.GetGenericArguments().Length != typeArgs.Length)
         {
             return false;
         }
         m = m.MakeGenericMethod(typeArgs);
         parameters = m.GetParameters();
     }
     int index = 0;
     int count = args.Count;
     while (index < count)
     {
         Type parameterType = parameters[index].ParameterType;
         if (parameterType == null)
         {
             return false;
         }
         if (parameterType.IsByRef)
         {
             parameterType = parameterType.GetElementType();
         }
         Expression operand = args[index];
         if (!parameterType.IsAssignableFrom(operand.Type))
         {
             if (operand.NodeType == ExpressionType.Quote)
             {
                 operand = ((UnaryExpression) operand).Operand;
             }
             if (!parameterType.IsAssignableFrom(operand.Type) && !parameterType.IsAssignableFrom(StripExpression(operand.Type)))
             {
                 return false;
             }
         }
         index++;
     }
     return true;
 }

        static OptionalTypeConverter()
        {
            optional = (from info in typeof(Prelude).GetMethods()
                        where info.Name == "Optional"
                        select info)
                       .First();

            methods = Prelude.memo((Type valueType) => optional.MakeGenericMethod(valueType));
        }

        static SomeTypeConverter()
        {
            someCreate = (from info in typeof(Some).GetMethods()
                          where info.Name == "Create"
                          select info)
                         .First();

            methods = Prelude.memo((Type valueType) => someCreate.MakeGenericMethod(valueType));
        }

        private static void Add(this ConfigurationRegistrar configurationRegistrar,Type modelConfigurationType, Type modelType, MethodInfo addMethod)
        {
            if (modelType != null)
            {
                addMethod
                    .MakeGenericMethod(modelType)
                    .Invoke(configurationRegistrar, new[] { Activator.CreateInstance(modelConfigurationType) });

            }
        }

        public void ShouldMatchGenericParameters()
        {
            targetMethod = typeof(MethodFinderTargetDummy).GetMethod("DoSomethingGeneric");
            Assert.IsTrue(targetMethod.IsGenericMethodDefinition);

            Type typeArgument = typeof(int);
            targetMethod = targetMethod.MakeGenericMethod(typeArgument);

            builder.TypeArguments.Add(typeArgument);
            RunTest();
        }

        public Case(MethodInfo caseMethod, params object[] parameters)
        {
            this.parameters = parameters != null && parameters.Length == 0 ? null : parameters;
            Class = caseMethod.ReflectedType;

            Method = caseMethod.IsGenericMethodDefinition
                         ? caseMethod.MakeGenericMethod(GenericArgumentResolver.ResolveTypeArguments(caseMethod, parameters))
                         : caseMethod;

            Name = GetName();
        }

    /// <summary>
    /// Takes the given <paramref name="genericMethodDefinition"/> and instantiates it, substituting its generic parameter with the value
    /// type of the value held by this object. The method must have exactly one generic parameter.
    /// </summary>
    /// <param name="genericMethodDefinition">The generic method definition to instantiate.</param>
    /// <returns>
    /// A closed generic instantiation of <paramref name="genericMethodDefinition"/> with this object's value type substituted for
    /// the generic parameter.
    /// </returns>
    public MethodInfo MakeClosedGenericExecuteMethod (MethodInfo genericMethodDefinition)
    {
      ArgumentUtility.CheckNotNull ("genericMethodDefinition", genericMethodDefinition);

      if (!genericMethodDefinition.IsGenericMethodDefinition)
        throw new ArgumentException ("GenericMethodDefinition must be a generic method definition.", "genericMethodDefinition");

      if (genericMethodDefinition.GetGenericArguments ().Length != 1)
        throw new ArgumentException ("GenericMethodDefinition must have exactly one generic parameter.", "genericMethodDefinition");

      return genericMethodDefinition.MakeGenericMethod (DataType);
    }

		public BindDelegateExpression(Type @delegate, Expression owner, MethodInfo methodToBindTo, GenericTypeParameterBuilder[] genericTypeParams)
		{
			delegateCtor = @delegate.GetConstructors()[0];
			this.methodToBindTo = methodToBindTo;
			if(@delegate.IsGenericTypeDefinition)
			{
				var closedDelegate = @delegate.MakeGenericType(genericTypeParams);
				delegateCtor = TypeBuilder.GetConstructor(closedDelegate, delegateCtor);
				this.methodToBindTo = methodToBindTo.MakeGenericMethod(genericTypeParams);
			}
			this.owner = owner;
		}

        public bool InitializeProxyMethod(MethodInfo sourceMethod, Type[] types, out MethodInfo proxyMethod)
        {
            var proxyType = this.ProxyType;
            if (types == null) throw new ArgumentOutOfRangeException("types");
            var proxyTypeArgs = new List<Type>();
            if (ReflectionHelper.IsGenericType(sourceMethod.DeclaringType))
            {
                proxyTypeArgs.AddRange(sourceMethod.DeclaringType.GetTypeInfo().GenericTypeArguments);
            }
            if (sourceMethod.IsGenericMethod)
            {
                proxyTypeArgs.AddRange(sourceMethod.GetGenericArguments());
            }
            var typeArrayPointer = 0;
            if (proxyType.IsGenericTypeDefinition)
            {
                var typeArgs = new Type[proxyType.GenericTypeParameters.Length];
                for (int i = 0; i < typeArgs.Length; i++)
                {
                    typeArgs[i] = proxyTypeArgs[typeArrayPointer];
                    typeArrayPointer++;
                }
                proxyType = proxyType.MakeGenericType(typeArgs).GetTypeInfo();
            }
            if (proxyTypeArgs.Count == typeArrayPointer)
            {
                proxyMethod = proxyType.GetDeclaredMethods(MethodName).FirstOrDefault(m => CheckTypes(m.GetParameters(), types));
            }
            else
            {
                var typeArgs = new Type[proxyTypeArgs.Count - typeArrayPointer];
                for (int i = 0; i < typeArgs.Length; i++)
                {
                    typeArgs[i] = proxyTypeArgs[typeArrayPointer];
                    typeArrayPointer++;
                }
                proxyMethod = proxyType.GetDeclaredMethods(MethodName).FirstOrDefault(m =>
                {
                    if (!m.IsGenericMethodDefinition || m.GetGenericArguments().Length != typeArgs.Length) return false;

                    var genericMethod = m.MakeGenericMethod(typeArgs);

                    return CheckTypes(genericMethod.GetParameters(), types);
                });
                if (proxyMethod != null)
                {
                    proxyMethod = proxyMethod.MakeGenericMethod(typeArgs);
                    return true;
                }
            }
            if (proxyMethod == null) return false;
            return true;
        }

        public static Delegate GetDelegate(MethodInfo openMethod, Type eventType, Type payloadType)
        {
            var closedMethod = openMethod.MakeGenericMethod(eventType);

            return _cache.GetOrAdd(closedMethod, (m) =>
            {
                var param = Expression.Parameter(eventType);
                var call = Expression.Call(param, closedMethod);
                var lambda = Expression.Lambda(call, param);

                return lambda.Compile();
            });
        }

 internal MethodInfo GainMethod()
 {
     if (Info != null)
     {
         return Info;
     }
     Info = GainBase();
     if(GenericParameter.Count > 0)
     {
         Info = Info.MakeGenericMethod(GenericParameter.GainTypes());
     }
     return Info;
 }