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

Question

Je voudrais déclarer un "vide", expression lambda qui n'a, rien. Est-il un moyen de faire quelque chose comme cela sans avoir besoin de l' 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 de le faire, c'est seulement le contrôle de l'activé/désactivé de l'état de mes commandes WPF, mais c'est une de côté. C'est peut-être un peu trop tôt le matin pour moi, mais j'imagine qu'il doit y avoir un moyen de simplement déclarer x => DoNothing() expression lambda en quelque sorte, comme ce pour accomplir la même chose:

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

Est-il possible de faire cela? Il semble tout à fait inutile d'avoir besoin d'un faire-rien de méthode.

Answer 1

Action doNothing = () => { };

Answer 2

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 classe statique Actions et une classe statique Functions 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 */
}
 

Je crois que cela contribue à améliorer un peu la lisibilité:

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

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

Answer 3

Cela devrait fonctionner:

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

Answer 4

En supposant que vous n’ayez 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 possède un corps d'instruction . Voir la section 4.6 de la spécification C # 3.0 pour plus de détails.)

Answer 5

Je ne comprends pas très bien pourquoi avez-vous besoin d'une méthode DoNothing?

Ne pouvez-vous pas simplement faire:

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