In C#, what Type is "method group"?

I want to write a method in C# that can take any other method and print out info about this method, like name, parameters etc. Something like:

public string GetMethodInfo([some type] method, params object[] args)
{
    // Use reflection to create a string with the method's name and list of parameters with their values
    //...
   return methodText;
}

public int Foo(int a, int b)
{
    return a + b;
}
 
public void DoSomething(int a, int b, int c)
{
   Debug.WriteLine("Now calling... " + GetMethodInfo(Foo, a, b));
   Foo(a, b);
   //...
}

No matter what Type I use (even "object"), the compiler always complains that it can't convert it from "method group". I understand that method group is not a real Type but simply a compiler construct that means something along the lines of "a group of one of more methods, which will be overloaded if there are more than one". Note though that in this case the method I'm passing in will never have any overloads so I should be able to resolve it in GetMethodInfo (and even if there are overloads, it should be possible to resolve it from the list of passed in args).

But is there no way to pass in a method of arbitrary signature that can then be analyzed using reflection? Of course I can make a delegate declaration for each method and use overloaded GetMethoInfo methods but that defeats the purpose.

@BitFlipper:

A "Method Group" is an internal type used by the compiler in order to keep track of the expression so far. It's not an LValue and you can't put it in a variable; it doesn't inherit from anything and it doesn't have a .NET Type.

If you want to capture it, you must use a delegate.

void foo()
{
}

void Main()
{
  var f = foo; // wrong!
  var q = new Action(foo): // correct.
} 

1 hour ago, BitFlipper wrote

But is there no way to pass in a method of arbitrary signature that can then be analyzed using reflection? Of course I can make a delegate declaration for each method and use overloaded GetMethoInfo methods but that defeats the purpose.

The closest you can do for that is to create an anonymous class and then look at the methods declared on that class reflectively. Alternatively if you're asking how you can pass an arbitrary method signature to a function, you can use the base class of all delegates System.Delegate as the function argument - and you can reflectively look at the parameters to get their type.

LINQ Expression trees are just about the closest you can get to that. You can pass the method as a lambda that appears to call the method you're interested in (the call will never get executed so it can use bogus parameters), and then extract the MethodInfo from the lambda expression. Something like this:

static void SomeMethod(int n)
{
}

static void Inspect(Expression<Action> expr)
{
    var call = (MethodCallExpression)expr.Body;
    Console.WriteLine(call.Method.Name);
}

static void Main(string[] args)
{
    Inspect(() => SomeMethod(0));
}

It's a small step over regular reflection as you at least get a compile time check on the name of SomeMethod, but it's not much.

Like evildictaitor said, method groups are not a real type. They can only ever be converted to delegate, the type of which has to be specified explicitly (even if the method has no overloads).

@Sven Groot:

Thanks, I'll look into this. I have not used the Expression<Action> type yet but it looks promising. I assume there are ways to get to the actual argument values that were passed in too? If that is the case then it could come close to what I need.

However at some point if it gets to be too complicated then it makes more sense to just do traditional logging and this whole thing becomes just an academic question.