ジェネリックメソッドを使用してインターフェイスでType.GetRuntimeMethodを呼び出すと、nullが返されます

GetRuntimeMethodメソッドに期待したことを実際に実行する独自の拡張メソッドをコーディングすることができました。気になるのは、.NETが提供するGetRuntimeMethodメソッドがサンプルでnullを返す理由がまだわからないことです。

これが私の問題を一時的に修正する不完全なクラスです。これは非常に素朴なアプローチですが、出発点です。そのクラスには欠けているものがたくさんありますが、少なくとも、それは私が続けることを可能にする答えです。

public static class TypeExtensions
{
    #region Public Methods

    /// <summary>
    /// Looks for the method in the type matching the name and arguments.
    /// </summary>
    /// <param name="type"></param>
    /// <param name="methodName">
    /// The name of the method to find.
    /// </param>
    /// <param name="args">
    /// The types of the method's arguments to match.
    /// </param>
    /// <returns></returns>
    /// <exception cref="ArgumentNullException">
    /// Thrown if:
    ///     - The name of the method is not specified.
    /// </exception>
    public static MethodInfo GetRuntimeMethod(this Type type, string methodName, Type[] args)
    {
        if (ReferenceEquals(type, null))
            throw new NullReferenceException("The type has not been specified.");

        if (string.IsNullOrEmpty(methodName))
            throw new ArgumentNullException("methodName", "The name of the method has not been specified.");


        var methods = type.GetRuntimeMethods().Where(methodInfo => string.Equals(methodInfo.Name, methodName, StringComparison.OrdinalIgnoreCase)).ToList();

        if (!methods.Any())
            return null;    //  No methods have the specified name.

        if (methods.Count == 1)
        {
            MethodInfo methodInfo = methods.Single();
            return IsSignatureMatch(methodInfo, args) ? methodInfo : null;
        }

        //  Oh noes, don't make me go there.
        throw new NotImplementedException("Resolving overloaded methods is not implemented as of now.");
    }

    #endregion

    #region Private Methods

    /// <summary>
    /// Finds out if the provided arguments matches the specified method's signature.
    /// </summary>
    /// <param name="methodInfo"></param>
    /// <param name="args"></param>
    /// <returns></returns>
    private static bool IsSignatureMatch(MethodBase methodInfo, Type[] args)
    {
        Debug.Assert(!ReferenceEquals(methodInfo, null), "The methodInfo has not been specified.");


        //  Gets the parameters of the method to analyze.
        ParameterInfo[] parameters = methodInfo.GetParameters();

        int currentArgId = 0;

        foreach (ParameterInfo parameterInfo in parameters)
        {
            if (!ReferenceEquals(args, null) && currentArgId < args.Length)
            {
                //  Find out if the types matchs.
                if (parameterInfo.ParameterType == args[currentArgId])
                {
                    currentArgId++;
                    continue; //  Yeah! Try the next one.
                }

                //  Is this a generic parameter?
                if (parameterInfo.ParameterType.IsGenericParameter)
                {
                    //  Gets the base type of the generic parameter.
                    Type baseType = parameterInfo.ParameterType.GetTypeInfo().BaseType;


                    //  TODO: This is not good v and works with the most simple situation.
                    //  Does the base type match?  
                    if (args[currentArgId].GetTypeInfo().BaseType == baseType)
                    {
                        currentArgId++;
                        continue; //  Yeah! Go on to the next parameter.
                    }
                }
            }

            //  Is this parameter optional or does it have a default value?
            if (parameterInfo.IsOptional || parameterInfo.HasDefaultValue)
                continue; // Uhum. So let's ignore this parameter for now.

            //  No need to go further. It does not match :(
            return false;
        }

        //  Ye!
        return true;
    }

    #endregion
}