C# LINQని నిఘంటువుగా మార్చండి

C Linqni Nighantuvuga Marcandi



C# LINQలో, నుండి నిఘంటువును రూపొందించడం System.Collections.Generic.IEnumerable ToDictionary() పద్ధతిని ఉపయోగించి సాధ్యమవుతుంది. ఈ పద్ధతి నుండి తో నిఘంటువుని సృష్టిస్తుంది. ది System.ArgumentNullException డేటా సోర్స్, కీసెలెక్టర్ లేదా ఎలిమెంట్ సెలెక్టర్ శూన్యంగా ఉంటే విసిరివేయబడుతుంది. అలాగే, కీసెలెక్టర్ రెండు మూలకాల కోసం డూప్లికేట్ కీలను ఉత్పత్తి చేస్తే, ది System.ArgumentException విసిరివేయబడుతుంది. ఈ గైడ్‌లో, రెండు పద్ధతులను ఓవర్‌లోడ్ చేయడం ద్వారా జాబితా డేటా మూలం నుండి నిఘంటువును ఎలా సృష్టించాలో మేము చర్చిస్తాము.

సింటాక్స్:

1. మీరు ఇచ్చిన డేటా సోర్స్ నుండి పేర్కొన్న కీ సెలెక్టర్ మరియు ఎలిమెంట్ సెలెక్టర్ ఫంక్షన్‌ల ప్రకారం నిఘంటువుని సృష్టించాలనుకుంటే, కింది పద్ధతిని ఓవర్‌లోడ్ చేయండి:







పారామితులు:



    1. మూలం : మూలం ఈ మూలం నుండి నిఘంటువు సృష్టించబడిన IEnumerable (జాబితా) కావచ్చు.
    2. కీసెలెక్టర్ : ఇది ప్రతి మూలకం నుండి కీని పొందడానికి ఉపయోగించే ఒక ఫంక్షన్.
    3. ఎలిమెంట్ సెలెక్టర్: ఇది మూలకాన్ని పొందడానికి ఉపయోగించే ఒక ఫంక్షన్.
    4. TS సోర్స్ : ఇది డేటా మూలం యొక్క రకాన్ని పేర్కొనే రకం పరామితి.
    5. TKey: ఇది కీ రకాన్ని పేర్కొనే రకం పరామితి.
    6. టెలీమెంట్ : ఇది మూలకం రకాన్ని పేర్కొనే రకం పరామితి.

2. మీరు ఇచ్చిన డేటా సోర్స్ నుండి పేర్కొన్న కీ సెలెక్టర్ ఫంక్షన్ ప్రకారం నిఘంటువుని సృష్టించాలనుకుంటే, కింది పద్ధతిని ఓవర్‌లోడ్ చేయండి:



పారామితులు:



    1. మూలం : మూలం ఈ మూలం నుండి నిఘంటువు సృష్టించబడిన IEnumerable (జాబితా) కావచ్చు.
    2. కీసెలెక్టర్ : ఇది ప్రతి మూలకం నుండి కీని పొందడానికి ఉపయోగించే ఒక ఫంక్షన్.
    3. TS మూలం: ఇది డేటా సోర్స్ యొక్క రకాన్ని సూచిస్తుంది.
    4. TKey : ఇది కీ రకాన్ని నిర్దేశిస్తుంది.

ఉదాహరణ 1: పేర్కొన్న కీ సెలెక్టర్ మరియు ఎలిమెంట్ సెలెక్టర్ ఫంక్షన్

ఐదు రికార్డులతో నాలుగు లక్షణాలను (Acc_ID, Acc_Name, Industry, Revenue) కలిగి ఉన్న “ఖాతా” రకంతో జాబితాను సృష్టించండి.

1. Acc_ID మరియు విలువను Acc_Nameగా కీతో మునుపటి జాబితా నుండి నిఘంటువుని సృష్టించండి.
2. Acc_Name మరియు విలువ ఆదాయంగా కీతో మునుపటి జాబితా నుండి నిఘంటువుని సృష్టించండి.

ఉపయోగించి వ్యవస్థ ;
ఉపయోగించి System.Linq ;
ఉపయోగించి System.Collections.Generic ;

తరగతి ఖాతా వివరములు
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( )
{
// రకం జాబితాను సృష్టించండి - ఖాతా.
జాబితా వివరాలు = కొత్త జాబితా ( ) ;
// జాబితాకు 5 రికార్డులను జోడించండి.
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 1 , Acc_Name = 'Linux' , పరిశ్రమ = 'చదువు' ,ఆదాయం = 2500 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 2 , Acc_Name = 'పైథాన్' , పరిశ్రమ = 'బూట్‌క్యాంప్' ,ఆదాయం = 10000 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 3 , Acc_Name = 'జావా' , పరిశ్రమ = 'చదువు' ,ఆదాయం = 500 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 4 , Acc_Name = '.NET' , పరిశ్రమ = 'శిక్షణ' ,ఆదాయం = 2080 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 5 , Acc_Name = 'ఒరాకిల్' , పరిశ్రమ = 'ఉద్యోగం' ,ఆదాయం = 2090 } ) ;

// Acc_IDగా కీతో మరియు Acc_Nameగా విలువతో పై జాబితా నుండి నిఘంటువుని సృష్టించండి
కన్సోల్ . రైట్ లైన్ ( ' ----కీ Acc_IDగా మరియు విలువ Acc_Name----' ) ;
నిఘంటువు ఖాతాలు_డిక్ట్1 = వివరాలు . నిఘంటువు ( జె => జె . Acc_ID , జె => జె . Acc_Name ) ;

ప్రతి ( కీవాల్యూపెయిర్ i లో ఖాతాలు_డిక్ట్1 )
{
కన్సోల్ . రైట్ లైన్ ( 'ఖాతా గుర్తింపు :' + i . కీ + 'ఖాతా-పేరు :' + i . విలువ ) ;
}

// Acc_Name మరియు విలువ ఆదాయంగా కీతో పై జాబితా నుండి నిఘంటువుని సృష్టించండి
కన్సోల్ . రైట్ లైన్ ( ' ----కీ Acc_పేరు మరియు విలువ ఆదాయంగా----' ) ;
నిఘంటువు ఖాతాలు_డిక్ట్2 = వివరాలు . నిఘంటువు ( ఎల్ => ఎల్ . Acc_Name , ఎల్ => ఎల్ . రాబడి ) ;

ప్రతి ( కీవాల్యూపెయిర్ k లో ఖాతాలు_డిక్ట్2 )
{
కన్సోల్ . రైట్ లైన్ ( 'ఖాతా పేరు :' + కె . కీ + 'ఖాతా-రాబడి :' + కె . విలువ ) ;
}

}
}

// పేరు గల తరగతిని సృష్టించండి - నాలుగు లక్షణాలతో ఖాతా
ప్రజా తరగతి ఖాతా
{
ప్రజా int Acc_ID { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ Acc_Name { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ పరిశ్రమ { పొందండి ; సెట్ ; }
ప్రజా int రాబడి { పొందండి ; సెట్ ; }
}

అవుట్‌పుట్:

వివరణ:

1. నాలుగు లక్షణాలతో 'ఖాతా' పేరుతో తరగతిని సృష్టించండి.

2. ప్రధాన తరగతిలో, 'ఖాతా' రకం జాబితాను సృష్టించండి మరియు దానిలో ఐదు రికార్డులను చొప్పించండి.

3. Acc_ID మరియు విలువను Acc_Nameగా కీతో మునుపటి జాబితా నుండి నిఘంటువుని సృష్టించండి. ఇక్కడ, మేము TKeyని intగా మరియు TElementని స్ట్రింగ్‌గా పేర్కొంటాము. ToDictionary() పద్ధతిలో, మేము కీసెలెక్టర్‌లో Acc_IDని మరియు ఎలిమెంట్‌సెలెక్టర్‌లో Acc_Nameని పాస్ చేస్తాము. చివరగా, మేము డిక్షనరీని మళ్ళించడానికి 'ఫోరీచ్' లూప్‌ని ఉపయోగిస్తాము మరియు కీ మరియు విలువ లక్షణాలను ఉపయోగించి కీలు మరియు విలువలను తిరిగి ఇస్తాము.

4. మునుపటి జాబితా నుండి Acc_Name కీతో మరియు ఆదాయంగా విలువతో నిఘంటువుని సృష్టించండి. ఇక్కడ, మేము TKeyని స్ట్రింగ్‌గా మరియు TElementని intగా పేర్కొంటాము. ToDictionary() పద్ధతిలో, మేము కీసెలెక్టర్‌లో Acc_Nameని మరియు ఎలిమెంట్‌సెలెక్టర్‌లో ఆదాయాన్ని పాస్ చేస్తాము. చివరగా, మేము డిక్షనరీని మళ్ళించడానికి 'ఫోరీచ్' లూప్‌ని ఉపయోగిస్తాము మరియు కీ మరియు విలువ లక్షణాలను ఉపయోగించి కీలు మరియు విలువలను తిరిగి ఇస్తాము.

ఉదాహరణ 2: పేర్కొన్న కీ సెలెక్టర్

మునుపటి కోడ్‌ని ఉపయోగించండి మరియు Acc_ID కీతో మునుపటి జాబితా నుండి నిఘంటువుని సృష్టించండి.

ఉపయోగించి వ్యవస్థ ;
ఉపయోగించి System.Linq ;
ఉపయోగించి System.Collections.Generic ;

తరగతి ఖాతా వివరములు
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( )
{
// రకం జాబితాను సృష్టించండి - ఖాతా.
జాబితా వివరాలు = కొత్త జాబితా ( ) ;
// జాబితాకు 5 రికార్డులను జోడించండి.
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 1 , Acc_Name = 'Linux' , పరిశ్రమ = 'చదువు' ,ఆదాయం = 2500 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 2 , Acc_Name = 'పైథాన్' , పరిశ్రమ = 'బూట్‌క్యాంప్' ,ఆదాయం = 10000 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 3 , Acc_Name = 'జావా' , పరిశ్రమ = 'చదువు' ,ఆదాయం = 500 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 4 , Acc_Name = '.NET' , పరిశ్రమ = 'శిక్షణ' ,ఆదాయం = 2080 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 5 , Acc_Name = 'ఒరాకిల్' , పరిశ్రమ = 'ఉద్యోగం' ,ఆదాయం = 2090 } ) ;

// Acc_IDగా కీతో పై జాబితా నుండి నిఘంటువుని సృష్టించండి.
నిఘంటువు ఖాతాలు_డిక్ట్ = వివరాలు . నిఘంటువు ( జె => జె . Acc_ID ) ;
ప్రతి ( కీవాల్యూపెయిర్ i లో ఖాతాలు_డిక్ట్ )
{
కన్సోల్ . రైట్ లైన్ ( 'కీ:' + i . కీ + '-->  ఖాతా-పేరు :' + i . విలువ . Acc_Name
+ 'ఖాతా-పరిశ్రమ :' + i . విలువ . పరిశ్రమ
+ 'ఖాతా-రాబడి :' + i . విలువ . రాబడి ) ;
}

}
}

// పేరు గల తరగతిని సృష్టించండి - నాలుగు లక్షణాలతో ఖాతా
ప్రజా తరగతి ఖాతా
{
ప్రజా int Acc_ID { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ Acc_Name { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ పరిశ్రమ { పొందండి ; సెట్ ; }
ప్రజా int రాబడి { పొందండి ; సెట్ ; }
}

అవుట్‌పుట్:

వివరణ:

ఇక్కడ, మేము Acc_ID కీతో నిఘంటువుని సృష్టిస్తాము. ఇది మేము జాబితా నుండి సృష్టించిన డిక్షనరీలోని ప్రతి రికార్డ్‌కు కీలకంగా పనిచేస్తుంది. ఆ తర్వాత, కీ మరియు విలువ లక్షణాలను ఉపయోగించి కీలు మరియు విలువలను (గుణాలతో) పొందడానికి మేము 'ఫోరీచ్' లూప్‌ని ఉపయోగిస్తాము.

ఉదాహరణ 3: డూప్లికేట్ కీలు – వాదన మినహాయింపు

రెండు రికార్డ్‌లతో జాబితాను సృష్టించండి మరియు దానిని Acc_ID కీతో నిఘంటువుగా మార్చడానికి ప్రయత్నించండి.

ఉపయోగించి వ్యవస్థ ;
ఉపయోగించి System.Linq ;
ఉపయోగించి System.Collections.Generic ;

తరగతి ఖాతా వివరములు
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( )
{
// రకం జాబితాను సృష్టించండి - ఖాతా.
జాబితా వివరాలు = కొత్త జాబితా ( ) ;
// జాబితాకు 2 రికార్డులను జోడించండి.
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 1 , Acc_Name = 'Linux' , పరిశ్రమ = 'చదువు' ,ఆదాయం = 2500 } ) ;
వివరాలు . జోడించు ( కొత్త ఖాతా { Acc_ID = 1 , Acc_Name = 'పైథాన్' , పరిశ్రమ = 'బూట్‌క్యాంప్' ,ఆదాయం = 10000 } ) ;

// Acc_IDగా కీతో పై జాబితా నుండి నిఘంటువుని సృష్టించడానికి ప్రయత్నించండి.
నిఘంటువు ఖాతాలు_డిక్ట్ = వివరాలు . నిఘంటువు ( జె => జె . Acc_ID ) ;

}
}

// పేరు గల తరగతిని సృష్టించండి - నాలుగు లక్షణాలతో ఖాతా
ప్రజా తరగతి ఖాతా
{
ప్రజా int Acc_ID { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ Acc_Name { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ పరిశ్రమ { పొందండి ; సెట్ ; }
ప్రజా int రాబడి { పొందండి ; సెట్ ; }
}

మినహాయింపు:

నిర్వహించబడని మినహాయింపు సిస్టమ్. Acc_ID రెండింటిలోనూ కీ నకిలీ (1) అయినందున ఆర్గ్యుమెంట్ మినహాయింపు పెరిగింది.

ఉదాహరణ 4: శూన్య మూలం – వాదనNullException

'ఖాతా' రకంతో జాబితాను సృష్టించండి మరియు దానికి శూన్యతను కేటాయించండి. Acc_ID కీతో మునుపటి జాబితా నుండి నిఘంటువుని రూపొందించడానికి ప్రయత్నించండి.

ఉపయోగించి వ్యవస్థ ;
ఉపయోగించి System.Linq ;
ఉపయోగించి System.Collections.Generic ;

తరగతి ఖాతా వివరములు
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( )
{
// రకం జాబితాను సృష్టించండి - ఖాతా మరియు దానికి శూన్యతను కేటాయించండి.
జాబితా వివరాలు = శూన్య ;

// Acc_IDగా కీతో పై జాబితా నుండి నిఘంటువుని సృష్టించడానికి ప్రయత్నించండి.
నిఘంటువు ఖాతాలు_డిక్ట్ = వివరాలు . నిఘంటువు ( జె => జె . Acc_ID ) ;

}
}

// పేరు గల తరగతిని సృష్టించండి - నాలుగు లక్షణాలతో ఖాతా
ప్రజా తరగతి ఖాతా
{
ప్రజా int Acc_ID { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ Acc_Name { పొందండి ; సెట్ ; }
ప్రజా స్ట్రింగ్ పరిశ్రమ { పొందండి ; సెట్ ; }
ప్రజా int రాబడి { పొందండి ; సెట్ ; }
}

మినహాయింపు:

System.ArgumentNullException అనే హ్యాండిల్ చేయని మినహాయింపు జాబితా శూన్యం అయినందున పెంచబడింది.

ముగింపు

C# LINQలోని ToDictionary() పద్ధతిని ఉపయోగించి IEnumerable (ఇక్కడ, ఇది జాబితా) నుండి నిఘంటువుని ఎలా సృష్టించాలో మేము నేర్చుకున్నాము. ఈ పద్ధతిని రెండు విధాలుగా ఓవర్‌లోడ్ చేయవచ్చు. మేము రెండు పద్ధతులను ఉదాహరణలతో చర్చించాము. అలాగే, డేటా సోర్స్/కీసెలెక్టర్/ఎలిమెంట్ సెలెక్టర్ శూన్యంగా ఉన్నప్పుడు మరియు కీలు డూప్లికేట్‌గా ఉన్నప్పుడు ఈ పద్ధతి ద్వారా లేవనెత్తే రెండు మినహాయింపు కేసులను మేము తెలుసుకున్నాము.

ఇతర

వర్గం

ప్రముఖ పోస్ట్లు

రాస్ప్బెర్రీ పైలో యాంబియంట్ లైట్ సాఫ్ట్‌వేర్ హైపెరియన్‌ను ఎలా ఇన్‌స్టాల్ చేయాలి

డిస్కార్డ్ క్లబ్‌హౌస్-స్టైల్ స్టేజ్ ఛానెల్‌లను ప్రారంభించింది

మైక్రోసాఫ్ట్ వర్డ్‌లో సంతకాన్ని ఎలా చొప్పించాలి

డిస్కార్డ్‌లో మీరు అల్ట్రా లైట్ మోడ్‌ని ఎలా ఆన్ చేస్తారు?

జావాస్క్రిప్ట్‌తో ఆన్‌క్లిక్‌ను ఎలా సెట్ చేయాలి

డెబియన్ 12లో NVMని ఎలా ఇన్‌స్టాల్ చేయాలి- బహుళ Node.js వెర్షన్‌లను ఇన్‌స్టాల్ చేయడం

Systemd సర్వీస్ ఫైల్‌ను ఎలా తొలగించాలి

workflow_dispatch GitHub చర్యలను ఎలా ట్రిగ్గర్ చేయాలి?

PyTorchలో అన్ని వైపులా నిర్దిష్ట చిత్రాన్ని ఎలా ప్యాడ్ చేయాలి?

Windows 11 యొక్క మీడియా ప్లేయర్ Windows 10కి చేరుకుంది

CSSలో ఓవర్‌ఫ్లో-y ప్రాపర్టీని ఎలా ఉపయోగించాలి?

డిస్కార్డ్ యాప్‌లోని చిహ్నాన్ని నేను ఎలా మార్చగలను?

Eig() ఫంక్షన్‌ని ఉపయోగించి MATLABలో Eigenvalues ​​మరియు Eigenvectorsని ఎలా కనుగొనాలి?

MATLABలో పాలీఫిట్‌ని ఎలా కోడ్ చేయాలి?

WordPressలో Google డాక్స్‌ను ఎలా పొందుపరచాలి

త్రీ-టైర్ ఆర్కిటెక్చర్ అంటే ఏమిటి?

Zshrcలో కమాండ్ కనుగొనబడలేదు?

పైథాన్‌లో PyGPT4Allని ఎలా ఉపయోగించాలి

Gitలో ఫాస్ట్ ఫార్వర్డ్ లేకుండా శాఖలను ఎలా విలీనం చేయాలి

Windows 10 తప్పిపోయిన లేదా పాడైన సిస్టమ్ ఫైల్‌లను ఎలా రిపేర్ చేయాలి