从MethodInfo打印方法的完整签名

时间:2009-08-21 14:05:39

标签: c# .net debugging reflection

.NET BCL中是否有任何现有功能可以使用MethodInfo提供的信息在运行时打印方法的完整签名(就像您在Visual Studio ObjectBrowser中看到的那样 - 包括参数名称)?

因此,例如,如果查找String.Compare(),其中一个重载将打印为:

public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase, System.Globalization.CultureInfo culture)

请注意包含所有访问和范围限定符的完整签名以及包括名称在内的完整参数列表。这就是我要找的东西。我可以编写自己的方法,但如果可能的话,我宁愿使用现有的实现。

4 个答案:

答案 0 :(得分:26)

不幸的是,我不相信有一种内置方法可以做到这一点。最好的方法是通过调查MethodInfo类

来创建自己的签名

编辑:我刚刚做了这个

 MethodBase mi = MethodInfo.GetCurrentMethod();
 mi.ToString();

你得到了

  

Void Main(System.String [])

这可能不是你想要的,但它很接近。

这个怎么样

 public static class MethodInfoExtension
        {
            public static string MethodSignature(this MethodInfo mi)
            {
                String[] param = mi.GetParameters()
                              .Select(p => String.Format("{0} {1}",p.ParameterType.Name,p.Name))
                              .ToArray();


            string signature = String.Format("{0} {1}({2})", mi.ReturnType.Name, mi.Name, String.Join(",", param));

            return signature;
        }
    }

    var methods = typeof(string).GetMethods().Where( x => x.Name.Equals("Compare"));

    foreach(MethodInfo item in methods)
    {
        Console.WriteLine(item.MethodSignature());
    }

这是结果

  

Int32 Compare(String strA,Int32   indexA,String strB,Int32 indexB,Int32   长度,StringComparison   comparisonType)

答案 1 :(得分:26)

更新3/22/2018

我重写了代码,添加了一些测试,并uploaded it to GitHub

答案

using System.Text;

namespace System.Reflection
{
    public static class MethodInfoExtensions
    {
        /// <summary>
        /// Return the method signature as a string.
        /// </summary>
        /// <param name="method">The Method</param>
        /// <param name="callable">Return as an callable string(public void a(string b) would return a(b))</param>
        /// <returns>Method signature</returns>
        public static string GetSignature(this MethodInfo method, bool callable = false)
        {
            var firstParam = true;
            var sigBuilder = new StringBuilder();
            if (callable == false)
            {
                if (method.IsPublic)
                    sigBuilder.Append("public ");
                else if (method.IsPrivate)
                    sigBuilder.Append("private ");
                else if (method.IsAssembly)
                    sigBuilder.Append("internal ");
                if (method.IsFamily)
                    sigBuilder.Append("protected ");
                if (method.IsStatic)
                    sigBuilder.Append("static ");
                sigBuilder.Append(TypeName(method.ReturnType));
                sigBuilder.Append(' ');
            }
            sigBuilder.Append(method.Name);

            // Add method generics
            if(method.IsGenericMethod)
            {
                sigBuilder.Append("<");
                foreach(var g in method.GetGenericArguments())
                {
                    if (firstParam)
                        firstParam = false;
                    else
                        sigBuilder.Append(", ");
                    sigBuilder.Append(TypeName(g));
                }
                sigBuilder.Append(">");
            }
            sigBuilder.Append("(");
            firstParam = true;
            var secondParam = false;
            foreach (var param in method.GetParameters())
            {
                if (firstParam)
                {
                    firstParam = false;
                    if (method.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false))
                    {
                        if (callable)
                        {
                            secondParam = true;
                            continue;
                        }
                        sigBuilder.Append("this ");
                    }
                }
                else if (secondParam == true)
                    secondParam = false;
                else
                    sigBuilder.Append(", ");
                if (param.ParameterType.IsByRef)
                    sigBuilder.Append("ref ");
                else if (param.IsOut)
                    sigBuilder.Append("out ");
                if (!callable)
                {
                    sigBuilder.Append(TypeName(param.ParameterType));
                    sigBuilder.Append(' ');
                }
                sigBuilder.Append(param.Name);
            }
            sigBuilder.Append(")");
            return sigBuilder.ToString();
        }

        /// <summary>
        /// Get full type name with full namespace names
        /// </summary>
        /// <param name="type">Type. May be generic or nullable</param>
        /// <returns>Full type name, fully qualified namespaces</returns>
        public static string TypeName(Type type)
        {
            var nullableType = Nullable.GetUnderlyingType(type);
            if (nullableType != null)
                return nullableType.Name + "?";

            if (!(type.IsGenericType && type.Name.Contains('`')))
                switch (type.Name)
                {
                    case "String": return "string";
                    case "Int32": return "int";
                    case "Decimal": return "decimal";
                    case "Object": return "object";
                    case "Void": return "void";
                    default:
                        {
                            return string.IsNullOrWhiteSpace(type.FullName) ? type.Name : type.FullName;
                        }
                }

            var sb = new StringBuilder(type.Name.Substring(0,
            type.Name.IndexOf('`'))
            );
            sb.Append('<');
            var first = true;
            foreach (var t in type.GetGenericArguments())
            {
                if (!first)
                    sb.Append(',');
                sb.Append(TypeName(t));
                first = false;
            }
            sb.Append('>');
            return sb.ToString();
        }

    }
}

这几乎可以处理所有事情,包括扩展方法。从http://www.pcreview.co.uk/forums/getting-correct-method-signature-t3660896.html开始。

我在tandum中使用T4模板为所有QueryableEnumerable Linq扩展方法生成重载。

答案 2 :(得分:0)

检查MethodBase上的GetParameters()方法。这将为您提供有关参数的信息,包括参数的名称。我不相信存在一个预先存在的方法来打印出名称,但使用ParameterInfo []构建应该是微不足道的。

这个怎么样:

public string GetSignature(MethodInfo mi)
{
  if(mi == null)
    return "";
  StringBuilder sb = new StringBuilder();

  if(mi.IsPrivate)
    sb.Append("private ");
  else if(mi.IsPublic)
    sb.Append("public ");
  if(mi.IsAbstract)
    sb.Append("abstract ");
  if(mi.IsStatic)
    sb.Append("static ");
  if(mi.IsVirtual)
    sb.Append("virtual ");

  sb.Append(mi.ReturnType.Name + " ");

  sb.Append(mi.Name + "(");

  String[] param = mi.GetParameters()
    .Select(p => String.Format(
              "{0} {1}",p.ParameterType.Name,p.Name))
                          .ToArray();


  sb.Append(String.Join(", ",param));

  sb.Append(")");

  return sb.ToString();
}

答案 3 :(得分:0)

如果该方法具有参数,则ParameterInfo.Member.ToString()将输出您想要的内容。如果没有,创建签名很容易。此方法将返回您想要的内容:

public string PrintSignature(MethodInfo methodInfo)
{
    ParameterInfo[] parameters = methodInfo.GetParameters();
    return parameters.Length > 0 ? parameters[0].Member.ToString() : $"{methodInfo.ReturnType.ToString()} {methodInfo.Name}()";
}

如果您还需要访问限定符:

public string GetSignatureSansModifiers(MethodInfo methodInfo)
{
    ParameterInfo[] parameters = methodInfo.GetParameters();
    return parameters.Length > 0 ? parameters[0].Member.ToString() : $"{methodInfo.ReturnType.ToString()} {methodInfo.Name}()";
}

public string PrintSignature(MethodInfo methodInfo)
{
    StringBuilder sb = new StringBuilder();

    if (methodInfo.IsPrivate)
        sb.Append("private ");
    else if (methodInfo.IsPublic)
        sb.Append("public ");
    if (methodInfo.IsAbstract)
        sb.Append("abstract ");
    if (methodInfo.IsStatic)
        sb.Append("static ");
    if (methodInfo.IsVirtual)
        sb.Append("virtual ");
    sb.Append(GetSignatureSansModifiers(methodInfo));
    return sb.ToString();
}