C# 将任何方法作为参数传递

Question

记录日志时，您总是会与字符串文字纠缠在一起。

我通过传递 Expression> 很好地解决了属性、字段和变量的问题。表达式 （如解释这里），所以你可以做这样的事情：

public void Demo(string someArgument)
{
    LogFrameWork.LogLine("Demo"); // goal is to get rid of these string literals
    LogFramework.Log(() => someArgument);
}

我想对方法 Demo 本身做类似的事情：

public void Demo(string someArgument)
{
    LogFramework.Log(this.Demo);
}

我尝试了这样的事情：

public static void Log(Delegate method)
{
    string methodName = method.Method.Name;
    LogLine(methodName);
}

和这样的：

public static void Log(Action method)
{
    string methodName = method.Method.Name;
    LogLine(methodName);
}

但是我得到了这样的编译器错误：

Argument 1: cannot convert from 'method group' to 'System.Delegate' 
Argument 1: cannot convert from 'method group' to 'System.Action'   

我可以使用 Func<...> 和 Action<...>，但这听起来过于复杂。

对于具有任意数量的参数和可选结果的任何方法，有没有办法解决这个问题？

--jeroen

PS：我认为这个问题可能在这里有一些相关性，但没有答案这让我有一种“啊哈”的感觉:-)

Answer 1

您也可以通过 System.Diagnostics.StackTrace 实现此目的，无需使用 ExpressionTree。

StackTrace trace = new StackTrace();

然后：

trace.GetFrame(0).GetMethod().Name

获取 MethodInfo 以及当前方法的名称，或者：

trace.GetFrame(1).GetMethod().Name 

获取调用方法。

Answer 2

这比看起来要难得多。我认为您可能最适合使用通用 Func 和 Action 重载，但是有一种方法可以使用表达式树来做到这一点。下面是 LINQPad 中的一个示例：

public static void Log(Expression<Action> expr)
{
    Console.WriteLine(((MethodCallExpression)expr.Body).Method.Name);
}

void Main()
{
    Log(() => DoIt());
    Log(() => DoIt2(null));
    Log(() => DoIt3());
}

public void DoIt()
{
    Console.WriteLine ("Do It!");
}

public void DoIt2(string s)
{
    Console.WriteLine ("Do It 2!" + s);
}

public int DoIt3()
{
    Console.WriteLine ("Do It 3!");
    return 3;
}

此输出：

DoIt
DoIt2
DoIt3

请注意，在调用 Log 方法时，我必须使用 lambda 并指定虚拟参数。

这是基于 Fyodor Soikin 的出色答案。

Answer 3

不要尝试将方法作为参数传递给记录器，而是从让记录器识别调用方法的角度来看待它。

这是一个（伪）示例：

Logger Class

public void Debug( string message )
{
  message = string.Format( "{0}: {1}", GetCallingMethodInfo(), message );
  // logging stuff
}

/// <summary>
/// Gets the application name and method that called the logger.
/// </summary>
/// <returns></returns>
private static string GetCallingMethodInfo()
{
  // we should be looking at the stack 2 frames in the past:
  // 1. for the calling method in this class
  // 2. for the calling method that called the method in this class
  MethodBase method = new StackFrame( 2 ).GetMethod();
  string name = method.Name;
  string type = method.DeclaringType.Name;

  return string.Format( "{0}.{1}", type, name );
}

在任何使用记录器的地方：

// resides in class Foo
public void SomeMethod()
{
  logger.Debug("Start");
}

记录器的输出将是：Foo.SomeMethod: Start

Answer 4

您可以定义一个委托，然后接受该委托作为参数。

public delegate void DemoDelegate(string arg);

public void MyMethod(DemoDelegate delegate)
{
    // Call the delegate
    delegate("some string");
}

您可以像这样调用 MyMethod：

MyMethod(delegate(string arg) 
{
   // do something
});

或

void MethodThatTakesAString(string value)
{
    // do something
}

MyMethod(MethodThatTakesAString);

查看此链接以获取更多信息：

http://msdn.microsoft.com/en-us/library/aa288459(v=vs.71).aspx

Answer 5

试试这个：

/// <summary>
/// Trace data event handler delegate.
/// </summary>
/// <returns>The data to write to the trace listeners</returns>
public delegate object TraceDataEventHandler();

public static class Tracing
{

    /// Trace a verbose message using an undefined event identifier and message.
    /// </summary>
    /// <param name="message">The delegate to call for the trace message if this event should be traced.</param>
    [Conditional("TRACE")]
    public static void TraceVerbose(TraceMessageEventHandler message)
    {
        ... your logic here
    }
}

然后你可以做...

Tracing.TraceVerbose(() => String.Format(...));

我希望我正确理解了你的问题...这符合你的要求吗？