ప్రశ్న సింటాక్స్:
సాధారణ వాక్యనిర్మాణాన్ని చూద్దాం:
నుండి పునరావృతం చేసేవాడు లో సమాచార మూలంఎంచుకోండి పునరావృతం చేసేవాడు ;
ఇక్కడ:
- డేటా_సోర్స్ అనేది డేటాను కలిగి ఉన్న జాబితా కావచ్చు.
- డేటా_సోర్స్ నుండి మూలకాలను పొందేందుకు ఇటరేటర్ ఉపయోగించబడుతుంది.
సమాచార మూలం
ఈ మొత్తం గైడ్‌లో, మేము కింది రికార్డుల జాబితాను డేటా సోర్స్‌గా ఉపయోగిస్తాము మరియు అన్ని ప్రశ్నలు ఈ డేటా సోర్స్‌లో మాత్రమే వర్తింపజేయబడతాయి. మీరు ఈ కోడ్‌ని మీ ఎన్విరాన్‌మెంట్‌లో అమలు చేశారని నిర్ధారించుకోండి మరియు మేము చర్చించబోయే క్రింది ఉదాహరణలతో ప్రశ్న స్టేట్‌మెంట్‌లను ఒక్కొక్కటిగా సవరించండి:
ఉపయోగించి వ్యవస్థ ;
ఉపయోగించి System.Collections.Generic ;
ఉపయోగించి System.Linq ;
ఉపయోగించి వ్యవస్థ. సేకరణలు ;
ప్రజా తరగతి లెక్కలు
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( )
{
// జాబితా సృష్టి
దేశం_ధరలను జాబితా చేయండి = కొత్త జాబితా ( ) {
// జాబితాలోకి 5 రికార్డులను జోడించండి
కొత్త ధరలు ( ) { అంశం = 'పండ్లు' ,స్థానం = 'USA' , పరిమాణం = 100 , ఖరీదు = 345.78 } ,
కొత్త ధరలు ( ) { అంశం = 'గింజలు' ,స్థానం = 'భారతదేశం' , పరిమాణం = 200 , ఖరీదు = 3645.78 } ,
కొత్త ధరలు ( ) { అంశం = 'ఇతరులు' ,స్థానం = 'UK' , పరిమాణం = 500 , ఖరీదు = 90.68 } ,
కొత్త ధరలు ( ) { అంశం = 'నూనె' ,స్థానం = 'USA' , పరిమాణం = 100 , ఖరీదు = 345.78 } ,
కొత్త ధరలు ( ) { అంశం = 'మిరపకాయలు' ,స్థానం = 'USA' , పరిమాణం = 10 , ఖరీదు = 67.89 } ,
} ;
ప్రతి ( ఉంది i లో దేశం_ధరలు )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
}
}
ప్రజా తరగతి ధరలు {
ప్రజా స్ట్రింగ్ అంశం { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ స్థానం { పొందండి ; సెట్ ; }
ప్రజా int పరిమాణం { పొందండి ; సెట్ ; }
ప్రజా రెట్టింపు ఖరీదు { పొందండి ; సెట్ ; }
}
రికార్డులు:
వివరణ:
1. కింది లక్షణాలతో ధరలను సృష్టించండి:
2. ప్రధాన పద్ధతితో 'లెక్కలు' అనే మరొక తరగతిని సృష్టించండి మరియు ఐదు రికార్డులతో దేశం_ధరల జాబితాను సృష్టించండి.
ఎంచుకోండి
ప్రాథమికంగా, “సెలెక్ట్” అనేది ప్రొజెక్షన్ ఆపరేటర్, ఇది పేర్కొన్న డేటా మూలం నుండి లక్షణాలను ఎంచుకుంటుంది. ప్రశ్న 'నుండి'తో ప్రారంభమవుతుంది. అప్పుడు, మేము డేటా సోర్స్‌పై మళ్లించే ఇటరేటర్‌ని పేర్కొంటాము. అప్పుడు, 'ఎంచుకోండి' ఆపరేటర్ పేర్కొనబడింది.
సింటాక్స్:
అన్ని లక్షణాలు: డేటా_సోర్స్‌లోని ఇటరేటర్ నుండి ఇటరేటర్‌ని ఎంచుకోండి;
నిర్దిష్ట లక్షణం: Data_Sourceలో iterator నుండి iterator.attributeని ఎంచుకోండి;
ఉదాహరణ 1:
జాబితా నుండి అన్ని రికార్డులను ఎంచుకోవడానికి ఒక ప్రశ్నను వ్రాద్దాం.
ఉపయోగించి వ్యవస్థ ;ఉపయోగించి System.Collections.Generic ;
ఉపయోగించి System.Linq ;
ఉపయోగించి వ్యవస్థ. సేకరణలు ;
ప్రజా తరగతి లెక్కలు
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( )
{
// జాబితా సృష్టి
దేశం_ధరలను జాబితా చేయండి = కొత్త జాబితా ( ) {
// జాబితాలోకి 5 రికార్డులను జోడించండి
కొత్త ధరలు ( ) { అంశం = 'పండ్లు' ,స్థానం = 'USA' , పరిమాణం = 100 , ఖరీదు = 345.78 } ,
కొత్త ధరలు ( ) { అంశం = 'గింజలు' ,స్థానం = 'భారతదేశం' , పరిమాణం = 200 , ఖరీదు = 3645.78 } ,
కొత్త ధరలు ( ) { అంశం = 'ఇతరులు' ,స్థానం = 'UK' , పరిమాణం = 500 , ఖరీదు = 90.68 } ,
కొత్త ధరలు ( ) { అంశం = 'నూనె' ,స్థానం = 'USA' , పరిమాణం = 100 , ఖరీదు = 345.78 } ,
కొత్త ధరలు ( ) { అంశం = 'మిరపకాయలు' ,స్థానం = 'USA' , పరిమాణం = 10 , ఖరీదు = 67.89 } ,
} ;
//ప్రశ్నలో ఆపరేటర్‌ని ఎంచుకోండి
ఉంది సమాచారం = నుండి i లో దేశం_ధరలు
ఎంచుకోండి i ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
}
}
ప్రజా తరగతి ధరలు {
ప్రజా స్ట్రింగ్ అంశం { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ స్థానం { పొందండి ; సెట్ ; }
ప్రజా int పరిమాణం { పొందండి ; సెట్ ; }
ప్రజా రెట్టింపు ఖరీదు { పొందండి ; సెట్ ; }
}
అవుట్‌పుట్:
ఇక్కడ, 'ఎంచుకోండి' ప్రశ్నలో మేము ఏ లక్షణాన్ని పేర్కొనలేదు. మేము ఇటరేటర్‌ని ఉపయోగించి “ఫోరీచ్” లూప్‌లోని ప్రశ్న (డేటా) నుండి అన్ని లక్షణాలను పొందాము.
ఉదాహరణ 2:
ఇప్పుడు, 'సెలెక్ట్' ఆపరేటర్‌లో ఐటెమ్ అట్రిబ్యూట్‌ని పేర్కొనడం ద్వారా ఐటెమ్‌లను పొందండి. ప్రశ్న ' దేశం_ధరలలో i నుండి i.itemని ఎంచుకోండి ”.
//ప్రశ్నలో ఐటెమ్ అట్రిబ్యూట్ పొందడానికి ఆపరేటర్‌ని ఎంచుకోండిఉంది సమాచారం = నుండి i లో దేశం_ధరలు
ఎంచుకోండి i . అంశం ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i ) ;
}
అవుట్‌పుట్:
పంక్తి # 21 – పంక్తి # 29:
2. ఎక్కడ
మీరు కొన్ని షరతులు/ల ఆధారంగా డేటాను ఫిల్టర్ చేయాలనుకుంటే, మీరు 'ఎంచుకోండి' నిబంధనతో పాటు ప్రశ్నలో 'ఎక్కడ' ఆపరేటర్‌ని ఉపయోగించవచ్చు. కానీ 'ఎక్కడ' ఆపరేటర్ మొదట ఉపయోగించబడుతుంది మరియు ఆపై ఎంపిక చేసిన ఆపరేటర్ పేర్కొనబడుతుంది.
సింటాక్స్:
LINQ ప్రశ్న లోపల 'ఎక్కడ' ఆపరేటర్‌ని ఎలా ఉపయోగించాలో చూద్దాం.
నుండి పునరావృతం చేసేవాడు లో సమాచార మూలంఎక్కడ పరిస్థితి / లు
ఎంచుకోండి పునరావృతం చేసేవాడు . గుణం ;
ఉదాహరణ 1: సింగిల్ కండిషన్
ఐటెమ్ అట్రిబ్యూట్ ఆధారంగా రికార్డ్‌లను ఫిల్టర్ చేద్దాం. “ఎక్కడ” ఆపరేటర్‌లో ఈక్వల్ టు (==) ఆపరేటర్‌ని షరతుగా ఉపయోగించండి మరియు ఇటరేటర్‌ను “చిల్లీస్”తో పోల్చండి. కాబట్టి, “మిరపకాయలు”కి సంబంధించిన రికార్డులు ఎంపిక చేయబడ్డాయి.
ప్రశ్న ' దేశం_ధరలలో i నుండి
ఇక్కడ i.item == “మిరపకాయలు”
నేను ఎంచుకోండి'
ఉంది సమాచారం = నుండి i లో దేశం_ధరలు
ఎక్కడ i . అంశం == 'మిరపకాయలు'
ఎంచుకోండి i ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
అవుట్‌పుట్:
'మిరపకాయలు' అంశంతో ఒకే ఒక్క రికార్డు ఉంది.
పంక్తి # 21 – పంక్తి # 30:
ఉదాహరణ 2: బహుళ షరతులు
స్థానం మరియు పరిమాణం లక్షణాల ఆధారంగా రికార్డులను ఫిల్టర్ చేద్దాం. పరిమాణం 50 కంటే ఎక్కువ మరియు 300 కంటే తక్కువగా ఉండాలి. స్థానం 'USA' అయి ఉండాలి.
ప్రశ్న ' దేశం_ధరలలో i నుండి
ఇక్కడ i.quantity > 50
ఇక్కడ i.పరిమాణం <300
ఎక్కడ i.location == “USA”
నేను ఎంచుకోండి'
ఉంది సమాచారం = నుండి i లో దేశం_ధరలు
ఎక్కడ i . పరిమాణం > యాభై
ఎక్కడ i . పరిమాణం < 300
ఎక్కడ i . స్థానం == 'USA'
ఎంచుకోండి i ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
అవుట్‌పుట్:
మునుపటి పరిస్థితులతో సరిపోలిన రెండు రికార్డులు ఉన్నాయి.
పంక్తి # 21 – పంక్తి # 32:
ఉదాహరణ 3: మరియు (&&) ఆపరేటర్
మేము ఒకేసారి బహుళ షరతులను పేర్కొనడానికి “మరియు (&&)” ఆపరేటర్‌ని పేర్కొనవచ్చు. అన్ని షరతులు నిజమైతే, అన్ని షరతులను సంతృప్తిపరిచే రికార్డులు ప్రశ్న ద్వారా తిరిగి ఇవ్వబడతాయి.
ఈ ఉదాహరణలో, పరిమాణం 20 కంటే ఎక్కువ మరియు ధర 67.89 అయితే మేము రికార్డులను ఎంచుకుంటాము.
ప్రశ్న ' దేశం_ధరలలో i నుండి
ఇక్కడ i.quantity < 20 && i.cost == 67.89
నేను ఎంచుకోండి'
ఎక్కడ i . పరిమాణం < ఇరవై && i . ఖరీదు == 67.89
ఎంచుకోండి i ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
అవుట్‌పుట్:
20 కంటే తక్కువ పరిమాణం మరియు 67.89 ధరతో ఒకే ఒక్క రికార్డు ఉంది
పంక్తి # 21 – పంక్తి # 29:
ఉదాహరణ 4: లేదా (||) ఆపరేటర్
'లేదా (||)' ఆపరేటర్ కూడా ఒకేసారి బహుళ షరతులను పేర్కొనడానికి ఉపయోగించబడుతుంది. కనీసం ఒక షరతు నిజమైతే, ఆ షరతును సంతృప్తిపరిచే రికార్డులు తిరిగి ఇవ్వబడతాయి.
ఈ ఉదాహరణలో, పరిమాణం 300 కంటే ఎక్కువ ఉంటే లేదా 'టోక్యో' స్థానం ఉంటే మేము రికార్డ్‌లను ఎంచుకుంటాము.
ప్రశ్న ' దేశం_ధరలలో i నుండి
ఇక్కడ i.quantity > 300 || i.location == “టోక్యో”
నేను ఎంచుకోండి'
ఎక్కడ i . పరిమాణం > 300 || i . స్థానం == 'టోక్యో'
ఎంచుకోండి i ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
అవుట్‌పుట్:
300 కంటే ఎక్కువ పరిమాణంతో ఒకే ఒక రికార్డు ఉంది (మొదటి షరతు సరిపోలింది).
పంక్తి # 21 – పంక్తి # 29:
3. ద్వారా ఆర్డర్
మీరు ఏదైనా లక్షణాలలో విలువల ఆధారంగా LINQ ప్రశ్న ద్వారా తిరిగి వచ్చే రికార్డ్‌లను ఆరోహణ లేదా అవరోహణ క్రమంలో అమర్చాలనుకుంటే, మీరు ప్రశ్నలో “ఆర్డర్ బై” ఆపరేటర్‌ని ఉపయోగించవచ్చు. 'ఎంచుకోండి' ఆపరేటర్‌కు ముందు మీరు ఈ ఆపరేటర్‌ని పేర్కొనాలి.
సింటాక్స్:
LINQ ప్రశ్న లోపల 'ఆర్డర్ బై' ఆపరేటర్‌ని ఎలా ఉపయోగించాలో చూద్దాం.
ఆరోహణ క్రమం:
నుండి పునరావృతం చేసేవాడు లో సమాచార మూలంఆర్డర్ ద్వారా పునరావృతం చేసేవాడు . గుణం ఆరోహణ
ఎంచుకోండి పునరావృతం చేసేవాడు ;
అవరోహణ క్రమం:
నుండి పునరావృతం చేసేవాడు లో సమాచార మూలంఆర్డర్ ద్వారా పునరావృతం చేసేవాడు . గుణం అవరోహణ
ఎంచుకోండి పునరావృతం చేసేవాడు ;
ఉదాహరణ 1: ఆరోహణ క్రమం
డేటా మూలం (జాబితా) నుండి అన్ని లక్షణాలను ఎంచుకోండి మరియు పరిమాణం లక్షణంలోని విలువల ఆధారంగా వాటిని ఆరోహణ క్రమంలో తిరిగి ఇవ్వండి.
ప్రశ్న ' దేశం_ధరలలో i నుండి
క్రమం ద్వారా i. పరిమాణం ఆరోహణ
నేను ఎంచుకోండి'
i ద్వారా ఆర్డర్ . పరిమాణం ఆరోహణ
ఎంచుకోండి i ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
అవుట్‌పుట్:
పంక్తి # 21 – పంక్తి # 29:
ఉదాహరణ 2: అవరోహణ క్రమం
డేటా మూలం (జాబితా) నుండి అన్ని అట్రిబ్యూట్‌లను ఎంచుకుని, ధర లక్షణంలోని విలువల ఆధారంగా అవరోహణ క్రమంలో వాటిని తిరిగి ఇవ్వండి.
ప్రశ్న ' దేశం_ధరలలో i నుండి
ఆర్డర్ ద్వారా i. ఖర్చు తగ్గుదల
నేను ఎంచుకోండి'
i ద్వారా ఆర్డర్ . ఖరీదు అవరోహణ
ఎంచుకోండి i ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
అవుట్‌పుట్:
పంక్తి # 21 – పంక్తి # 29:
4. పరిమితి
SQLలో పరిమితి ప్రశ్న ద్వారా తిరిగి వచ్చే రికార్డులను పరిమితం చేస్తుంది. ఇది ప్రశ్న ద్వారా అందించబడిన టాప్ రికార్డ్‌లను అందిస్తుంది. LINQలో, టేక్() ఆపరేటర్‌తో స్కిప్()ని ఉపయోగించడం ద్వారా మనం దీనిని సాధించవచ్చు. టేక్() పేర్కొన్న రికార్డుల సంఖ్యను పొందుతుంది. ప్రారంభ రికార్డ్ సంఖ్యను పేర్కొనడానికి స్కిప్() ఉపయోగించబడుతుంది. ఈ విధంగా, మేము LINQలో “పరిమితి” కార్యాచరణను సాధించగలము.
సింటాక్స్:
( నుండి పునరావృతం చేసేవాడు లో సమాచార మూలంఎంచుకోండి పునరావృతం చేసేవాడు ) . దాటవేయి ( n ) . తీసుకోవడం ( n ) ;
- స్కిప్() అనేది రికార్డ్‌లను దాటవేయడానికి మరియు మిగిలిన రికార్డులను తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది. ఇది దాటవేయవలసిన మూలకాల సంఖ్యను పేర్కొనే పూర్ణాంకాన్ని తీసుకుంటుంది. మా విషయంలో, ఇది 0.
- మొదటి రికార్డు నుండి 'n' సంఖ్య రికార్డులను తీసుకోవడానికి Take() ఉపయోగించబడుతుంది.
ఉదాహరణ:
ప్రశ్న ద్వారా తిరిగి వచ్చిన ఐదు రికార్డ్‌లలో మొదటి మూడు రికార్డ్‌లను ఎంచుకోండి.
ప్రశ్న ' (ఐ నుండి దేశంలో_ధరలు
i ఎంచుకోండి. దాటవేయి(0).టేక్(3)”
ఎంచుకోండి i ) . దాటవేయి ( 0 ) . తీసుకోవడం ( 3 ) ;
ప్రతి ( ఉంది i లో సమాచారం )
{
కన్సోల్ . రైట్ లైన్ ( i . అంశం + '' + i . స్థానం + '' + i . పరిమాణం + '' + i . ఖరీదు ) ;
}
}
అవుట్‌పుట్:
పంక్తి # 21 – పంక్తి # 28:
ముగింపు
SQLని పోలి ఉండే C# LINQలో ప్రశ్నలను ఎలా వ్రాయాలో మేము నేర్చుకున్నాము. ఈ ట్యుటోరియల్‌లో భాగంగా, డేటా సోర్స్ నుండి రికార్డ్‌లను ఎంచుకోవడానికి “సెలెక్ట్” ఆపరేటర్‌ని ఎలా ఉపయోగించాలో మేము చర్చించాము. ప్రశ్న ద్వారా తిరిగి వచ్చిన రికార్డులను ఫిల్టర్ చేయడానికి, మేము షరతులను పేర్కొనడం ద్వారా 'ఎక్కడ' ఆపరేటర్‌ని ఉపయోగించాము. ఆపై, 'ఆర్డర్ బై' ఆపరేటర్‌తో ప్రశ్న ద్వారా తిరిగి వచ్చిన రికార్డ్‌లను ఎలా క్రమబద్ధీకరించాలో మేము నేర్చుకున్నాము. చివరగా, రికార్డులను పరిమితం చేయడానికి, మేము స్కిప్() మరియు టేక్() ఆపరేటర్లను ఉపయోగించాము.