தொடரியல்:
- லாம்ப்டா வெளிப்பாடு: (அளவுருக்கள்) => வெளிப்பாடு
- லாம்ப்டா அறிக்கை: {நிபந்தனை அறிக்கை1 அறிக்கை2 …}
எடுத்துக்காட்டு 1:
ஐந்து சரங்களைக் கொண்ட 'உரங்கள்' பட்டியலை உருவாக்கவும். பட்டியலிலிருந்து அனைத்து சரங்களையும் வழங்கும் லாம்ப்டா வெளிப்பாட்டைப் பயன்படுத்தவும்.
பயன்படுத்தி அமைப்பு ;பயன்படுத்தி System.Linq ;
பயன்படுத்தி அமைப்பு.தொகுப்புகள்.பொது ;
வர்க்கம் LambdaExpression உதாரணம் {
நிலையான பொது வெற்றிடமானது முக்கிய ( )
{
// உரங்களின் பட்டியலை உருவாக்கவும்
உரங்களைப் பட்டியலிடுங்கள் = புதிய பட்டியல் ( ) ;
உரங்கள் . கூட்டு ( 'யூரியா' ) ;
உரங்கள் . கூட்டு ( 'நைட்ரஜன்' ) ;
உரங்கள் . கூட்டு ( 'பொட்டாசியம்' ) ;
உரங்கள் . கூட்டு ( 'டி-அம்மோனியம் பாஸ்பேட்' ) ;
உரங்கள் . கூட்டு ( 'பாஸ்பரஸ்' ) ;
// அனைத்து உரங்களையும் தேர்ந்தெடுக்க LambdaExpression ஐப் பயன்படுத்தவும்
இருந்தது விளைவாக = உரங்கள் . தேர்ந்தெடு ( inp1 => inp1 ) ;
ஒவ்வொரு ( இருந்தது நான் உள்ளே விளைவாக )
{
பணியகம் . ரைட்லைன் ( நான் ) ;
}
}
}
வெளியீடு:
விளக்கம்:
1. 'உரங்கள்' என்று பெயரிடப்பட்ட சரம் வகை பட்டியலை உருவாக்கவும். இந்த பட்டியலில் ஐந்து சரங்களைச் சேர்க்கவும்.
2. அனைத்து உரங்களையும் தேர்ந்தெடுக்க லாம்ப்டா வெளிப்பாடு பயன்படுத்தவும். இங்கே, வெளிப்பாடு 'தேர்ந்தெடு' ஆபரேட்டருடன் பயன்படுத்தப்படுகிறது. வெளிப்பாடு ஆகும் inp1 => inp1. பின்னர், லாம்ப்டா வெளிப்பாடு மூலம் திரும்பிய சரங்களைக் காட்ட 'ஃபோர்ச்' லூப்பைப் பயன்படுத்துகிறோம்.
எடுத்துக்காட்டு 2:
'பாஸ்பேட்' அடங்கிய உரங்களைத் தேர்ந்தெடுக்க லாம்ப்டா வெளிப்பாட்டைப் பயன்படுத்தவும்.
பயன்படுத்தி அமைப்பு ;பயன்படுத்தி System.Linq ;
பயன்படுத்தி அமைப்பு.தொகுப்புகள்.பொது ;
வர்க்கம் LambdaExpression உதாரணம் {
நிலையான பொது வெற்றிடமானது முக்கிய ( )
{
// உரங்களின் பட்டியலை உருவாக்கவும்
உரங்களைப் பட்டியலிடுங்கள் = புதிய பட்டியல் ( ) ;
உரங்கள் . கூட்டு ( 'யூரியா' ) ;
உரங்கள் . கூட்டு ( 'நைட்ரஜன்' ) ;
உரங்கள் . கூட்டு ( 'ஆர்த்தோ - பாஸ்பேட்' ) ;
உரங்கள் . கூட்டு ( 'டி-அம்மோனியம் பாஸ்பேட்' ) ;
உரங்கள் . கூட்டு ( 'பாஸ்பரஸ்' ) ;
// 'பாஸ்பேட்' உள்ளிட்ட உரங்களைத் தேர்ந்தெடுக்க LambdaExpression ஐப் பயன்படுத்தவும்
இருந்தது விளைவாக = உரங்கள் . எங்கே ( inp1 => inp1 . கொண்டுள்ளது ( 'பாஸ்பேட்' ) ) ;
ஒவ்வொரு ( இருந்தது நான் உள்ளே விளைவாக )
{
பணியகம் . ரைட்லைன் ( நான் ) ;
}
}
}
வெளியீடு:
அவற்றில் 'பாஸ்பேட்' அடங்கிய இரண்டு சரங்கள் உள்ளன.
விளக்கம்:
1. 'உரங்கள்' என்று பெயரிடப்பட்ட சரம் வகை பட்டியலை உருவாக்கவும். இந்த பட்டியலில் ஐந்து சரங்களைச் சேர்க்கவும்.
2. இங்கே, வெளிப்பாடு 'எங்கே' ஆபரேட்டருடன் பயன்படுத்தப்படுகிறது. வெளிப்பாடு ஆகும் inp1 => inp1. கொண்டிருக்கிறது('பாஸ்பேட்'). பின்னர், லாம்ப்டா வெளிப்பாடு மூலம் திரும்பிய சரங்களைக் காட்ட 'ஃபோர்ச்' லூப்பைப் பயன்படுத்துகிறோம்.
எடுத்துக்காட்டு 3:
மூன்று ஆர்டர்களைக் கொண்ட ஒரு பட்டியலை (order_quantity) வைத்திருப்போம். ஒவ்வொரு ஆர்டருக்கும் 5ஐச் சேர்க்க லாம்ப்டா எக்ஸ்பிரஷனைக் குறிப்பிடவும்.
பயன்படுத்தி அமைப்பு ;பயன்படுத்தி System.Linq ;
பயன்படுத்தி அமைப்பு.தொகுப்புகள்.பொது ;
வர்க்கம் LambdaExpression உதாரணம் {
நிலையான பொது வெற்றிடமானது முக்கிய ( )
{
// அளவுகளின் பட்டியலை உருவாக்கவும்
பட்டியல் வரிசை_அளவு = புதிய பட்டியல் ( ) ;
ஒழுங்கு_அளவு . கூட்டு ( 5 ) ;
ஒழுங்கு_அளவு . கூட்டு ( 7 ) ;
ஒழுங்கு_அளவு . கூட்டு ( 8 ) ;
// ஒவ்வொரு ஆர்டருக்கும் 5க்கு LambdaExpression ஐப் பயன்படுத்தவும்.
இருந்தது விளைவாக = ஒழுங்கு_அளவு . தேர்ந்தெடு ( inp1 => inp1 + 5 ) ;
ஒவ்வொரு ( இருந்தது நான் உள்ளே விளைவாக )
{
பணியகம் . ரைட்லைன் ( நான் ) ;
}
}
}
வெளியீடு:
[5,7,8] பட்டியல் [10,12,13] ஆக மாற்றப்பட்டது.
விளக்கம்:
1. முழு எண் வகையின் அளவுகளின் பட்டியலை உருவாக்கவும்.
2. நாங்கள் முதலில் ஆர்டர்களைத் தேர்ந்தெடுத்து ஒவ்வொரு ஆர்டருக்கும் 5 ஐச் சேர்க்கிறோம். எனவே, 'தேர்ந்தெடு' ஆபரேட்டர் பயன்படுத்தப்படுகிறது. வெளிப்பாடு ஆகும் inp1 => inp1 + 5.
எடுத்துக்காட்டு 4:
நிகழ்வு வகையின் பட்டியல் தரவு மூலத்தை உருவாக்கவும் (மூன்று பண்புக்கூறுகளுடன் - Event_Name, Event_Status மற்றும் Event_Budget) மற்றும் 5000 ஐ விட அதிகமாக இருக்கும் Event_Budget மூலம் பதிவுகளை வழங்கவும்.
பயன்படுத்தி அமைப்பு ;பயன்படுத்தி System.Linq ;
பயன்படுத்தி அமைப்பு.தொகுப்புகள்.பொது ;
// 5 நிகழ்வுகளுடன் 'Event_Source' என்ற வகுப்பை உருவாக்கவும்.
பொது வர்க்கம் நிகழ்வு_மூலம்
{
பொது நிலையான வெற்றிடமானது முக்கிய ( )
{
// நிகழ்வு பட்டியல்
IList நிகழ்வுகள் = புதிய பட்டியல் ( ) {
புதிய நிகழ்வு ( ) { நிகழ்வு_பெயர் = 'தொழில்நுட்ப முகாம்' ,நிகழ்வு_நிலை = 'திட்டமிடப்பட்டது' ,நிகழ்வு_பட்ஜெட் = 10000 } ,
புதிய நிகழ்வு ( ) { நிகழ்வு_பெயர் = 'சந்தைப்படுத்தல் முகாம்' ,நிகழ்வு_நிலை = 'நிறைவு' ,நிகழ்வு_பட்ஜெட் = 5000 } ,
புதிய நிகழ்வு ( ) { நிகழ்வு_பெயர் = 'மற்றவை' ,நிகழ்வு_நிலை = 'திட்டமிடப்பட்டது' ,நிகழ்வு_பட்ஜெட் = 1000 } ,
புதிய நிகழ்வு ( ) { நிகழ்வு_பெயர் = 'அரசியல்' ,நிகழ்வு_நிலை = 'திட்டமிடப்பட்டது' ,நிகழ்வு_பட்ஜெட் = 13000 } ,
புதிய நிகழ்வு ( ) { நிகழ்வு_பெயர் = 'நிதி' ,நிகழ்வு_நிலை = 'நிறைவு' ,நிகழ்வு_பட்ஜெட் = 20000 } ,
} ;
//நிகழ்வு_பட்ஜெட் 5000க்கு மேல்.
இருந்தது விளைவாக = நிகழ்வுகள் . எங்கே ( inp1 => inp1 . நிகழ்வு_பட்ஜெட் > 5000 ) ;
ஒவ்வொரு ( இருந்தது நான் உள்ளே விளைவாக ) {
பணியகம் . ரைட்லைன் ( 'NAME:' + நான் . நிகழ்வு_பெயர் + 'நிலை:' + நான் . நிகழ்வு_நிலை + 'பட்ஜெட்:' + நான் . நிகழ்வு_பட்ஜெட் ) ;
}
}
}
பொது வர்க்கம் நிகழ்வு {
பொது லேசான கயிறு நிகழ்வு_பெயர் { பெறு ; அமைக்கப்பட்டது ; }
பொது லேசான கயிறு நிகழ்வு_நிலை { பெறு ; அமைக்கப்பட்டது ; }
பொது முழு எண்ணாக நிகழ்வு_பட்ஜெட் { பெறு ; அமைக்கப்பட்டது ; }
}
வெளியீடு:
'நிகழ்வுகள்' பட்டியலில் 5000க்கும் அதிகமான நிகழ்வு_பட்ஜெட் கொண்ட மூன்று பதிவுகள் உள்ளன.
விளக்கம்:
1. முதலில், மூன்று பண்புக்கூறுகளுடன் 'நிகழ்வு' வகுப்பை உருவாக்குகிறோம்.
2. பிறகு, ஐந்து நிகழ்வுகளின் பட்டியலை உருவாக்குகிறோம்.
3. பயன்படுத்தி inp1 => inp1.Event_Budget > 5000 lambda வெளிப்பாடு, நாங்கள் 5000 க்கும் அதிகமான நிகழ்வு_பட்ஜெட் கொண்ட பதிவுகளைத் தேர்ந்தெடுக்கிறோம்.
எடுத்துக்காட்டு 5:
முந்தைய குறியீட்டைப் பயன்படுத்தி, லாம்ப்டா வெளிப்பாட்டை மாற்றவும். நிகழ்வுகளை 'முகாம்' என்று முடிவடையும் நிகழ்வு_பெயருடன் மற்றும் 'திட்டமிடப்பட்ட' நிகழ்வு_நிலையுடன் திரும்பவும்.
//Lambda Expression - Event_Name 'Camp' என்று முடிவடைகிறது மற்றும் Event_Status 'திட்டமிடப்பட்டது'.இருந்தது விளைவாக = நிகழ்வுகள் . எங்கே ( inp1 => inp1 . நிகழ்வு_பெயர் . உடன் முடிகிறது ( 'முகாம்' ) && inp1 . நிகழ்வு_நிலை == 'திட்டமிடப்பட்டது' ) ;
ஒவ்வொரு ( இருந்தது நான் உள்ளே விளைவாக ) {
பணியகம் . ரைட்லைன் ( 'NAME:' + நான் . நிகழ்வு_பெயர் + 'நிலை:' + நான் . நிகழ்வு_நிலை + 'பட்ஜெட்:' + நான் . நிகழ்வு_பட்ஜெட் ) ;
}
வெளியீடு:
இரண்டு நிபந்தனைகளையும் பூர்த்தி செய்யும் ஒரே ஒரு பதிவு மட்டுமே உள்ளது.
விளக்கம்:
இங்கே, லாம்ப்டா வெளிப்பாட்டில் இரண்டு நிபந்தனைகளைக் குறிப்பிடுகிறோம். && (மற்றும்) ஆபரேட்டர் இரண்டு நிபந்தனைகளை உண்மையாக மாற்ற பயன்படுகிறது. கொடுக்கப்பட்ட சரத்துடன் ஒரு சரம் முடிவடைகிறதா என்பதைச் சரிபார்க்க முதல் நிபந்தனை EndsWith() முறையைப் பயன்படுத்துகிறது. இரண்டு மதிப்புகளும் சமமாக உள்ளதா இல்லையா என்பதைச் சரிபார்க்க இரண்டாவது நிபந்தனை “ஒப்பீடு” ஆபரேட்டரை (==) பயன்படுத்துகிறது.
முடிவுரை
C# இல், லாம்ப்டா வெளிப்பாடு வெளிப்பாடுகள்/நிபந்தனை அறிக்கைகளை பெயரில்லாமல் அதன் உடலாக எடுத்துக்கொள்கிறது. அளவுருக்களை நாம் குறிப்பிட வேண்டும். பின்னர், வெளிப்பாடுகள் அதற்கு ஒதுக்கப்படுகின்றன. அடிப்படையில், கொடுக்கப்பட்ட தரவு மூலத்திலிருந்து பதிவுகளை வடிகட்டவும், உறுப்புகளை மாற்றவும், தரவு மூல/வரிசையிலிருந்து உறுப்புகளைத் தேர்ந்தெடுக்கவும் இவை பயன்படுத்தப்படுகின்றன. இந்த வழிகாட்டியில், லாம்ப்டா வெளிப்பாட்டைப் பயன்படுத்தி உறுப்புகளைத் தேர்ந்தெடுக்கும், வடிகட்ட மற்றும் மாற்றும் ஐந்து வெவ்வேறு எடுத்துக்காட்டுகளைப் பற்றி நாங்கள் விவாதித்தோம்.