Question

I have a class that implements an Interface with some methods.
I also have method with an Action parameter where I pass the Interface method.
Is it possible to get the type of the owner that has the method?

EDIT
This is the wrapper:

private void Wrapper (params Action[] actions)
{
    var action = actions.FirstOrDefault();
    var type = action.Method.DeclaringType.Name;
}

private void test()
{
   Wrapper(()=> _GC.ChargeCancellation(""));
}

For demonstration purpose I don’t iterate through the collection.

I want the type of _GC.

Answer 1

Actually, I should’ve spotted this to begin with but since Jon didn’t either I’m not feeling too bad about it 🙂

The code you have to begin with in your question does not compile:

Wrapper(() => TestClass.Hello);

This is not complete code. You either have to have:

Wrapper(TestClass.Hello);
        ^
        |
        +-- notice the missing () => here

or:

Wrapper(() => TestClass.Hello());
                             ^
                             |
                             +-- notice the added parenthesis here

And now that you have edited your question, it is clear you have the second form.

There’s a subtle difference between the two. Subtle to us, but important to the compiler:

Wrapper(TestClass.Hello);
        ^------+------^
               |
               +-- This is a method group

Wrapper(() => TestClass.Hello());
              ^------+--------^
                     |
                     +-- This is a method call

A method group is a reference to a method (or its overloads), a method call is executable code.

The difference to the compiler is that in the first piece of code, the compiler will wrap up the method group into an action, basically compile it like this:

Wrapper(new Action(TestClass.Hello));

and thus, you’re passing that method to the Wrapper method, inside an Action delegate.

However, the second form is handled altogether differently. The compiler now produces a new method to contain your code, and then passes the new method to the Wrapper method instead of the code you had.

Thus, your code actually looks like this:

public static void Main()
{
    Wrapper(new Action(TempMethod1));
}

private static void TempMethod1()
{
    TestClass.Hello();
}

And that’s why you’re seeing the form class as the owner of the method, because that’s what it is.

The reason I asked in a comment whether you were taking a delegate or an expression is that my brain was working at half speed. It detected something odd, but not the whole picture.

If you want to pass code like this to a method, and work with it, you have two choices:

1. For a delegate, work with reflection, decompile the code and analyze it, find the method call and figure out which class it is made on
2. For an expression, analyze the pieces of the expression (this requires C# 3 or above)

Since neither is trivial I’m not going to post any code here, suffice to say that what you’re asking warrants a new question. Of the two, I suggest you go with the expression way if you can.