CODEWITHSUNDEEP
c#reflectionreferencereflector
user420667
user420667

Reputation: 6700

C# reflection and finding all references

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.

Upvotes: 44

Views: 39822

Answers (5)

Elian Ebbing
Elian Ebbing

Reputation: 19027

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.

Upvotes: 56

Lucas Martins Juviniano
Lucas Martins Juviniano

Reputation: 116

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.

Upvotes: 0

Alexei Levenkov
Alexei Levenkov

Reputation: 100527

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.

Upvotes: 3

Darin Dimitrov
Darin Dimitrov

Reputation: 1038770

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

Upvotes: 5

Gregory A Beamer
Gregory A Beamer

Reputation: 17010

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.

Upvotes: 1

Related Questions