获取 C# 方法体内使用的类型

Question

有没有办法获取 C# 方法中使用的所有类型？

例如，

public int foo(string str)
{
    Bar bar = new Bar();
    string x = "test";
    TEST t = bar.GetTEST();
}

将返回：Bar、string 和 TEST。

我现在能得到的只是使用 EnvDTE.CodeFunction 的方法正文文本。也许有比尝试解析这段代码更好的方法来实现它。

Answer 1

我将借此机会发布我所做的概念证明，因为有人告诉我这是不可能完成的 - 通过在这里和那里进行一些调整，扩展它以提取所有内容是相对微不足道的方法中引用的类型 - 对于它的大小和缺乏前言表示歉意，但它有一些评论：

void Main()
{
    Func<int,int> addOne = i => i + 1;
    Console.WriteLine(DumpMethod(addOne));
    Func<int,string> stuff = i =>
    {
        var m = 10312;        
        var j = i + m;
        var k = j * j + i;
        var foo = "Bar";
        var asStr = k.ToString();
        return foo + asStr;
    };
    Console.WriteLine(DumpMethod(stuff));

    Console.WriteLine(DumpMethod((Func<string>)Foo.GetFooName));

    Console.WriteLine(DumpMethod((Action)Console.Beep));
}

public class Foo
{
    public const string FooName = "Foo";
    public static string GetFooName() { return typeof(Foo).Name + ":" + FooName; }
}

public static string DumpMethod(Delegate method)
{
    // For aggregating our response
    StringBuilder sb = new StringBuilder();

    // First we need to extract out the raw IL
    var mb = method.Method.GetMethodBody();
    var il = mb.GetILAsByteArray();

    // We'll also need a full set of the IL opcodes so we
    // can remap them over our method body
    var opCodes = typeof(System.Reflection.Emit.OpCodes)
        .GetFields()
        .Select(fi => (System.Reflection.Emit.OpCode)fi.GetValue(null));

    //opCodes.Dump();

    // For each byte in our method body, try to match it to an opcode
    var mappedIL = il.Select(op => 
        opCodes.FirstOrDefault(opCode => opCode.Value == op));

    // OpCode/Operand parsing: 
    //     Some opcodes have no operands, some use ints, etc. 
    //  let's try to cover all cases
    var ilWalker = mappedIL.GetEnumerator();
    while(ilWalker.MoveNext())
    {
        var mappedOp = ilWalker.Current;
        if(mappedOp.OperandType != OperandType.InlineNone)
        {
            // For operand inference:
            // MOST operands are 32 bit, 
            // so we'll start there
            var byteCount = 4;
            long operand = 0;
            string token = string.Empty;

            // For metadata token resolution            
            var module = method.Method.Module;
            Func<int, string> tokenResolver = tkn => string.Empty;
            switch(mappedOp.OperandType)
            {
                // These are all 32bit metadata tokens
                case OperandType.InlineMethod:        
                    tokenResolver = tkn =>
                    {
                        var resMethod = module.SafeResolveMethod((int)tkn);
                        return string.Format("({0}())", resMethod == null ? "unknown" : resMethod.Name);
                    };
                    break;
                case OperandType.InlineField:
                    tokenResolver = tkn =>
                    {
                        var field = module.SafeResolveField((int)tkn);
                        return string.Format("({0})", field == null ? "unknown" : field.Name);
                    };
                    break;
                case OperandType.InlineSig:
                    tokenResolver = tkn =>
                    {
                        var sigBytes = module.SafeResolveSignature((int)tkn);
                        var catSig = string
                            .Join(",", sigBytes);
                        return string.Format("(SIG:{0})", catSig == null ? "unknown" : catSig);
                    };
                    break;
                case OperandType.InlineString:
                    tokenResolver = tkn =>
                    {
                        var str = module.SafeResolveString((int)tkn);
                        return string.Format("('{0}')",  str == null ? "unknown" : str);
                    };
                    break;
                case OperandType.InlineType:
                    tokenResolver = tkn =>
                    {
                        var type = module.SafeResolveType((int)tkn);
                        return string.Format("(typeof({0}))", type == null ? "unknown" : type.Name);
                    };
                    break;
                // These are plain old 32bit operands
                case OperandType.InlineI:
                case OperandType.InlineBrTarget:
                case OperandType.InlineSwitch:
                case OperandType.ShortInlineR:
                    break;
                // These are 64bit operands
                case OperandType.InlineI8:
                case OperandType.InlineR:
                    byteCount = 8;
                    break;
                // These are all 8bit values
                case OperandType.ShortInlineBrTarget:
                case OperandType.ShortInlineI:
                case OperandType.ShortInlineVar:
                    byteCount = 1;
                    break;
            }
            // Based on byte count, pull out the full operand
            for(int i=0; i < byteCount; i++)
            {
                ilWalker.MoveNext();
                operand |= ((long)ilWalker.Current.Value) << (8 * i);
            }

            var resolved = tokenResolver((int)operand);
            resolved = string.IsNullOrEmpty(resolved) ? operand.ToString() : resolved;
            sb.AppendFormat("{0} {1}", 
                    mappedOp.Name, 
                    resolved)
                .AppendLine();                    
        }
        else
        {
            sb.AppendLine(mappedOp.Name);
        }
    }
    return sb.ToString();
}

public static class Ext
{
    public static FieldInfo SafeResolveField(this Module m, int token)
    {
        FieldInfo fi;
        m.TryResolveField(token, out fi);
        return fi;
    }
    public static bool TryResolveField(this Module m, int token, out FieldInfo fi)
    {
        var ok = false;
        try { fi = m.ResolveField(token); ok = true; }
        catch { fi = null; }    
        return ok;
    }
    public static MethodBase SafeResolveMethod(this Module m, int token)
    {
        MethodBase fi;
        m.TryResolveMethod(token, out fi);
        return fi;
    }
    public static bool TryResolveMethod(this Module m, int token, out MethodBase fi)
    {
        var ok = false;
        try { fi = m.ResolveMethod(token); ok = true; }
        catch { fi = null; }    
        return ok;
    }
    public static string SafeResolveString(this Module m, int token)
    {
        string fi;
        m.TryResolveString(token, out fi);
        return fi;
    }
    public static bool TryResolveString(this Module m, int token, out string fi)
    {
        var ok = false;
        try { fi = m.ResolveString(token); ok = true; }
        catch { fi = null; }    
        return ok;
    }
    public static byte[] SafeResolveSignature(this Module m, int token)
    {
        byte[] fi;
        m.TryResolveSignature(token, out fi);
        return fi;
    }
    public static bool TryResolveSignature(this Module m, int token, out byte[] fi)
    {
        var ok = false;
        try { fi = m.ResolveSignature(token); ok = true; }
        catch { fi = null; }    
        return ok;
    }
    public static Type SafeResolveType(this Module m, int token)
    {
        Type fi;
        m.TryResolveType(token, out fi);
        return fi;
    }
    public static bool TryResolveType(this Module m, int token, out Type fi)
    {
        var ok = false;
        try { fi = m.ResolveType(token); ok = true; }
        catch { fi = null; }    
        return ok;
    }
}

Answer 2

如果您可以访问此方法的 IL，您也许可以做一些合适的事情。也许看看开源项目 ILSpy 并看看您是否可以利用他们的任何工作。

Answer 3

正如其他人提到的，如果您有 DLL，您可以使用类似于 的内容ILSpy 的分析功能（迭代程序集中的所有 IL 指令以查找对特定类型的引用）。

否则，如果不将文本解析为 C# 抽象语法树，并使用解析器，就无法做到这一点 - 解析器可以很好地理解代码的语义，以了解示例中的“Bar”是否确实是一个名称可以从该方法访问的类型（在其“使用”范围内），或者可能是方法的名称、成员字段等... SharpDevelop 包含一个 C# 解析器（称为“NRefactory”）并且还包含这样一个解析器，你可以看看通过查看此线程来追求该选项，但请注意，这是公平的使其正常工作所需的工作量。

Answer 4

我刚刚发布了 如何使用 Mono.Cecil 进行静态代码分析，如下所示。

我还展示了一个 CallTreeSearch 枚举器类，它可以静态分析调用树，查找某些有趣的事情并使用自定义提供的选择器函数生成结果，因此您可以将其插入“有效负载”逻辑，例如，

    static IEnumerable<TypeUsage> SearchMessages(TypeDefinition uiType, bool onlyConstructions)
    {
        return uiType.SearchCallTree(IsBusinessCall,
               (instruction, stack) => DetectTypeUsage(instruction, stack, onlyConstructions));
    }

    internal class TypeUsage : IEquatable<TypeUsage>
    {
        public TypeReference Type;
        public Stack<MethodReference> Stack;

        #region equality
        // ... omitted for brevity ...
        #endregion
    }

    private static TypeUsage DetectTypeUsage(
        Instruction instruction, IEnumerable<MethodReference> stack, bool onlyConstructions)
    {
        TypeDefinition resolve = null;
        {
            TypeReference tr = null;

            var methodReference = instruction.Operand as MethodReference;
            if (methodReference != null)
                tr = methodReference.DeclaringType;

            tr = tr ?? instruction.Operand as TypeReference;

            if ((tr == null) || !IsInterestingType(tr))
                return null;

            resolve = tr.GetOriginalType().TryResolve();
        }

        if (resolve == null)
            throw new ApplicationException("Required assembly not loaded.");

        if (resolve.IsSerializable)
            if (!onlyConstructions || IsConstructorCall(instruction))
                return new TypeUsage {Stack = new Stack<MethodReference>(stack.Reverse()), Type = resolve};

        return null;
    }

这省略了一些细节

• 实现IsBusinessCall、IsConstructorCall 和 TryResolve 因为这些都很简单，仅用作说明性

希望有帮助

Answer 5

我能想到的最接近的是表达式树。请查看Microsoft 的文档。

然而它们非常有限，并且仅适用于简单表达式，而不适用于具有语句体的完整方法。

编辑：由于海报的目的是查找类耦合和使用的类型，我建议使用商业工具，例如 NDepend 将代码分析作为一个简单的解决方案。

Answer 6

这绝对不能通过反射（GetMethod()、表达式树等）来完成。正如您所提到的，使用 EnvDTE 的 CodeModel 是一种选择，因为您可以逐行获取 C# 在那里，但在 Visual Studio 之外使用它（即处理已经存在的函数，而不是在编辑器窗口中）几乎是不可能的，恕我直言。

但我可以推荐Mono.Cecil，它可以处理CIL 逐行代码（在方法内），您可以在您引用的任何程序集中的任何方法上使用它。然后，您可以检查每一行是否是变量声明（例如 string x = "test" 或 methodCall），并且可以获得这些行中涉及的类型。

Answer 7

通过反射，您可以 获取方法。这将返回一个 MethodInfo 对象，通过该对象，您可以无法获取该方法中使用的类型。所以我认为答案是你无法在 C# 中获得此原生。

Answer 8

今天，您可以通过调用 LocalVariables 来自 MethodBody 类。
例如：

public class Example
{
    public static void Main()
    {
        var methodInfo = typeof(Example).GetMethod("foo");
        var methodBody = methodInfo?.GetMethodBody();
        
        foreach (var localVariableInfo in methodBody.LocalVariables)
        {
            Console.WriteLine("Type: {0}", localVariableInfo.LocalType);
        }
        //result:
        //Local variable type: Bar
        //Local variable type: System.String
        //Local variable type: TEST
    }
    
    public void foo(string str)
    {
        Bar bar = new Bar();
        string x = "test";
        TEST t = bar.GetTEST();
    }
}