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.

Gordie

Do you need to detect only static calls to the method? Should calls with Reflection and Reflection Emit also be detected? – Iodism

And should this work with non-managed code? Not all DLLs support reflection. – Denunciate

@Darin: those would be icing on the cake, but aren't necessary. @James: I don't think I have to worry about non-managed code. How could I do this on dlls that don't support reflection? – Gordie

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.

Mosier

Nice. This also uses Linq for the select statement. Time to build me some dependency graphs. – Gordie

I'm getting this error message: "Value does not fall within the expected range." from this bit of code: this.body = method.GetMethodBody(); if (this.body == null) throw new ArgumentException(); and I'm wondering how there could be bodyless methods (or what else could be going on). any thoughts? – Foundling

@ekkis: an abstract method (of an abstract class) is bodyless. You can check if the method is abstract by checking MethodBase.IsAbstract. – Mosier

@ElianEbbing, apparently there are other kinds of bodiless methods. Take a look at System.GetType() - I'm not sure what's special about this one but the .GetMethodBody() also comes up null. I wonder whether we should be throwing ArgumentExceptions in these cases or just fail silently – Foundling

@Foundling - You are right. It seems that the core .net library contains some methods that have no body. These methods are decorated with the [MethodImpl(MethodImplOptions.InternalCall)] attribute and are implemented within the CL runtime itself. I think you are right that the GetInstructions() method should return an empty list in this case instead of an exception. – Mosier

MethodBodyReader - I learn something new everyday, this is liquid gold! – Thromboplastin

Nuget alternative to MethodBodyReader: nuget package mono.reflection with var instructions = Disassembler.GetInstructions(methodBase); – Survival

Answer 2

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

Iodism

+1: note that you'll have to search somewher for IL reader - Reflector's one is not directly available as far as I can tell... – Stinkhorn

Good article. But it suggests using Reflector for the method dependencies. I guess they all boil down to parsing IL. – Gordie

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.

Stinkhorn

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.

Quality

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.

Omega