Existe-t-il un moyen de spécifier une expression lambda C # «vide»?

Je voudrais déclarer une expression lambda "vide" qui ne fait rien. Existe-t-il un moyen de faire quelque chose comme ça sans avoir besoin de la DoNothing()méthode?

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

private void DoNothing()
{
}

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

Mon intention en faisant cela est de contrôler uniquement l'état activé / désactivé de ma commande WPF, mais c'est un aparté. Il est peut-être trop tôt le matin pour moi, mais j'imagine qu'il doit y avoir un moyen de simplement déclarer l' x => DoNothing()expression lambda d'une manière comme celle-ci pour accomplir la même chose:

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

Y a-t-il un moyen de faire cela? Il semble simplement inutile d'avoir besoin d'une méthode de ne rien faire.

Action doNothing = () => { };

C'est une vieille question, mais j'ai pensé ajouter du code que j'ai trouvé utile pour ce type de situation. J'ai une Actionsclasse statique et une Functionsclasse statique avec quelques fonctions de 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; }
}

Je pense que cela permet d'améliorer un tout petit peu la lisibilité:

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

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

Cela devrait fonctionner:

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

En supposant que vous n'avez besoin que d'un délégué (plutôt que d'un arbre d'expression), cela devrait fonctionner:

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

(Cela ne fonctionnera pas avec les arbres d'expression car il a un corps d'instruction . Voir la section 4.6 de la spécification C # 3.0 pour plus de détails.)

Je ne comprends pas tout à fait pourquoi vous avez besoin d'une méthode DoNothing.

Tu ne peux pas simplement faire:

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