C# MethodInfo.GetGenericArguments方法代码示例

		public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder typeBuilder)
		{
			const MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig |
																								MethodAttributes.Virtual;
			ParameterInfo[] parameters = method.GetParameters();

			MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes,
			                                                       CallingConventions.HasThis, method.ReturnType,
			                                                       parameters.Select(param => param.ParameterType).ToArray());

			System.Type[] typeArgs = method.GetGenericArguments();

			if (typeArgs.Length > 0)
			{
				var typeNames = new List<string>();

				for (int index = 0; index < typeArgs.Length; index++)
				{
					typeNames.Add(string.Format("T{0}", index));
				}

				methodBuilder.DefineGenericParameters(typeNames.ToArray());
			}

			ILGenerator IL = methodBuilder.GetILGenerator();

			Debug.Assert(MethodBodyEmitter != null);
			MethodBodyEmitter.EmitMethodBody(IL, method, field);
		}

 private static bool IsSameMethod(MethodInfo first, MethodInfo second)
 {
     return first.DeclaringType == second.DeclaringType
            && first.MetadataToken == second.MetadataToken
            && first.Module == second.Module
            && first.GetGenericArguments().SequenceEqual(second.GetGenericArguments());
 }

        public IAutoFactoryMethodDefinition GetMethodDefinition(MethodInfo methodInfo, IList<object> arguments)
        {
            if (methodInfo.Name.StartsWith("GetNames", StringComparison.InvariantCultureIgnoreCase)
                && methodInfo.IsGenericMethod
                && methodInfo.GetGenericArguments().Any()
                && (methodInfo.ReturnType.IsAssignableFrom(typeof(List<string>))))
            {
                return new AutoFactoryMethodDefinition(AutoFactoryMethodType.GetNames, methodInfo.GetGenericArguments().First(), null, null);
            }

            var pluginType = methodInfo.ReturnType;

            // do nothing with void methods for now
            if (pluginType == typeof(void))
            {
                return null;
            }

            var name = tryGetInstanceName(methodInfo, arguments);

            var isNamed = !string.IsNullOrEmpty(name);

            var explicitArguments = getExplicitArguments(isNamed, methodInfo, arguments);

            return new AutoFactoryMethodDefinition(AutoFactoryMethodType.GetInstance, pluginType, name, explicitArguments);
        }

        protected override Type GetComponentType(MethodInfo method, object[] arguments)
        {
            int genericLength = method.GetGenericArguments().Length;

            if (genericLength == 1)
            {
                bool isView =  typeof (IView).IsAssignableFrom(method.GetGenericArguments()[0]);

                if (method.Name == "CreatePresenter" && isView)
                {
                    return method.GetGenericArguments()[0];
                }
            }

            return base.GetComponentType(method, arguments);
        }

        protected static string GetGenericDeclarationInformation(MethodInfo method, Assembly containingAssembly, bool isDeclaration)
        {
            var builder = new StringBuilder();

            if(method != null)
            {
                var genericArguments = method.GetGenericArguments();
                builder.Append("<");

                var descriptors = new List<string>();

                if(genericArguments != null)
                {
                    foreach(var genericArgument in genericArguments)
                    {
                        var elementType = genericArgument.GetRootElementType();

                        if(isDeclaration)
                        {
                            descriptors.Add(elementType.Name);
                        }
                        else
                        {
                            descriptors.Add(new TypeDescriptor(elementType, containingAssembly, true).Value);
                        }
                    }
                }

                builder.Append(string.Join(", ", descriptors.ToArray()));
                builder.Append(">");
            }

            return builder.ToString();
        }

        protected static GenericTypeParameterBuilder[] CloneGenericMethodArguments(MethodInfo source, MethodBuilder destination)
        {
            var genericArgs = source.GetGenericArguments();

            if (genericArgs.Length == 0)
            {
                return new GenericTypeParameterBuilder[0];
            }

            var names = new string[genericArgs.Length];

            for (var i = 0; i < genericArgs.Length; i++)
            {
                names[i] = genericArgs[i].Name;
            }

            var genericTypeParameterBuilders = destination.DefineGenericParameters(names);

            for (var i = 0; i < genericTypeParameterBuilders.Length; i++)
            {
                var genericArgConstraints = genericArgs[i].GetGenericParameterConstraints();

                for (var j = 0; j < genericArgConstraints.Length; j++)
                {
                    genericTypeParameterBuilders[i].SetBaseTypeConstraint(genericArgConstraints[j]);
                }
            }

            return genericTypeParameterBuilders;
        }

        protected virtual MethodInfo VisitMethod(MethodInfo methodToSearch)
        {
            var newReflectedType = VisitType(methodToSearch.ReflectedType);
            if (newReflectedType != methodToSearch.ReflectedType)
            {
                methodToSearch = newReflectedType.GetMethod(methodToSearch.Name,
                    (methodToSearch.IsStatic ? BindingFlags.Static : BindingFlags.Instance)
                    | (methodToSearch.IsPublic
                        ? BindingFlags.Public
                        : BindingFlags.NonPublic),
                    null,
                    methodToSearch.GetParameters().Select(x => x.ParameterType).ToArray(),
                    null);
            }

            if (!methodToSearch.IsGenericMethod)
                return methodToSearch;

            var genArgs = methodToSearch.GetGenericArguments();
            var newGenArgs = genArgs.Select(VisitType).ToArray();
            if (genArgs.SequenceEqual(newGenArgs))
                return methodToSearch;

            return methodToSearch.GetGenericMethodDefinition().MakeGenericMethod(newGenArgs);
        }

        public static Method CreateMethod(MethodInfo methodInfo, TsType parent)
        {
            var method = new Method(methodInfo.Name, parent)
            {
                IsStatic = methodInfo.IsStatic
            };

            var parameters = methodInfo.GetParameters();
            foreach (var parameterInfo in parameters)
            {
                method.Parameters.Add(MethodParameterFactory.Create(parameterInfo, method));
            }

            if (methodInfo.IsGenericMethod)
            {
                var genericArguments = methodInfo.GetGenericArguments();
                foreach (var argument in genericArguments)
                {
                    method.Generics.Add(new GenericDefinition(argument.Name));
                }
            }

            if (methodInfo.ReturnType != typeof(void))
            {
                method.Return = new TsUndefined { UnderlyingType = methodInfo.ReturnType };
            }

            return method;
        }

        bool CanCompareGenericMethods(MethodInfo a, MethodInfo b)
        {
			return
				   AreEquivalentDefinitions(a, b)
				&& TypesAreAllEquivalent(ParameterTypes(a), ParameterTypes(b))
				&& TypesAreAllEquivalent(a.GetGenericArguments(), b.GetGenericArguments());
        }

        public virtual void GenerateMethod(PropertyInfo pi, MethodInfo mi, ILGenerator gen)
        {
            gen.DeclareLocal(typeof(Type));
            gen.EmitLdType(mi.GetGenericArguments()[0]);
            gen.Emit(OpCodes.Stloc_0);

            foreach (var scc in _pcb.ProxyCoderContext.MixinCoderContexts.SelectMany(a => a.SubjectCoderContexts))
            {
                var smes = scc.GetPerSubjectCoder<ISubjectMethodExistsPerSubjectCoder>();
                if (smes==null)
                    continue;

                var falseTarget = gen.DefineLabel();
                gen.Emit(OpCodes.Ldloc_0);
                gen.EmitLdType(scc.SubjectType);
                gen.EmitOpEqualityCall(typeof(Type));
                gen.Emit(OpCodes.Brfalse, falseTarget);
                smes.PutSubjectMethodExistsOnStack(gen);
                // Required for PE Verification
                gen.Emit(OpCodes.Castclass, mi.ReturnType);
                gen.Emit(OpCodes.Ret);
                gen.MarkLabel(falseTarget);
            }

            gen.Emit(OpCodes.Ldnull);
            gen.Emit(OpCodes.Ret);
        }

        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));
        }

        public static Type[] ResolveTypeArguments(MethodInfo method, object[] parameters)
        {
            var genericArguments = method.GetGenericArguments();
            var parameterTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();

            return genericArguments.Select(genericArgument => ResolveTypeArgument(genericArgument, parameterTypes, parameters)).ToArray();
        }

        /// <summary>
        /// Gets the display name for a method as used by NUnit.
        /// </summary>
        /// <param name="method">The method for which a display name is needed.</param>
        /// <param name="arglist">The arguments provided.</param>
        /// <returns>The display name for the method</returns>
        public static string GetDisplayName(MethodInfo method, object[] arglist)
        {
            StringBuilder sb = new StringBuilder(method.Name);

#if CLR_2_0 || CLR_4_0
            if (method.IsGenericMethod)
            {
                sb.Append("<");
                int cnt = 0;
                foreach (Type t in method.GetGenericArguments())
                {
                    if (cnt++ > 0) sb.Append(",");
                    sb.Append(t.Name);
                }
                sb.Append(">");
            }
#endif

            if (arglist != null)
            {
                sb.Append("(");

                for (int i = 0; i < arglist.Length; i++)
                {
                    if (i > 0) sb.Append(",");
                    sb.Append(GetDisplayString(arglist[i]));
                }

                sb.Append(")");
            }

            return sb.ToString();
        }

        /// <summary>
        /// Implements a method as a no operation method. Method can be virtual, abstract or not.
        /// </summary>
        /// <param name="tB">The <see cref="TypeBuilder"/> for the new type.</param>
        /// <param name="method">The method to implement.</param>
        /// <param name="isVirtual">Defaults to false: the method is sealed. True to keep the method virtual. </param>
        /// <returns>The <see cref="MethodBuilder"/> to enable, for instance, creation of custom attributes on the method.</returns>
        public static MethodBuilder ImplementEmptyStubMethod( TypeBuilder tB, MethodInfo method, bool isVirtual = false )
        {
            if( tB == null ) throw new ArgumentNullException( "tB" );
            if( method == null ) throw new ArgumentNullException( "method" );

            ParameterInfo[] parameters = method.GetParameters();
            Type[] parametersTypes = ReflectionHelper.CreateParametersType( parameters );
            Type returnType = method.ReturnType;

            MethodAttributes mA = method.Attributes & ~(MethodAttributes.Abstract | MethodAttributes.VtableLayoutMask);
            if( isVirtual ) mA |= MethodAttributes.Virtual;
            MethodBuilder mB = tB.DefineMethod( method.Name, mA );
            if( method.ContainsGenericParameters )
            {
                int i = 0;

                Type[] genericArguments = method.GetGenericArguments();
                string[] names = genericArguments.Select( t => String.Format( "T{0}", i++ ) ).ToArray();

                var genericParameters = mB.DefineGenericParameters( names );
                for( i = 0; i < names.Length; ++i )
                {
                    var genericTypeArgument = genericArguments[i].GetTypeInfo();
                    GenericTypeParameterBuilder genericTypeBuilder = genericParameters[i];


                    genericTypeBuilder.SetGenericParameterAttributes( genericTypeArgument.GenericParameterAttributes );
                    genericTypeBuilder.SetInterfaceConstraints( genericTypeArgument.GetGenericParameterConstraints() );
                }
            }
            mB.SetReturnType( method.ReturnType );
            mB.SetParameters( ReflectionHelper.CreateParametersType( parameters ) );
            EmitEmptyImplementation( mB, returnType, parameters );
            return mB;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="MethodInvokeInfo"/> class.
 /// </summary>
 /// <param name="method">The method.</param>
 public MethodInvokeInfo(MethodInfo method)
 {
     name = method.Name;
     declaringType = method.DeclaringType;
     genericArguments = method.GetGenericArguments();
     parameters = method.GetParameters();
     returnType = method.ReturnType;
 }