C# übergeben der Methode als parameter

Beim einloggen bekommen Sie immer verstrickt in string-literalen.

Ich gelöst, die schön für Eigenschaften, Felder und Variablen, die durch die übergabe einer Expression<Func<T>> expression (wie bereits hier), so dass Sie tun können, Dinge wie diese:

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

Will ich tun, etwas ähnliches für die Methode Demo selbst:

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

Versuchte ich Dinge wie diese:

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

und so:

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

Aber bekomme ich compiler Fehler wie diese:

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

Konnte ich die Einführung einer Reihe von überladungen mit Func<...> und Aktion<...>, aber das klingt zu Komplex.

Gibt es eine Möglichkeit, diese für jede Methode, die mit einer beliebigen Anzahl von Parametern und ein optionales Ergebnis?

--jeroen

PS: ich denke, diese Frage vielleicht haben einige Relevanz hier, aber keine Antworten, die mir ein " aha " - Gefühl 🙂

Ich verstehe Ihre Frage, aber glaubst du nicht, Sie wäre es viel einfacher und besser erweiterbar mit einigen AOP-framework? Man könnte das erstellen von benutzerdefinierten-Attribut, das würde daneben Methoden, die protokolliert werden sollen, nach dem Aufruf.
Ich habe AOP in der Vergangenheit, und es verursacht die compile/link-Male zu explodieren. Da .NET hat bereits viel höher compile/link Male, die ich lieber vermeiden.
Jede Lösung für dieses Allgemeine problem, das ich gesehen habe, die mit expression trees verwendet hat, die mehrere überladungen Ansatz, der ist auch ein bisschen umständlich, da müssen Sie die Parameter enthalten. Wenn ich dabei bin, zu schreiben-Handbuch trace-logging, ich in der Regel geben Sie einfach den Namen der Methode als string-Konstante und verlassen Sie sich auf Resharper um mich daran zu erinnern, um synchron zu halten.

InformationsquelleAutor Jeroen Wiert Pluimers | 2011-03-26

c#methods parameters

3

Anstatt zu versuchen, übergeben Sie der Methode als parameter zu Ihrem logger, schauen Sie es aus der Sicht der logger identifizieren die aufrufende Methode.

Hier ist ein (pseudo -) Beispiel:

Logger-Klasse
```
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 );
}
```
Überall, verwendet der logger:
```
//resides in class Foo
public void SomeMethod()
{
  logger.Debug("Start");
}
```
Den Ausgang aus dem logger wird dann sein: Foo.SomeMethod: Start
- +1; Dank für die Ausarbeitung an die solution, die Josh G vorgeschlagen. Ich habe bekommen, was er meinte, aber mit einem aufwendigeren Beispiel bei der hand wird helfen, die künftigen Nutzer eine Menge.
- Dies ist eine logging-Bibliothek, die ich schrieb mit MS Enterprise Logging Library vor ein paar Jahren. Das löste ziemlich viel, was Sie versuchen zu erreichen, ich denke, dass Sie möchten, dass der logger zu wissen, welche Methode aufgerufen, den logger. Die nette Sache über diese ist mit der DeclaringType werden Sie am Ende mit einem vollen Namensraum der Methode. und keine sorgen über das hinzufügen der Namen der Methode als Bestandteil des logging-Nachricht.
- Ich akzeptierte Ihre Antwort, denn es sorgt für den saubersten code an der call-site. Keine gewundenen Ausdrücken. Schön.
- Gleiche problem ist dieser ein. In release keine brauchbaren Rahmen zur Verfügung. Und der andere ist der Reiniger wirklich.
InformationsquelleAutor Metro Smurf
5

Können Sie auch erreichen, ohne das ExpressionTrees durch System.Diagnostics.StackTrace.
```
StackTrace trace = new StackTrace();
```
Dann:
```
trace.GetFrame(0).GetMethod().Name
```
Um die MethodInfo-und dann den Namen der aktuellen Methode, oder:
```
trace.GetFrame(1).GetMethod().Name 
```
Bekommen die aufrufende Methode.
- +1; Interessant! Untersuchen Sie diese. Vielen Dank für denken außerhalb der box. Dies wird wahrscheinlich auch helfen mir sehr, immer die Parameter in eine automatische Weise.
- Dies ist vor allem auch non-performant, und birgt die Gefahr von frames optimiert, entfernt.
- Ausdrücke sind bekanntlich sehr teuer, wie gut, können Sie näher auf die being optimized away Teil; meinst du inlining?
- Was Kirk sagt (und das ist legitim) ist, dass, wenn Sie erstellen eine optimierte Version zu bauen anstatt ein debug-build, Sie können nicht finden die richtige frames im stack-trace. In der Tat, könnten Sie nicht finden, ALLE Rahmen, die in dem stack-trace.
- Ja nützlich für die Debug version. In Release ich sehe nur den Main frame und die logger-Methode, dazwischen gibt es nichts. 🙁
- ist richtig. Die stack-trace-option funktioniert nur im debug.
InformationsquelleAutor Josh G
5

Dies ist viel schwieriger, als es aussieht. Ich glaube, Sie könnten am besten mit den generischen Func und Action überlastungen, aber es ist ein Weg, dies zu tun mit dem Ausdruck Bäume. Hier ist ein Beispiel, in 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;
}
```
Dieser Ausgänge:
```
DoIt 
DoIt2 
DoIt3
```
Beachten Sie, dass ich hatte, um Lambda-Ausdrücke und geben Sie dummy-Argumente, die beim Aufruf der Log-Methode.

Diese basiert auf Fjodor Soikin ausgezeichnete Antwort.
- Danke für die Antwort; ich hatte Angst, es würde sich um so etwas wie dieses, aber es ist gut, haben es bestätigt.
InformationsquelleAutor TrueWill
0

Können Sie definieren einen Delegaten, dann akzeptieren, dass Delegaten als parameter.
```
public delegate void DemoDelegate(string arg);

public void MyMethod(DemoDelegate delegate)
{
    //Call the delegate
    delegate("some string");
}
```
Können Sie rufen Sie Meinemethode wie diese:
```
MyMethod(delegate(string arg) 
{
   //do something
});
```
oder
```
void MethodThatTakesAString(string value)
{
    //do something
}

MyMethod(MethodThatTakesAString);
```
Finden Sie unter diesem link für mehr Informationen:

http://msdn.microsoft.com/en-us/library/aa288459(v=vs. 71).aspx
- Ich weiß über die Delegierten, aber nicht, um zu sehen, wie dieser mir helfen würde, für eine beliebige Methode mit einer beliebigen Anzahl von Parametern. Bitte erläutern Sie, wie ich wohl Aussehen über etwas sehr offensichtlich 🙂
InformationsquelleAutor Kyle Trauberman

Versuchen Sie dies:

///<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
    }
}

Dann kannst du das tun...

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

Ich hoffe, dass ich deine Frage verstanden habe korrekt... nicht das tun, was Sie wollen?

InformationsquelleAutor Cameron Peters

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.