System.Reflection.Module.ResolveMethod C# (CSharp) Method

        public MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
        {
            MetadataToken tk = new MetadataToken(metadataToken);

            if (!MetadataImport.IsValidToken(tk))
                throw new ArgumentOutOfRangeException("metadataToken",
                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));

            RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
            RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);

            try 
            {
                if (!tk.IsMethodDef && !tk.IsMethodSpec)
                {
                    if (!tk.IsMemberRef)
                        throw new ArgumentException("metadataToken",
                            String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethod", tk, this)));

                    unsafe
                    {
                        ConstArray sig = MetadataImport.GetMemberRefProps(tk);
                        
                        if (*(CorCallingConvention*)sig.Signature.ToPointer() == CorCallingConvention.Field)
                            throw new ArgumentException("metadataToken", 
                                String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethod"), tk, this));
                    }
                }

                RuntimeMethodHandle methodHandle = GetModuleHandle().ResolveMethodHandle(tk, typeArgs, methodArgs);
                Type declaringType = methodHandle.GetDeclaringType().GetRuntimeType();
    
                if (declaringType.IsGenericType || declaringType.IsArray)
                {
                    MetadataToken tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tk));
                
                    if (tk.IsMethodSpec)
                        tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tkDeclaringType));
                
                    declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
                }

                return System.RuntimeType.GetMethodBase(declaringType.GetTypeHandleInternal(), methodHandle);    
            } 
            catch (BadImageFormatException e) 
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
            }
        }

        public IMethodReference FindMethod(uint metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
        {
            // Lookup the type in the cache
            List <GenericReference <IMethodReference> > genericMethodReferences;

            if (_genericTokenMethodMap.TryGetValue(metadataToken, out genericMethodReferences))
            {
                foreach (GenericReference <IMethodReference> r in genericMethodReferences)
                {
                    if (CompareArrays(r.GenericArgs, genericMethodArguments))
                    {
                        return(r.Reference);
                    }
                }
            }

            IList <ITypeReference> genericArguments = new List <ITypeReference>();

            foreach (Type type in genericTypeArguments)
            {
                genericArguments.Add(AssemblyManager.FindType(type, type.GetGenericArguments()));
            }

            MethodBase methodBase = _netModule.ResolveMethod((int)metadataToken, genericTypeArguments, genericMethodArguments);

            IMethodDeclaration methodDeclaration;

            if (methodBase is ConstructorInfo)
            {
                methodDeclaration = new ConstructorDeclaration((ConstructorInfo)methodBase, this,
                                                               AssemblyManager.FindType(methodBase.DeclaringType, methodBase.DeclaringType.GetGenericArguments()));
            }
            else
            {
                methodDeclaration = new MethodDeclaration((MethodInfo)methodBase, this,
                                                          AssemblyManager.FindType(methodBase.DeclaringType, methodBase.DeclaringType.GetGenericArguments()));
            }

            if (genericMethodReferences == null)
            {
                genericMethodReferences = new List <GenericReference <IMethodReference> >();
                _genericTokenMethodMap.Add(metadataToken, genericMethodReferences);
            }

            genericMethodReferences.Add(new GenericReference <IMethodReference>(methodDeclaration, genericTypeArguments));

            return(methodDeclaration);
        }