जंजीर LINQ एक्सटेंशन विधि कॉल में 'लेट' कीवर्ड के बराबर कोड

Question

C # कंपाइलर क्वेरी कॉम्प्रिहेंशन फीचर्स का उपयोग करके, आप कोड को इस तरह लिख सकते हैं:

var names = new string[] { "Dog", "Cat", "Giraffe", "Monkey", "Tortoise" };
var result =
    from animalName in names
    let nameLength = animalName.Length
    where nameLength > 3
    orderby nameLength
    select animalName; 

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

LINQ एक्सटेंशन मेथड कॉल्स के समतुल्य सेट क्या है जो यह बताता है कि "लेट" कीवर्ड यहाँ क्या करता है?

Comments

FYI करें, C # 3.0 विनिर्देश एक्सक्लूसिव विस्तार में प्रत्येक क्वेरी कॉम्प्रिहेंशन ट्रांसलेशन नियम की व्याख्या करता है।

— एरिक लिपर्ट

और जो लोग भारी जा रहा है कल्पना के लिए, गहराई में जॉन स्कीट के सी # इसे भी शामिल करता है;

— मार्क ग्रेवेल

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

— ओलिवियर जैकोट-डेसकोम्बे

Answer 1

चलो अपना खुद का ऑपरेशन नहीं है; यह गुल्लक-पीठ से निकलता हैSelect । यदि आप "परावर्तक" का उपयोग किसी मौजूदा dll को अलग करने के लिए कर सकते हैं, तो आप इसे देख सकते हैं।

यह कुछ इस तरह होगा:

var result = names
        .Select(animalName => new { nameLength = animalName.Length, animalName})
        .Where(x=>x.nameLength > 3)
        .OrderBy(x=>x.nameLength)
        .Select(x=>x.animalName);

Comments

वाह, मुझे नहीं पता था कि आप उस तरह के नए ऑपरेटर का उपयोग करके ऑटोएन्कैप्सुलेट कर सकते हैं।

— डेविड फेफर

यदि आप किसी क्वेरी के साथ प्रारंभ करते हैं, तो उत्पन्न कोड को देखने के लिए आप LinqPad के परिणाम फलक में छोटे "लैम्ब्डा" बटन का उपयोग कर सकते हैं । दूसरे शब्दों में, यदि आप अपनी पहली पंक्ति को var name = new string [] {"Dog", ...} .AsQueryable () में बदलते हैं; फिर LinqPad में पूरी चीज़ चलाएं, थोड़ा लैम्ब्डा बटन पर क्लिक करें, आपको मार्क के उत्तर के समान उत्पन्न कोड दिखाई देगा।

— रेब.किनब

.Dump()परिणामी मेमने को देखने के लिए मुझे LinqPad में विस्तार विधि का उपयोग करने की आवश्यकता थी ।

— justanotherdev 7

Answer 2

यहाँ एक अच्छा लेख है

अनिवार्य रूप letसे एक अनाम टपल बनाता है। यह इसके बराबर है:

var result = names.Select(
  animal => new { animal = animal, nameLength = animal.Length })
.Where(x => x.nameLength > 3)
.OrderBy(y => y.nameLength)
.Select(z => z.animal);

Comments

मैं ऊपर के लेख को उद्धृत करता हूंit seems prudent to recommend against using the let keyword in cases where you do not need to transform a variable

— जेबी। मोनिका के साथ।

मैं इसे आगे उद्धृत करता हूं:This could be considered a micro-optimisation

— मोनसिनगोर

Answer 3

System.Interactive में एक .Let विस्तार विधि भी है, लेकिन इसका उद्देश्य एक धाराप्रवाह अभिव्यक्ति में 'इन-लाइन' का मूल्यांकन करने के लिए एक लैम्ब्डा अभिव्यक्ति पेश करना है। उदाहरण के लिए, विचार करें (LinqPad में, कहते हैं) निम्न अभिव्यक्ति जो हर बार निष्पादित होने पर नए यादृच्छिक संख्याएं बनाती है:

var seq = EnumerableEx.Generate(
    new Random(),
    _ => true,
    _ => _,
    x => x.Next());

यह देखने के लिए कि नए यादृच्छिक नमूने हर बार दिखाई देते हैं, निम्नलिखित पर विचार करें

seq.Zip(seq, Tuple.Create).Take(3).Dump();

जो जोड़े पैदा करता है जिसमें बाएँ और दाएँ अलग होते हैं। ऐसे जोड़े उत्पन्न करने के लिए जिनमें बाएँ और दाएँ हमेशा समान होते हैं, कुछ ऐसा करें जैसे कि निम्नलिखित:

seq.Take(3).ToList().Let(xs => xs.Zip(xs, Tuple.Create)).Dump(); 

अगर हम सीधे लैंबडा एक्सप्रेशंस को आमंत्रित कर सकते हैं, तो हम लिख सकते हैं

(xs => xs.Zip(xs, Tuple.Create))(seq.Take(3).ToList()).Dump();

लेकिन हम लैम्ब्डा के भावों को प्रकट नहीं कर सकते हैं जैसे कि वे तरीके थे।

Answer 4

के बारे में जंजीर LINQ एक्सटेंशन विधि कॉल में 'लेट' कीवर्ड के बराबर कोड के में

उपरोक्त टिप्पणी अधिक मान्य नहीं है

var x = new List<int> { 2, 3, 4, 5, 6 }.AsQueryable();
(from val in x
let val1 = val
let val2 = val + 1
where val2 > val1
select val
).Dump();

पैदा करता है

System.Collections.Generic.List`1[System.Int32]
.Select(
  val =>
     new
     {
         val = val,
         val1 = val
     }
)
.Select(
  temp0 =>
     new
     {
         temp0 = temp0,
         val2 = (temp0.val + 1)
     }
)
.Where(temp1 => (temp1.val2 > temp1.temp0.val1))
.Select(temp1 => temp1.temp0.val)

इतने सारे letअब अनुकूलित कर रहे हैं