C#లో జతను ఉపయోగించడం
C#లో పెయిర్ని ఉపయోగించడానికి, మీరు మీ కోడ్లో System.Collections.Generic నేమ్స్పేస్ని చేర్చాలి. అప్పుడు, మీరు పెయిర్
రెండు విలువలతో జత ఆబ్జెక్ట్ని సృష్టించే ఉదాహరణ ఇక్కడ ఉంది:
జత < స్ట్రింగ్, Int > myPair = కొత్త జత < స్ట్రింగ్, Int > ( 'తాను' , ఇరవై ) ;
ఈ ఉదాహరణలో, మేము రెండు విలువలతో జత ఆబ్జెక్ట్ను సృష్టించాము, ఇక్కడ మొదటి విలువ స్ట్రింగ్ “సామ్” మరియు రెండవ విలువ పూర్ణాంకం 20.
మీరు మొదటి మరియు రెండవ లక్షణాలను ఉపయోగించి పెయిర్ ఆబ్జెక్ట్ యొక్క విలువలను యాక్సెస్ చేయవచ్చు, ఇక్కడ ఒక ఉదాహరణ ఉంది:
కన్సోల్.WriteLine ( myPair.మొదటి ) ;
కన్సోల్.WriteLine ( myPair.రెండవ ) ;
మీరు ఈ లక్షణాలను ఉపయోగించి పెయిర్ ఆబ్జెక్ట్ యొక్క విలువలను కూడా సవరించవచ్చు, ఇక్కడ ఒక ఉదాహరణ ఉంది:
myPair.First = 'గుర్తు' ;
myPair.Second = 30 ;
కన్సోల్.WriteLine ( myPair.మొదటి ) ;
కన్సోల్.WriteLine ( myPair.రెండవ ) ;
మీరు ఫంక్షన్ నుండి రెండు విలువలను తిరిగి ఇవ్వవలసి వచ్చినప్పుడు జత ఉపయోగకరంగా ఉంటుంది. కస్టమ్ క్లాస్ని సృష్టించడానికి లేదా పారామీటర్లను ఉపయోగించకుండా, మీరు రెండు విలువలతో జత వస్తువును తిరిగి ఇవ్వవచ్చు. ఇక్కడ ఒక ఉదాహరణ:
వ్యవస్థను ఉపయోగించడం;System.Collections.Generic ఉపయోగించి;
namespace PairExample {
తరగతి కార్యక్రమం {
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// ఒక జత సృష్టిస్తోంది
జత < స్ట్రింగ్, Int > myPair = కొత్త జత < స్ట్రింగ్, Int > ( 'తాను' , ఇరవై ) ;
// అవుట్పుట్ అసలైన జత
కన్సోల్.WriteLine ( 'అసలు జత:' ) ;
కన్సోల్.WriteLine ( $ 'మొదటి: {myPair.First}, రెండవది: {myPair.Second}' ) ;
// ఒక జతను సవరించడం
myPair.First = 'గుర్తు' ;
myPair.Second = 30 ;
// అవుట్పుట్ సవరించిన జత
కన్సోల్.WriteLine ( ' \n సవరించిన జత:' ) ;
కన్సోల్.WriteLine ( $ 'మొదటి: {myPair.First}, రెండవది: {myPair.Second}' ) ;
కన్సోల్. రీడ్లైన్ ( ) ;
}
}
// జత తరగతి
పబ్లిక్ క్లాస్ పెయిర్ < T1, T2 > {
పబ్లిక్ T1 మొదటిది {
పొందండి;
సెట్ ;
}
పబ్లిక్ T2 సెకను {
పొందండి;
సెట్ ;
}
పబ్లిక్ జత ( T1 మొదటి, T2 రెండవ ) {
మొదటి = మొదటి;
రెండవ = రెండవ;
}
}
}
ఈ కోడ్లో, మేము మొదట స్ట్రింగ్ మరియు పూర్ణాంక విలువతో జత వస్తువును సృష్టిస్తాము. మేము మొదటి మరియు రెండవ లక్షణాలను ఉపయోగించి జత యొక్క విలువలను యాక్సెస్ చేస్తాము మరియు ఆ తర్వాత, అదే లక్షణాలను ఉపయోగించి మేము జత యొక్క విలువలను సవరించాము.
మేము పెయిర్ క్లాస్ని మెయిన్ మెథడ్ నుండి విడిగా నిర్వచించామని గమనించండి. పెయిర్ క్లాస్లో రెండు జెనరిక్ టైప్ పారామీటర్లు ఉన్నాయి, T1 మరియు T2, ఇవి వరుసగా జత యొక్క మొదటి మరియు రెండవ విలువల రకాలను సూచిస్తాయి. మేము ఈ విలువలను యాక్సెస్ చేయడానికి మొదటి మరియు రెండవ రెండు లక్షణాలను నిర్వచించాము మరియు వాటిని ప్రారంభించేందుకు మేము ఒక కన్స్ట్రక్టర్ను అందిస్తాము.
ముగింపు
పెయిర్ అనేది C#లో ఉపయోగకరమైన డేటా నిర్మాణం, ఇది ఒక జత విలువలను నిల్వ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది, ఇక్కడ ప్రతి విలువ విభిన్న డేటా రకాలుగా ఉండవచ్చు. కీ-విలువ జతలను నిల్వ చేయడం లేదా ఫంక్షన్ నుండి రెండు విలువలను తిరిగి ఇవ్వడం వంటి వివిధ దృశ్యాలలో దీనిని ఉపయోగించవచ్చు. ఈ వ్యాసంలో, మేము వివిధ ఉదాహరణల ద్వారా C#లోని జతల వినియోగాన్ని అన్వేషించాము. మీ కోడ్లో జతలను చేర్చడం ద్వారా, మీరు దాని రీడబిలిటీ, మెయింటెనబిలిటీ మరియు మొత్తం సరళతను మెరుగుపరచవచ్చు.