पैराम [] लैम्बडा अभिव्यक्ति के लिए पैरामीटर हो सकता है?

Question

मैंने हाल ही में लैम्ब्डा अभिव्यक्तियों की खोज शुरू कर दी है, और एक प्रश्न दिमाग में आया। मान लें कि मेरे पास एक ऐसा फ़ंक्शन है जिसके लिए पैरामीटर की अनिश्चित संख्या की आवश्यकता है। मैं पैरामीटर कीवर्ड का उपयोग पैरामीटर की चर संख्या को मॉडल करने के लिए करता हूं।

मेरा प्रश्न: मैं लैम्ब्डा भाव के साथ कुछ ऐसा ही कर सकता है? उदाहरण के लिए:

Func<int[], int> foo = (params numbers[]) => 
         { 
          int result; 

          foreach(int number in numbers) 
          { 
           result += numbers; 
          } 

          return result; 
         } 

यदि हां, दो उप सवाल खुद को प्रस्तुत करते - वहाँ एक 'अच्छा' जिस तरह से इस तरह के एक अभिव्यक्ति लिखने के लिए है, और मैं भी कुछ बिंदु पर इस तरह एक अभिव्यक्ति लिखना चाहते हैं?

Answer 1

ठीक है, तरह। पहले, बजाय Func<> का उपयोग कर के, आप एक कस्टम प्रतिनिधि निर्धारित करना होगा: फिर

public delegate int ParamsFunc (params int[] numbers); 

, आप एक निम्नलिखित लैम्ब्डा लिख ​​सकते हैं:

ParamsFunc sum = p => p.Sum(); 

और तर्कों की चर संख्या के साथ यह आह्वान:

Console.WriteLine(sum(1, 2, 3)); 
Console.WriteLine(sum(1, 2, 3, 4)); 
Console.WriteLine(sum(1, 2, 3, 4, 5)); 

लेकिन ईमानदार होने के लिए, यह Func<> प्रतिनिधियों के साथ चिपकने के लिए वास्तव में अधिक सरल है।

Answer 2

निकटतम बात मुझे लगता है कि आप कुछ इस तरह किया जाएगा प्राप्त कर सकते हैं:

Func<int[], int> foo = numbers[] => 
         { 
          // logic... 
         } 

var result = foo(Params.Get(1, 5, 4, 4, 36, 321, 21, 2, 0, -4)); 

और है:

public static class Params 
{ 
    public static T[] Get(params T[] arr) 
    { 
     return arr; 
    } 
} 

लेकिन मुझे लगता है कि कैसे एक साधारण new[] {1, 5, 4, 4, ...}

धड़कता नहीं देख सकते हैं

Answer 3

यहां दो चीजें हैं, Func<int[], int> एलएचएस पर जेनेरिक प्रतिनिधि और आरएचएस पर लैम्ब्डा अभिव्यक्ति।

public delegate TResult Func<in T, out TResult>(T arg); //ie no params involved 

आप अपनी खुद की प्रतिनिधि है कि params इनपुट के रूप में स्वीकार किए जाते हैं जवाब में दिखाया गया है स्वीकार करता है की जरूरत है: पूर्व के बाद से एक Func<S, T> प्रतिनिधि की तरह घोषित किया जाता है, संभव नहीं है।

उत्तरार्द्ध, जो सवाल शीर्षक है, सी #, में भी संभव नहीं है, लेकिन किसी कारण से।

एक काम अभिव्यक्ति की एलएचएस एक संकलन समय बात (जब तक यह निश्चित रूप से dynamic है, लेकिन फिर संकलक इसके बारे में पता है) है और इसकी आरएचएस एक रन समय बात (const रों के मामले में निश्चित रूप से जब तक) है। संकलक एलएचएस पर जो टाइप किया गया है उसका अनुमान लगा सकता है, लेकिन यह केवल रन टाइम के दौरान आरएचएस पर मूल्य प्राप्त करता है, यानी जब कोड चलाया जाता है। जब आप यह टाइप करें:

Func<int[], int> foo = .... 

foo हमेशा Func<int[], int> के रूप में माना जाता है। यदि यह आरएचएस को समझना था तो यह कंपाइलर को बहुत जटिलता जोड़ देगा। उदाआप क्या संभव था प्रयास कर रहे हैं, इस परिदृश्य के बारे में सोचना:

Func<int[], int> foo = (params int[] numbers) => 
        { 
         int result; 

         foreach(int number in numbers) 
         { 
          result += numbers; 
         } 

         return result; 
        }; 

//and later at some other place 
foo = (int[] numbers) => 0; 

//how would you call 'foo' now? 

इसके बजाय जब आप अपने खुद के प्रतिनिधि कि params स्वीकार करता है, आप संकलक सीधे कह रहे हैं (यानी एलएचएस से जाना जाता है) लिखें।

तीन सुविधाओं का

है कि एक नामित विधि समर्थन के मापदंडों, यानी, out/ref, params, वैकल्पिक पैरामीटर, लैम्ब्डा भाव (या उससे भी पहले delegate सिंटेक्स) समर्थन केवल out/ref।