वाक्य - विन्यास:
- लैम्ब्डा अभिव्यक्ति: (पैरामीटर) => अभिव्यक्ति
- लैम्ब्डा कथन: {सशर्त कथन1 कथन2… }
उदाहरण 1:
'उर्वरक' सूची बनाएं जिसमें पाँच तार हों। लैम्ब्डा एक्सप्रेशन का उपयोग करें जो सूची से सभी स्ट्रिंग्स लौटाता है।
का उपयोग करते हुए प्रणाली ;का उपयोग करते हुए सिस्टम.लिंक ;
का उपयोग करते हुए सिस्टम.संग्रह.जेनेरिक ;
कक्षा लैम्ब्डा एक्सप्रेशन उदाहरण {
स्थिर जनता खालीपन मुख्य ( )
{
// उर्वरकों की सूची बनाएं
उर्वरकों की सूची बनाएं = नया सूची ( ) ;
उर्वरक . जोड़ना ( 'यूरिया' ) ;
उर्वरक . जोड़ना ( 'नाइट्रोजन' ) ;
उर्वरक . जोड़ना ( 'पोटैशियम' ) ;
उर्वरक . जोड़ना ( 'डाइ-अमोनियम फॉस्फेट' ) ;
उर्वरक . जोड़ना ( 'फास्फोरस' ) ;
// सभी उर्वरकों का चयन करने के लिए LambdaExpression का उपयोग करें
था परिणाम = उर्वरक . चुनना ( inp1 => inp1 ) ;
प्रत्येक के लिए ( था मैं में परिणाम )
{
सांत्वना देना . पंक्ति लिखो ( मैं ) ;
}
}
}
आउटपुट:
व्याख्या:
1. 'उर्वरक' नामक स्ट्रिंग प्रकार की सूची बनाएं। इस सूची में पाँच तार जोड़ें।
2. सभी उर्वरकों का चयन करने के लिए लैम्ब्डा अभिव्यक्ति का उपयोग करें। यहां, अभिव्यक्ति का उपयोग 'Select' ऑपरेटर के साथ किया जाता है। अभिव्यक्ति है inp1 => inp1. फिर, हम लैम्ब्डा अभिव्यक्ति द्वारा लौटाए गए स्ट्रिंग्स को प्रदर्शित करने के लिए 'foreach' लूप का उपयोग करते हैं।
उदाहरण 2:
उन उर्वरकों का चयन करने के लिए लैम्ब्डा अभिव्यक्ति का उपयोग करें जिनमें 'फॉस्फेट' शामिल है।
का उपयोग करते हुए प्रणाली ;का उपयोग करते हुए सिस्टम.लिंक ;
का उपयोग करते हुए सिस्टम.संग्रह.जेनेरिक ;
कक्षा लैम्ब्डा एक्सप्रेशन उदाहरण {
स्थिर जनता खालीपन मुख्य ( )
{
// उर्वरकों की सूची बनाएं
उर्वरकों की सूची बनाएं = नया सूची ( ) ;
उर्वरक . जोड़ना ( 'यूरिया' ) ;
उर्वरक . जोड़ना ( 'नाइट्रोजन' ) ;
उर्वरक . जोड़ना ( 'ऑर्थो-फॉस्फेट' ) ;
उर्वरक . जोड़ना ( 'डाइ-अमोनियम फॉस्फेट' ) ;
उर्वरक . जोड़ना ( 'फास्फोरस' ) ;
// उन उर्वरकों का चयन करने के लिए LambdaExpression का उपयोग करें जिनमें शामिल हैं - 'फॉस्फेट'
था परिणाम = उर्वरक . कहाँ ( inp1 => inp1 . रोकना ( 'फॉस्फेट' ) ) ;
प्रत्येक के लिए ( था मैं में परिणाम )
{
सांत्वना देना . पंक्ति लिखो ( मैं ) ;
}
}
}
आउटपुट:
इसमें दो तार हैं जिनमें 'फॉस्फेट' शामिल है।
व्याख्या:
1. 'उर्वरक' नामक स्ट्रिंग प्रकार की एक सूची बनाएं। इस सूची में पाँच तार जोड़ें।
2. यहां, अभिव्यक्ति का उपयोग 'कहां' ऑपरेटर के साथ किया गया है। अभिव्यक्ति है inp1 => inp1.Contains(“फॉस्फेट”)। फिर, हम लैम्ब्डा अभिव्यक्ति द्वारा लौटाए गए स्ट्रिंग्स को प्रदर्शित करने के लिए 'foreach' लूप का उपयोग करते हैं।
उदाहरण 3:
आइए एक सूची (ऑर्डर_क्वांटिटी) बनाएं जिसमें तीन ऑर्डर हों। प्रत्येक क्रम में 5 जोड़ने के लिए लैम्ब्डा अभिव्यक्ति निर्दिष्ट करें।
का उपयोग करते हुए प्रणाली ;का उपयोग करते हुए सिस्टम.लिंक ;
का उपयोग करते हुए सिस्टम.संग्रह.जेनेरिक ;
कक्षा लैम्ब्डा एक्सप्रेशन उदाहरण {
स्थिर जनता खालीपन मुख्य ( )
{
// मात्राओं की सूची बनाएं
सूची क्रम_मात्रा = नया सूची ( ) ;
आदेश की मात्रा . जोड़ना ( 5 ) ;
आदेश की मात्रा . जोड़ना ( 7 ) ;
आदेश की मात्रा . जोड़ना ( 8 ) ;
// प्रत्येक ऑर्डर के लिए 5 तक LambdaExpression का उपयोग करें।
था परिणाम = आदेश की मात्रा . चुनना ( inp1 => inp1 + 5 ) ;
प्रत्येक के लिए ( था मैं में परिणाम )
{
सांत्वना देना . पंक्ति लिखो ( मैं ) ;
}
}
}
आउटपुट:
[5,7,8] सूची को [10,12,13] में बदल दिया गया है।
व्याख्या:
1. पूर्णांक प्रकार की मात्राओं की सूची बनाएं।
2. हम पहले ऑर्डर चुनते हैं और फिर प्रत्येक ऑर्डर में 5 जोड़ते हैं। तो, 'Select' ऑपरेटर का उपयोग किया जाता है। अभिव्यक्ति है inp1 => inp1 + 5.
उदाहरण 4:
इवेंट प्रकार का एक सूची डेटा स्रोत बनाएं (तीन विशेषताओं के साथ - इवेंट_नाम, इवेंट_स्टेटस और इवेंट_बजट) और इवेंट_बजट के साथ रिकॉर्ड लौटाएं जो 5000 से अधिक है।
का उपयोग करते हुए प्रणाली ;का उपयोग करते हुए सिस्टम.लिंक ;
का उपयोग करते हुए सिस्टम.संग्रह.जेनेरिक ;
// 5 इवेंट के साथ - 'Event_Source' नाम से एक क्लास बनाएं।
जनता कक्षा घटना_स्रोत
{
जनता स्थिर खालीपन मुख्य ( )
{
// घटना सूची
आईलिस्ट इवेंट = नया सूची ( ) {
नया आयोजन ( ) { घटना नाम = 'तकनीकी शिविर' ,घटना_स्थिति = 'योजनाबद्ध' ,इवेंट_बजट = 10000 } ,
नया आयोजन ( ) { घटना नाम = 'विपणन शिविर' ,घटना_स्थिति = 'पुरा होना' ,इवेंट_बजट = 5000 } ,
नया आयोजन ( ) { घटना नाम = 'अन्य' ,घटना_स्थिति = 'योजनाबद्ध' ,इवेंट_बजट = 1000 } ,
नया आयोजन ( ) { घटना नाम = 'राजनीति' ,घटना_स्थिति = 'योजनाबद्ध' ,इवेंट_बजट = 13000 } ,
नया आयोजन ( ) { घटना नाम = 'वित्त' ,घटना_स्थिति = 'पुरा होना' ,इवेंट_बजट = 20000 } ,
} ;
//इवेंट_बजट 5000 से अधिक।
था परिणाम = आयोजन . कहाँ ( inp1 => inp1 . इवेंट_बजट > 5000 ) ;
प्रत्येक के लिए ( था मैं में परिणाम ) {
सांत्वना देना . पंक्ति लिखो ( 'नाम: ' + मैं . घटना नाम + ' दर्जा: ' + मैं . घटना_स्थिति + ' बजट: ' + मैं . इवेंट_बजट ) ;
}
}
}
जनता कक्षा आयोजन {
जनता डोरी घटना नाम { पाना ; तय करना ; }
जनता डोरी घटना_स्थिति { पाना ; तय करना ; }
जनता int यहाँ इवेंट_बजट { पाना ; तय करना ; }
}
आउटपुट:
इवेंट_बजट 5000 से अधिक के साथ 'इवेंट' सूची में तीन रिकॉर्ड हैं।
व्याख्या:
1. सबसे पहले, हम तीन विशेषताओं के साथ एक 'इवेंट' क्लास बनाते हैं।
2. फिर, हम पाँच घटनाओं की एक सूची बनाते हैं।
3. का उपयोग करना inp1 => inp1.Event_Budget > 5000 लैम्ब्डा एक्सप्रेशन, हम 5000 से अधिक इवेंट_बजट वाले रिकॉर्ड का चयन करते हैं।
उदाहरण 5:
पिछले कोड का उपयोग करें और लैम्ब्डा एक्सप्रेशन बदलें। इवेंट को उस इवेंट_नाम के साथ लौटाएं जो 'कैंप' पर समाप्त होता है और इवेंट_स्टेटस के साथ जो 'योजनाबद्ध' है।
//लैम्ब्डा अभिव्यक्ति - इवेंट_नाम 'कैंप' के साथ समाप्त होता है और इवेंट_स्टेटस 'योजनाबद्ध' होता है।था परिणाम = आयोजन . कहाँ ( inp1 => inp1 . घटना नाम . इसी के साथ समाप्त होता है ( 'शिविर' ) && inp1 . घटना_स्थिति == 'योजनाबद्ध' ) ;
प्रत्येक के लिए ( था मैं में परिणाम ) {
सांत्वना देना . पंक्ति लिखो ( 'नाम: ' + मैं . घटना नाम + ' दर्जा: ' + मैं . घटना_स्थिति + ' बजट: ' + मैं . इवेंट_बजट ) ;
}
आउटपुट:
केवल एक ही रिकॉर्ड है जो दोनों शर्तों को पूरा करता है।
व्याख्या:
यहां, हम लैम्ब्डा अभिव्यक्ति में दो शर्तें निर्दिष्ट करते हैं। && (and) ऑपरेटर का उपयोग दो स्थितियों को सत्य बनाने के लिए किया जाता है। पहली शर्त यह जांचने के लिए EndsWith() विधि का उपयोग करती है कि कोई स्ट्रिंग दिए गए स्ट्रिंग के साथ समाप्त होती है या नहीं। दूसरी शर्त यह जांचने के लिए 'तुलना' ऑपरेटर (==) का उपयोग करती है कि दोनों मान समान हैं या नहीं।
निष्कर्ष
C# में, लैम्ब्डा अभिव्यक्ति अभिव्यक्ति/सशर्त कथनों को बिना नाम के अपने मुख्य भाग के रूप में लेती है। हमें पैरामीटर निर्दिष्ट करने की आवश्यकता है। फिर, उसे अभिव्यक्तियाँ सौंपी जाती हैं। मूल रूप से, इनका उपयोग दिए गए डेटा स्रोत से रिकॉर्ड को फ़िल्टर करने, तत्वों को बदलने और डेटा स्रोत/अनुक्रम से तत्वों का चयन करने के लिए किया जाता है। इस गाइड में, हमने पांच अलग-अलग उदाहरणों पर चर्चा की जो लैम्ब्डा अभिव्यक्ति का उपयोग करके तत्वों का चयन, फ़िल्टर और परिवर्तन करते हैं।