MethodInfo e.l. for metode som System.String

Kode 

static int test()
{
   return 1;
}

static void Main()
{
    Console.Write(test().GetType());
}

Kode 

using System;
using System.Linq;
using System.Reflection;

namespace Thomas.CSharp.Testing
{
    class ReferenceTypes
    {
        static unsafe void Main(string[] args)
        {
            Type type = Type.GetType("System.Console");
            MethodInfo[] methods = type.GetMethods();

            methods = (from m in methods where (m.ReturnType.ToString() == "System.Void" && m.Name == "WriteLine") select m).ToArray();
            foreach (MethodInfo m in methods)
                Console.WriteLine("Name = {0}\nType = {1}\n", m.Name, m.ReturnType.ToString());

            Console.ReadKey();
        }
    }
}

CSharp kode 

 using System;
 using System.Linq;
 using System.Reflection;
 
 namespace Thomas.CSharp.Testing
 {
     class MethodIsolator
     {
         static void Main(string[] args)
         {
             Console.WriteLine(GetReturnTypeFromMethod("System.Console.ReadLine") ?? "Not found");
             Console.WriteLine(GetReturnTypeFromMethod("System.Console.WriteLine", null) ?? "Not found");
             Console.WriteLine(GetReturnTypeFromMethod("System.Console.WriteLine", "System.String") ?? "Not found");
             Console.WriteLine(GetReturnTypeFromMethod("System.Console.WriteLine", new string[] { "System.String" }) ?? "Not found");
             Console.ReadLine();
         }
 
         public static string GetReturnTypeFromMethod(string method, object _types)
         {
             string[] types = null;
             if (_types is string)
                 types = new string[] { _types as string };
             else if (_types is string[])
                 types = _types as string[];
             else if (_types == null)
                 types = new string[0];
             else
                 return null;
 
             string nspc = IsolateNamespace(method);
             method = IsolateMethod(method);
 
             Type type = Type.GetType(nspc);
             foreach (MethodInfo methodInfo in type.GetMethods())
             {
                 if (methodInfo.Name == method)
                 {
                     ParameterInfo[] args = methodInfo.GetParameters();
                     // If the method takes 0 args and none are specified, the method is found
                     if ((_types == null) && (args.Length == 0))
                         return methodInfo.ReturnType.ToString();
                     // If the amount of methods is inconsistent with the types specified, the method isn't found
                     if (args.Length != types.Length)
                         goto Next;
                     int argIndex = 0;
                     foreach (ParameterInfo paramInfo in args)
                     {
                         if (paramInfo.ParameterType.ToString() != types[argIndex++])
                             goto Next;
                     }
                     // This point will only be reached if all param types are consistent
                     return methodInfo.ReturnType.ToString();
                 }
             Next:
                 method = method; // A redundant but valid (and therefore necessary) statement
             }
 
             return null;
         }
 
         public static string GetReturnTypeFromMethod(string method)
         {
             return GetReturnTypeFromMethod(method, null);
         }
 
         public static string IsolateNamespace(string method)
         {
             string[] parts = method.Split('.');
             string @namespace = string.Empty;
 
             parts = parts.Take<string>(parts.Length - 1).ToArray();
             foreach (string part in parts)
                 @namespace += "." + part;
 
             @namespace = @namespace.Remove(0, 1);
             return @namespace;
         }
 
         public static string IsolateMethod(string method)
         {
             string[] parts = method.Split('.');
             return parts[parts.Length - 1];
         }
     }
 }