Gibt es eine Möglichkeit, einen "leeren" C # -Lambda-Ausdruck anzugeben?

Ich möchte einen "leeren" Lambda-Ausdruck deklarieren, der nichts bewirkt. Gibt es eine Möglichkeit, so etwas zu tun, ohne die DoNothing()Methode zu benötigen ?

public MyViewModel()
{
    SomeMenuCommand = new RelayCommand(
            x => DoNothing(),
            x => CanSomeMenuCommandExecute());
}

private void DoNothing()
{
}

private bool CanSomeMenuCommandExecute()
{
    // this depends on my mood
}

Meine Absicht dabei ist es, nur den aktivierten / deaktivierten Status meines WPF-Befehls zu steuern, aber das ist eine Seite. Vielleicht ist es für mich einfach zu früh am Morgen, aber ich stelle mir vor, dass es eine Möglichkeit geben muss, den x => DoNothing()Lambda-Ausdruck einfach so zu deklarieren , um dasselbe zu erreichen:

SomeMenuCommand = new RelayCommand(
    x => (),
    x => CanSomeMenuCommandExecute());

Gibt es eine Möglichkeit, dies zu tun? Es scheint einfach unnötig, eine Do-Nothing-Methode zu benötigen.

Action doNothing = () => { };

Dies ist eine alte Frage, aber ich dachte, ich würde Code hinzufügen, den ich für diese Art von Situation nützlich fand. Ich habe eine Actionsstatische Klasse und eine Functionsstatische Klasse mit einigen Grundfunktionen:

public static class Actions
{
  public static void Empty() { }
  public static void Empty<T>(T value) { }
  public static void Empty<T1, T2>(T1 value1, T2 value2) { }
  /* Put as many overloads as you want */
}

public static class Functions
{
  public static T Identity<T>(T value) { return value; }

  public static T0 Default<T0>() { return default(T0); }
  public static T0 Default<T1, T0>(T1 value1) { return default(T0); }
  /* Put as many overloads as you want */

  /* Some other potential methods */
  public static bool IsNull<T>(T entity) where T : class { return entity == null; }
  public static bool IsNonNull<T>(T entity) where T : class { return entity != null; }

  /* Put as many overloads for True and False as you want */
  public static bool True<T>(T entity) { return true; }
  public static bool False<T>(T entity) { return false; }
}

Ich glaube, dies trägt dazu bei, die Lesbarkeit ein wenig zu verbessern:

SomeMenuCommand = new RelayCommand(
        Actions.Empty,
        x => CanSomeMenuCommandExecute());

// Another example:
var lOrderedStrings = GetCollectionOfStrings().OrderBy(Functions.Identity);

Das sollte funktionieren:

SomeMenuCommand = new RelayCommand(
    x => {},
    x => CanSomeMenuCommandExecute());

Angenommen, Sie benötigen nur einen Delegaten (anstelle eines Ausdrucksbaums), sollte dies funktionieren:

SomeMenuCommand = new RelayCommand(
        x => {},
        x => CanSomeMenuCommandExecute());

(Dies funktioniert bei Ausdrucksbäumen nicht, da es einen Anweisungshauptteil enthält . Weitere Informationen finden Sie in Abschnitt 4.6 der C # 3.0-Spezifikation.)

Ich verstehe nicht ganz, warum Sie eine DoNothing-Methode benötigen.

Kannst du nicht einfach tun:

SomeMenuCommand = new RelayCommand(
                null,
                x => CanSomeMenuCommandExecute());