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.

Answer 5

Hey this is an example assuming you want to search for all the calls in the current assembly. I coded this trying to get a parameter value in order to set some constraints for a method with some default values. But I couldn't manage to get the parameter values, I got only types and defaults.

var currentAssembly = Assembly.GetExecutingAssembly();

foreach (var method in currentAssembly.GetTypes().Where(type => type.IsClass)
                                      .SelectMany(cl => cl.GetMethods())
                                      .OfType<MethodBase>()
                                      .SelectMany(mb => mb.GetInstructions())
                                      .Select(inst => inst.Operand).OfType<MethodInfo>()
                                      .Where(mi => mi.Name == "<YourMethodName>"))
{
    //here are your calls.
}

Hope it helps.

Answer 6

See Stack Overflow question Get a list of functions for a DLL.

Ripped from the above (thanks Jon Skeet):

For a particular assembly, you can use Assembly.GetTypes to get the types, then for each type call Type.GetMethods(), Type.GetProperties() etc, or just Type.GetMembers().

However, for plugin functionality it's usually a good idea to have a common interface which the plugins have to implement - that reduces the amount of reflection you need to use. Use Type.IsAssignableFrom() to check whether a type is compatible with a particular interface.

You might also want to look at the Managed Extensibility Framework which can make implementing an extension system easier.