क्या एक "खाली" सी # लैंबडा अभिव्यक्ति को निर्दिष्ट करने का एक तरीका है?

Question

मैं एक "खाली" लैंबडा एक्सप्रेशन घोषित करना चाहता हूं जो करता है, ठीक है, कुछ भी नहीं। क्या DoNothing()विधि की आवश्यकता के बिना ऐसा कुछ करने का एक तरीका है ?

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

private void DoNothing()
{
}

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

ऐसा करने का मेरा इरादा केवल मेरे WPF कमांड की सक्षम / अक्षम स्थिति को नियंत्रित करता है, लेकिन यह एक तरफ है। हो सकता है कि यह मेरे लिए सुबह बहुत जल्दी हो, लेकिन मुझे लगता है कि एक ही तरह से x => DoNothing()लैम्ब्डा अभिव्यक्ति को घोषित करने का एक तरीका होना चाहिए ताकि एक ही चीज़ को पूरा किया जा सके:

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

क्या ऐसा करने का कोई तरीका है? यह सिर्फ एक गैर-विधि की आवश्यकता के लिए अनावश्यक लगता है।

Answer 1

Action doNothing = () => { };

Comments

क्या एक पूर्वनिर्धारित खाली लैम्ब्डा मौजूद है? मुझे लगता है कि हर बार जब मुझे इसकी जरूरत होती है तो एक खाली लंबोदा बनाने के लिए यह एक बुरा विचार है। जैसे JQuery में हैnoop और मैं C # में मौजूद होने के लिए कुछ इसी तरह की उम्मीद करूंगा।

— क़क़्क़्क़ाक़

तो क्या इस क्रिया का एक अनिवार्य संस्करण है Func<Task> doNothing = async() => await Task.CompletedTask;?

— पैट्रिक शाजापल्स्की

Answer 2

यह एक पुराना प्रश्न है, लेकिन मुझे लगा कि मैं इस प्रकार की स्थिति के लिए उपयोगी कुछ कोड जोड़ूंगा। मेरे पास एक Actionsस्थिर वर्ग और Functionsकुछ बुनियादी कार्यों के साथ एक स्थिर वर्ग है:

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

मेरा मानना ​​है कि यह सिर्फ एक छोटे से पठनीयता में सुधार करने में मदद करता है:

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

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

Answer 3

यह काम करना चाहिए:

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

Answer 4

यह मानते हुए कि आपको केवल एक प्रतिनिधि (अभिव्यक्ति पेड़ के बजाय) की आवश्यकता है तो यह काम करना चाहिए:

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

(यह अभिव्यक्ति पेड़ों के साथ काम नहीं करेगा क्योंकि यह एक विवरण निकाय है । अधिक जानकारी के लिए C # 3.0 कल्पना की धारा 4.6 देखें।)

Answer 5

मुझे पूरी तरह से समझ नहीं आ रहा है कि आपको DoNothing पद्धति की आवश्यकता क्यों है।

क्या आप ऐसा नहीं कर सकते:

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

Comments

कि शायद जाँच की है और शायद एक एनआरई फेंक देंगे।

— १०:५०

मुझे लगता है कि Dykam सही है, लेकिन मैं सिर्फ null पास करने के बारे में नहीं सोचता था :-)

— Rob

मुझे समझ नहीं आ रहा है कि यह क्यों अस्वीकृत है? जॉर्ज एक वैध बिंदु बनाता है, हालांकि इसे जाँचने का एक छोटा सा प्रयास होता।

— कोहेन

+1, यह एक वैध समाधान है, बस यह है कि अशक्त जाँच को बढ़ाया जाना चाहिए new RelayCommand(..।

— नवफाल