C# Microsoft.Cci.GetParameters方法代码示例

        private void MakeMethodParameters(MethodBase method, Cci.IMethodReference methodRef, out Type[] methodGenericParameters, out ParameterInfo[] parameters, out ParameterInfo returnParameter)
        {
            Type declaringType = method.DeclaringType;

            if (methodRef.IsGeneric && methodRef.AsGenericMethodInstanceReference == null)
            {
                // generic definition
                methodGenericParameters = MakeGenericParameters((MethodInfo)method, methodRef);
            }
            else
            {
                methodGenericParameters = Type.EmptyTypes;
            }

            Type[] typeGenericParameters;
            if (declaringType.IsGenericTypeDefinition)
            {
                typeGenericParameters = declaringType.GetGenericArguments();
            }
            else
            {
                typeGenericParameters = Type.EmptyTypes;
            }

            GenericContext genericContext = methodGenericParameters.Length > 0 || typeGenericParameters.Length > 0 ?
                new GenericContext(typeGenericParameters, methodGenericParameters) : default(GenericContext);

            parameters = new ParameterInfo[methodRef.ParameterCount];
            int i = 0;
            foreach (var parameter in methodRef.GetParameters(_context))
            {
                parameters[i] = MakeParameterInfo(method, i + 1, parameter.GetType(_context), genericContext, parameter.CustomModifiers, parameter.IsByReference);
                i++;
            }

            returnParameter = MakeParameterInfo(method, 0, methodRef.GetType(_context), genericContext, methodRef.ReturnValueCustomModifiers, methodRef.ReturnValueIsByRef);
        }

        private MethodBase ResolveOverload(MemberInfo[] members, Cci.IMethodReference methodRef)
        {
            IEnumerable<Cci.IParameterTypeInformation> paramRefs = methodRef.GetParameters(_context);

            Type[] reusableResolvedParameters = null;
            Type[] typeGenericParameters = members[0].DeclaringType.GetGenericArguments();

            MethodBase candidate = null;
            foreach (MethodBase method in members)
            {
                Debug.Assert(!method.IsGenericMethod || method.IsGenericMethodDefinition);

                if (methodRef.AcceptsExtraArguments && method.CallingConvention != CallingConventions.VarArgs)
                {
                    continue;
                }

                if (methodRef.IsGeneric != method.IsGenericMethodDefinition)
                {
                    continue;
                }

                Type[] methodGenericParameters = (methodRef.IsGeneric) ? method.GetGenericArguments() : Type.EmptyTypes;
                if (methodGenericParameters.Length != methodRef.GenericParameterCount)
                {
                    continue;
                }
                GenericContext genericContext = new GenericContext(typeGenericParameters, methodGenericParameters);
                Type[] resolvedParameters = reusableResolvedParameters ??
                    ResolveMethodParameters(methodRef, paramRefs, genericContext);

                if (ParametersMatch(resolvedParameters, method.GetParameters()) && ReturnTypeMatches(methodRef, method, genericContext))
                {
                    Debug.Assert(candidate == null);
                    candidate = method;
#if !DEBUG
                    break;
#endif
                }

                // We can reuse resolved parameters if the method isn't generic. 
                // If it is its signature might contain references to its generic parameters which are different for each overload.
                if (reusableResolvedParameters == null && !methodRef.IsGeneric)
                {
                    reusableResolvedParameters = resolvedParameters;
                }
            }

            Debug.Assert(candidate != null);
            return candidate;
        }

        private void GetParameterTypes(Cci.ISignature signature, out Type[] types, out Type[][] reqMods, out Type[][] optMods)
        {
            // name, default value, marshalling and custom attributes are handled later in DefineParameter
            types = new Type[signature.ParameterCount];
            reqMods = optMods = null;

            int i = 0;
            foreach (var parameter in signature.GetParameters(_context))
            {
                Type type = ResolveParameterType(parameter);

                // TODO (tomat, Dev12): this doesn't handle types constructed from modified types, we need Ref.Emit support for that:
                ModifiedType modifiedType = type as ModifiedType;
                if (modifiedType != null)
                {
                    type = modifiedType.UnmodifiedType;

                    if (modifiedType.RequiredModifiers != null)
                    {
                        if (reqMods == null)
                        {
                            reqMods = new Type[types.Length][];
                        }

                        reqMods[i] = modifiedType.RequiredModifiers;
                    }

                    if (modifiedType.OptionalModifiers != null)
                    {
                        if (optMods == null)
                        {
                            optMods = new Type[types.Length][];
                        }

                        optMods[i] = modifiedType.OptionalModifiers;
                    }
                }

                types[i++] = type;
            }
        }