C# reflection and finding all references

Question

Given a DLL file, I'd like to be able to find all the calls to a method within that DLL file. How can I do this?

Essentially, how can I do programmatically what Visual Studio already does?

I don't want to use a tool like .NET Reflector to do this, but reflection is fine and probably necessary.

Answer 1

To find out where a method MyClass.Foo() is used, you have to analyse all classes of all assemblies that have a reference to the assembly that contains MyClass. I wrote a simple proof of concept of how this code can look like. In my example I used this library (it's just a single .cs file) written by Jb Evain:

I wrote a little test class to analyse:

public class TestClass
{
    public void Test()
    {
        Console.WriteLine("Test");
        Console.Write(10);
        DateTime date = DateTime.Now;
        Console.WriteLine(date);
    }
}

And I wrote this code to print out all the methods used within TestClass.Test():

MethodBase methodBase = typeof(TestClass).GetMethod("Test");
var instructions = MethodBodyReader.GetInstructions(methodBase);

foreach (Instruction instruction in instructions)
{
    MethodInfo methodInfo = instruction.Operand as MethodInfo;

    if(methodInfo != null)
    {
        Type type = methodInfo.DeclaringType;
        ParameterInfo[] parameters = methodInfo.GetParameters();

        Console.WriteLine("{0}.{1}({2});",
            type.FullName,
            methodInfo.Name,
            String.Join(", ", parameters.Select(p => p.ParameterType.FullName + " " + p.Name).ToArray())
        );
    }
}

It gave me the following output:

System.Console.WriteLine(System.String value);
System.Console.Write(System.Int32 value);
System.DateTime.get_Now();
System.Console.WriteLine(System.Object value);

This example is obviously far from complete, because it doesn't handle ref and out parameters, and it doesn't handle generic arguments. I am sure that forgot about other details as well. It just shows that it can be done.

Answer 2

You may take a look at the MSDN Magazine article Determining .NET Assembly and Method References.

Answer 3

Reflection alone is not enough to find all references to a method in a given assembly. Reflection gives you a byte array for the body of any particular method (MethodInfo.GetMethodBody.GetILAsByteArray) and you have to parse it yourself for references to other methods. There are several publicly available "CIL reader" libraries (I have not used them - hopefully someone will post more on it).

Adding FxCop option - depending on your scenario, you may be able to reuse CIL parsing logic provided by FxCop (Visual Studio code analysis) and add your custom rules if running it as part of code analysis is OK for you.

Answer 4

I would consider reflecting the Visual Studio assemblies and see if you can find it in the reverse engineered code base. I believe VS is actually navigating code rather than reflecting. Reflection, as Michael has posted, is great for determining the bits of an assembly, but not the consumers of those bits. I have not re-examined reflection to confirm my suspicions, however.