web-dev-qa-db-fra.com

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

J'aimerais déclarer une expression "vide" lambda ne faisant rien, eh bien .. Y a-t-il un moyen de faire quelque chose comme cela sans avoir besoin de la méthode DoNothing()?

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

    private void DoNothing()
    {
    }

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

Mon intention est uniquement de contrôler l'état activé/désactivé de ma commande WPF, mais c'est un aparté. Peut-être que c'est trop tôt pour moi, mais j'imagine qu'il doit y avoir un moyen de déclarer l'expression x => DoNothing() 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 ça? Il semble simplement inutile d’avoir besoin d’une méthode qui consiste à ne rien faire.

c#lambda
94
Rob
Action doNothing = () => { };
198
Rauhotz

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 */

  /* 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 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);
18
Anthony

Cela devrait fonctionner:

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

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 instruction body . Voir la section 4.6 de la spécification C # 3.0 pour plus de détails.)

7
Jon Skeet

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());
0
Jorge Córdoba