Esiste un modo per specificare un'espressione "vuota" C# lambda?

Question

Vorrei dichiarare un'espressione lambda "vuota" che fa, beh, nulla. C'è un modo per fare qualcosa di simile senza il metodo DoNothing()?

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

    private void DoNothing() 
    { 
    } 

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

Il mio intento nel fare ciò è solo controllare lo stato abilitato/disabilitato del mio comando WPF, ma questo è un accantonamento. Forse è solo troppo presto la mattina per me, ma immagino che ci deve essere un modo per dichiarare solo l'espressione x => DoNothing() lambda, in qualche modo come questo per ottenere la stessa cosa:

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

C'è qualche modo per farlo Questo? Sembra semplicemente inutile avere bisogno di un metodo do-nothing.

Answer 1

Action doNothing =() => { }; 

Answer 2

Supponendo che è necessario solo un delegato (piuttosto che un albero di espressione), allora questo dovrebbe funzionare:

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

(Non funzionerà con alberi di espressione in quanto ha un corpo dichiarazione vedere paragrafo 4.6. . delle specifiche C# 3.0 per maggiori dettagli)

Answer 3

Questo dovrebbe funzionare:

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

Answer 4

Non capisco perché è necessario un metodo DoNothing.

non puoi semplicemente fare:

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

Answer 5

Questa è una vecchia questione, ma ho pensato di aggiungere un po 'di codice che ho trovato utile per questo tipo di situazione. Ho una classe Actions statica e una classe statica Functions con alcune funzioni di base in loro:

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

Credo che questo aiuta a migliorare la leggibilità solo un po ':

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

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