Existe uma maneira de especificar uma expressão lambda C # “vazia”?

Eu gostaria de declarar uma expressão lambda "vazia" que faz, bem, nada. Existe uma maneira de fazer algo assim sem precisar do DoNothing()método?

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

private void DoNothing()
{
}

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

Minha intenção ao fazer isso é apenas controlar o estado ativado / desativado do meu comando WPF, mas isso é um aparte. Talvez seja muito cedo para mim, mas imagino que deve haver uma maneira de apenas declarar a x => DoNothing()expressão lambda de alguma forma como esta para realizar a mesma coisa:

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

Existe alguma maneira de fazer isso? Simplesmente parece desnecessário precisar de um método de não fazer nada.

Action doNothing = () => { };

Essa é uma pergunta antiga, mas pensei em adicionar algum código que achei útil para esse tipo de situação. Eu tenho uma Actionsclasse estática e uma Functionsclasse estática com algumas funções básicas:

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

Acredito que isso ajuda a melhorar um pouco a legibilidade:

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

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

Isso deve funcionar:

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

Supondo que você só precise de um delegado (em vez de uma árvore de expressão), isso deve funcionar:

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

(Isso não funcionará com árvores de expressão, pois tem um corpo de instrução . Consulte a seção 4.6 da especificação C # 3.0 para obter mais detalhes.)

Não entendo completamente por que você precisa de um método DoNothing.

Você não pode simplesmente fazer:

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