సింటాక్స్:
- లాంబ్డా వ్యక్తీకరణ: (పారామితులు) => వ్యక్తీకరణ
- లాంబ్డా ప్రకటన: {షరతులతో కూడిన ప్రకటన1 ప్రకటన2 …}
ఉదాహరణ 1:
ఐదు తీగలను కలిగి ఉన్న 'ఎరువుల' జాబితాను సృష్టించండి. జాబితా నుండి అన్ని స్ట్రింగ్‌లను తిరిగి ఇచ్చే లాంబ్డా వ్యక్తీకరణను ఉపయోగించండి.
ఉపయోగించి వ్యవస్థ ;ఉపయోగించి System.Linq ;
ఉపయోగించి System.Collections.Generic ;
తరగతి లాంబ్డా ఎక్స్‌ప్రెషన్ ఉదాహరణ {
స్థిరమైన ప్రజా శూన్యం ప్రధాన ( )
{
// ఎరువుల జాబితాను రూపొందించండి
ఎరువులను జాబితా చేయండి = కొత్త జాబితా ( ) ;
ఎరువులు . జోడించు ( 'యూరియా' ) ;
ఎరువులు . జోడించు ( 'నత్రజని' ) ;
ఎరువులు . జోడించు ( 'పొటాషియం' ) ;
ఎరువులు . జోడించు ( 'డి-అమ్మోనియం ఫాస్ఫేట్' ) ;
ఎరువులు . జోడించు ( 'భాస్వరం' ) ;
// అన్ని ఎరువులను ఎంచుకోవడానికి LambdaExpression ఉపయోగించండి
ఉంది ఫలితం = ఎరువులు . ఎంచుకోండి ( inp1 => inp1 ) ;
ప్రతి ( ఉంది i లో ఫలితం )
{
కన్సోల్ . రైట్ లైన్ ( i ) ;
}
}
}
అవుట్‌పుట్:
వివరణ:
1. 'ఎరువులు' పేరుతో స్ట్రింగ్ రకం జాబితాను సృష్టించండి. ఈ జాబితాకు ఐదు స్ట్రింగ్‌లను జోడించండి.
2. అన్ని ఎరువులను ఎంచుకోవడానికి లాంబ్డా వ్యక్తీకరణను ఉపయోగించండి. ఇక్కడ, వ్యక్తీకరణ 'ఎంచుకోండి' ఆపరేటర్‌తో ఉపయోగించబడుతుంది. వ్యక్తీకరణ ఉంది inp1 => inp1. అప్పుడు, లాంబ్డా వ్యక్తీకరణ ద్వారా తిరిగి వచ్చే స్ట్రింగ్‌లను ప్రదర్శించడానికి మేము 'ఫోరీచ్' లూప్‌ని ఉపయోగిస్తాము.
ఉదాహరణ 2:
'ఫాస్ఫేట్'తో కూడిన ఎరువులను ఎంచుకోవడానికి లాంబ్డా వ్యక్తీకరణను ఉపయోగించండి.
ఉపయోగించి వ్యవస్థ ;ఉపయోగించి System.Linq ;
ఉపయోగించి System.Collections.Generic ;
తరగతి లాంబ్డా ఎక్స్‌ప్రెషన్ ఉదాహరణ {
స్థిరమైన ప్రజా శూన్యం ప్రధాన ( )
{
// ఎరువుల జాబితాను రూపొందించండి
ఎరువులను జాబితా చేయండి = కొత్త జాబితా ( ) ;
ఎరువులు . జోడించు ( 'యూరియా' ) ;
ఎరువులు . జోడించు ( 'నత్రజని' ) ;
ఎరువులు . జోడించు ( 'ఆర్తో - ఫాస్ఫేట్' ) ;
ఎరువులు . జోడించు ( 'డి-అమ్మోనియం ఫాస్ఫేట్' ) ;
ఎరువులు . జోడించు ( 'భాస్వరం' ) ;
// 'ఫాస్ఫేట్'తో కూడిన ఎరువులను ఎంచుకోవడానికి LambdaExpression ఉపయోగించండి
ఉంది ఫలితం = ఎరువులు . ఎక్కడ ( inp1 => inp1 . కలిగి ఉంది ( 'ఫాస్ఫేట్' ) ) ;
ప్రతి ( ఉంది i లో ఫలితం )
{
కన్సోల్ . రైట్ లైన్ ( i ) ;
}
}
}
అవుట్‌పుట్:
వాటిలో 'ఫాస్ఫేట్' కలిగి ఉన్న రెండు తీగలు ఉన్నాయి.
వివరణ:
1. 'ఎరువులు' పేరుతో స్ట్రింగ్ రకం జాబితాను సృష్టించండి. ఈ జాబితాకు ఐదు స్ట్రింగ్‌లను జోడించండి.
2. ఇక్కడ, వ్యక్తీకరణ 'ఎక్కడ' ఆపరేటర్‌తో ఉపయోగించబడుతుంది. వ్యక్తీకరణ ఉంది inp1 => inp1. కలిగి ఉంటుంది('ఫాస్ఫేట్'). అప్పుడు, లాంబ్డా వ్యక్తీకరణ ద్వారా తిరిగి వచ్చే స్ట్రింగ్‌లను ప్రదర్శించడానికి మేము 'ఫోరీచ్' లూప్‌ని ఉపయోగిస్తాము.
ఉదాహరణ 3:
మూడు ఆర్డర్‌లను కలిగి ఉన్న జాబితా (ఆర్డర్_క్వాంటిటీ)ని కలిగి ఉండండి. ప్రతి ఆర్డర్‌కు 5ని జోడించడానికి లాంబ్డా వ్యక్తీకరణను పేర్కొనండి.
ఉపయోగించి వ్యవస్థ ;ఉపయోగించి System.Linq ;
ఉపయోగించి System.Collections.Generic ;
తరగతి లాంబ్డా ఎక్స్‌ప్రెషన్ ఉదాహరణ {
స్థిరమైన ప్రజా శూన్యం ప్రధాన ( )
{
// పరిమాణాల జాబితాను సృష్టించండి
జాబితా ఆర్డర్_పరిమాణం = కొత్త జాబితా ( ) ;
ఆర్డర్_పరిమాణం . జోడించు ( 5 ) ;
ఆర్డర్_పరిమాణం . జోడించు ( 7 ) ;
ఆర్డర్_పరిమాణం . జోడించు ( 8 ) ;
// ప్రతి ఆర్డర్‌కు LambdaExpressionని 5కి ఉపయోగించండి.
ఉంది ఫలితం = ఆర్డర్_పరిమాణం . ఎంచుకోండి ( inp1 => inp1 + 5 ) ;
ప్రతి ( ఉంది i లో ఫలితం )
{
కన్సోల్ . రైట్ లైన్ ( i ) ;
}
}
}
అవుట్‌పుట్:
[5,7,8] జాబితా [10,12,13]కి రూపాంతరం చెందింది.
వివరణ:
1. పూర్ణాంకాల రకం పరిమాణాల జాబితాను సృష్టించండి.
2. మేము ముందుగా ఆర్డర్‌లను ఎంచుకుని, ఆపై ప్రతి ఆర్డర్‌కు 5ని జోడిస్తాము. కాబట్టి, 'ఎంచుకోండి' ఆపరేటర్ ఉపయోగించబడుతుంది. వ్యక్తీకరణ ఉంది inp1 => inp1 + 5.
ఉదాహరణ 4:
ఈవెంట్ రకం జాబితా డేటా మూలాన్ని సృష్టించండి (మూడు లక్షణాలతో – Event_Name, Event_Status మరియు Event_Budget) మరియు 5000 కంటే ఎక్కువ ఉన్న Event_Budgetతో రికార్డ్‌లను తిరిగి ఇవ్వండి.
ఉపయోగించి వ్యవస్థ ;ఉపయోగించి System.Linq ;
ఉపయోగించి System.Collections.Generic ;
// 5 ఈవెంట్‌లతో 'Event_Source' పేరుతో తరగతిని సృష్టించండి.
ప్రజా తరగతి ఈవెంట్_మూలం
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( )
{
// ఈవెంట్ జాబితా
IList సంఘటనలు = కొత్త జాబితా ( ) {
కొత్త ఈవెంట్ ( ) { ఈవెంట్_పేరు = 'సాంకేతిక శిబిరం' ,ఈవెంట్_స్థితి = 'ప్రణాళిక' ,ఈవెంట్_బడ్జెట్ = 10000 } ,
కొత్త ఈవెంట్ ( ) { ఈవెంట్_పేరు = 'మార్కెటింగ్ క్యాంప్' ,ఈవెంట్_స్థితి = 'పూర్తయింది' ,ఈవెంట్_బడ్జెట్ = 5000 } ,
కొత్త ఈవెంట్ ( ) { ఈవెంట్_పేరు = 'ఇతర' ,ఈవెంట్_స్థితి = 'ప్రణాళిక' ,ఈవెంట్_బడ్జెట్ = 1000 } ,
కొత్త ఈవెంట్ ( ) { ఈవెంట్_పేరు = 'రాజకీయం' ,ఈవెంట్_స్థితి = 'ప్రణాళిక' ,ఈవెంట్_బడ్జెట్ = 13000 } ,
కొత్త ఈవెంట్ ( ) { ఈవెంట్_పేరు = 'ఆర్థిక' ,ఈవెంట్_స్థితి = 'పూర్తయింది' ,ఈవెంట్_బడ్జెట్ = 20000 } ,
} ;
//Event_Budget 5000 కంటే ఎక్కువ.
ఉంది ఫలితం = సంఘటనలు . ఎక్కడ ( inp1 => inp1 . ఈవెంట్_బడ్జెట్ > 5000 ) ;
ప్రతి ( ఉంది i లో ఫలితం ) {
కన్సోల్ . రైట్ లైన్ ( 'NAME:' + i . ఈవెంట్_పేరు + 'స్థితి:' + i . ఈవెంట్_స్థితి + 'బడ్జెట్:' + i . ఈవెంట్_బడ్జెట్ ) ;
}
}
}
ప్రజా తరగతి ఈవెంట్ {
ప్రజా స్ట్రింగ్ ఈవెంట్_పేరు { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ ఈవెంట్_స్థితి { పొందండి ; సెట్ ; }
ప్రజా int ఈవెంట్_బడ్జెట్ { పొందండి ; సెట్ ; }
}
అవుట్‌పుట్:
ఈవెంట్_బడ్జెట్ 5000 కంటే ఎక్కువ ఉన్న “ఈవెంట్స్” జాబితాలో మూడు రికార్డ్‌లు ఉన్నాయి.
వివరణ:
1. ముందుగా, మేము మూడు లక్షణాలతో 'ఈవెంట్' తరగతిని సృష్టిస్తాము.
2. అప్పుడు, మేము ఐదు ఈవెంట్‌ల జాబితాను సృష్టిస్తాము.
3. ఉపయోగించి inp1 => inp1.Event_Budget > 5000 లాంబ్డా వ్యక్తీకరణ, మేము ఈవెంట్_బడ్జెట్ 5000 కంటే ఎక్కువ ఉన్న రికార్డ్‌లను ఎంచుకుంటాము.
ఉదాహరణ 5:
మునుపటి కోడ్‌ని ఉపయోగించండి మరియు లాంబ్డా వ్యక్తీకరణను మార్చండి. ఈవెంట్‌లను 'క్యాంప్'తో ముగిసే ఈవెంట్_పేరుతో మరియు 'ప్లాన్డ్' ఈవెంట్_స్టేటస్‌తో తిరిగి ఇవ్వండి.
//Lambda Expression - Event_Name 'Camp'తో ముగుస్తుంది మరియు Event_Status 'ప్లాన్డ్'.ఉంది ఫలితం = సంఘటనలు . ఎక్కడ ( inp1 => inp1 . ఈవెంట్_పేరు . ముగుస్తుంది ( 'శిబిరం' ) && inp1 . ఈవెంట్_స్థితి == 'ప్రణాళిక' ) ;
ప్రతి ( ఉంది i లో ఫలితం ) {
కన్సోల్ . రైట్ లైన్ ( 'NAME:' + i . ఈవెంట్_పేరు + 'స్థితి:' + i . ఈవెంట్_స్థితి + 'బడ్జెట్:' + i . ఈవెంట్_బడ్జెట్ ) ;
}
అవుట్‌పుట్:
రెండు షరతులను సంతృప్తిపరిచే రికార్డు మాత్రమే ఉంది.
వివరణ:
ఇక్కడ, మేము లాంబ్డా వ్యక్తీకరణలో రెండు షరతులను పేర్కొంటాము. రెండు షరతులను ఒప్పుగా చేయడానికి && (మరియు) ఆపరేటర్ ఉపయోగించబడుతుంది. ఇచ్చిన స్ట్రింగ్‌తో స్ట్రింగ్ ముగుస్తుందో లేదో తనిఖీ చేయడానికి మొదటి షరతు EndsWith() పద్ధతిని ఉపయోగిస్తుంది. రెండు విలువలు సమానంగా ఉన్నాయో లేదో తనిఖీ చేయడానికి రెండవ షరతు “పోలిక” ఆపరేటర్ (==)ని ఉపయోగిస్తుంది.
ముగింపు
C#లో, లాంబ్డా వ్యక్తీకరణ వ్యక్తీకరణలు/షరతులతో కూడిన ప్రకటనలను పేరు లేకుండా దాని శరీరంగా తీసుకుంటుంది. మేము పారామితులను పేర్కొనాలి. అప్పుడు, వ్యక్తీకరణలు దానికి కేటాయించబడతాయి. ప్రాథమికంగా, ఇవ్వబడిన డేటా మూలం నుండి రికార్డులను ఫిల్టర్ చేయడానికి, మూలకాలను మార్చడానికి మరియు డేటా మూలం/క్రమం నుండి మూలకాలను ఎంచుకోవడానికి ఇవి ఉపయోగించబడతాయి. ఈ గైడ్‌లో, లాంబ్డా ఎక్స్‌ప్రెషన్‌ని ఉపయోగించి ఎలిమెంట్‌లను ఎంచుకునే, ఫిల్టర్ చేసే మరియు మార్చే ఐదు విభిన్న ఉదాహరణలను మేము చర్చించాము.