¿Hay alguna manera de especificar una expresión lambda C# "vacía"?

Question

Me gustaría declarar una expresión lambda "vacía" que hace, bueno, nada. ¿Hay alguna manera de hacer algo como esto sin necesidad del método DoNothing()?

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

    private void DoNothing() 
    { 
    } 

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

Mi intención al hacer esto sólo es controlar el estado activado/desactivado de mi mando WPF, pero eso es un aparte. Tal vez sea demasiado temprano en la mañana para mí, pero me imagino que debe haber una manera de declarar simplemente la expresión x => DoNothing() lambda de alguna manera como este para obtener el mismo resultado:

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

¿Hay alguna manera de hacerlo ¿esta? Simplemente parece innecesario el método de no hacer nada.

Answer 1

Action doNothing =() => { }; 

Answer 2

Suponiendo que sólo necesita un delegado (en lugar de un árbol de expresión), entonces esto debería funcionar:

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

(Eso no va a trabajar con árboles de expresión, ya que tiene un cuerpo comunicado ver sección 4.6. . de la especificación C# 3.0 para más detalles)

Answer 3

Esto debería funcionar:

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

Answer 4

No entiendo completamente por qué necesita un método DoNothing.

no puedes hacer:

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

Answer 5

Esta es una vieja pregunta, pero pensé que iba a añadir algo de código que he encontrado útil para este tipo de situación. Tengo una clase estática Actions y una clase estática Functions con algunas funciones básicas en ellos:

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

Creo que esto ayuda a mejorar la legibilidad sólo un poco:

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

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