C'è un modo per specificare un'espressione lambda C # "vuota"?

Vorrei dichiarare un'espressione lambda "vuota" che non fa, beh, niente. C'è un modo per fare qualcosa di simile senza bisogno del DoNothing()metodo?

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

private void DoNothing()
{
}

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

Il mio intento in questo è solo controllare lo stato abilitato / disabilitato del mio comando WPF, ma questo è un a parte. Forse è solo troppo presto per me la mattina, ma immagino che ci debba essere un modo per dichiarare l' x => DoNothing()espressione lambda in qualche modo come questo per ottenere la stessa cosa:

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

C'è un modo per farlo? Sembra solo inutile aver bisogno di un metodo non fare nulla.

Action doNothing = () => { };

Questa è una vecchia domanda, ma ho pensato di aggiungere del codice che ho trovato utile per questo tipo di situazione. Ho una Actionsclasse statica e una Functionsclasse statica con alcune funzioni di base:

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

Credo che questo aiuti a migliorare la leggibilità solo un po ':

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

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

Questo dovrebbe funzionare:

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

Supponendo che sia necessario solo un delegato (anziché un albero delle espressioni), allora dovrebbe funzionare:

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

(Ciò non funzionerà con gli alberi delle espressioni poiché ha un corpo di istruzione . Vedere la sezione 4.6 delle specifiche C # 3.0 per maggiori dettagli.)

Non capisco completamente perché hai bisogno di un metodo DoNothing.

Non puoi semplicemente fare:

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