C#తో పని చేస్తున్నప్పుడు, ఒక పద్ధతి నుండి కాలర్‌కు బహుళ విలువలను తిరిగి ఇవ్వాల్సిన పరిస్థితులు ఉండవచ్చు. సంక్లిష్ట డేటా లేదా గణనలతో వ్యవహరించేటప్పుడు ఇది ఒక సాధారణ సంఘటన కావచ్చు మరియు ఈ కథనంలో, C#లో బహుళ విలువలను తిరిగి ఇవ్వడానికి మేము కొన్ని సాధారణ పద్ధతులను అన్వేషిస్తాము.
1: పారామీటర్‌లను ఉపయోగించి C#లోని మెథడ్ కాలర్‌కి బహుళ విలువలను ఎలా తిరిగి ఇవ్వాలి
C#లో బహుళ విలువలను అందించడానికి మరొక మార్గం పారామీటర్‌లను ఉపయోగించడం మరియు ఆ సందర్భంలో అవుట్ పారామీటర్ అనేది వేరియబుల్, ఇది సూచన ద్వారా పద్ధతికి పంపబడుతుంది మరియు పద్ధతి నుండి విలువను తిరిగి ఇవ్వడానికి ఉపయోగించవచ్చు, ఇక్కడ ఒక ఉదాహరణ ఉంది:
వ్యవస్థను ఉపయోగించడం;
పబ్లిక్ క్లాస్ ప్రోగ్రామ్
{
పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన ( )
{
int [ ] సంఖ్యలు = { 3 , 1 , 4 , 1 , 5 , 9 , 2 , 6 , 5 , 3 } ;
int min, max;
GetMinMax ( సంఖ్యలు, నిమి, గరిష్టంగా ) ;
కన్సోల్.WriteLine ( $ 'కనిష్టం: {min}, గరిష్టం: {max}' ) ;
}
పబ్లిక్ స్టాటిక్ శూన్యమైన GetMinMax ( int [ ] సంఖ్యలు, పూర్ణాంక నిమిషం, పూర్ణాంక గరిష్టం )
{
min = సంఖ్యలు [ 0 ] ;
max = సంఖ్యలు [ 0 ] ;
కోసం ( int i = 1 ; i < సంఖ్యలు.పొడవు; i++ )
{
ఉంటే ( సంఖ్యలు [ i ] < నిమి )
{
min = సంఖ్యలు [ i ] ;
}
ఉంటే ( సంఖ్యలు [ i ] > గరిష్టంగా )
{
max = సంఖ్యలు [ i ] ;
}
}
}
}
దీనిలో గెట్‌మిన్‌మాక్స్ పద్ధతి నిమి మరియు గరిష్టం కోసం రెండు అవుట్ పారామీటర్‌లతో పాటు పూర్ణాంక శ్రేణిని ఇన్‌పుట్‌గా తీసుకుంటుంది. పద్ధతి నుండి అవుట్‌పుట్ విలువలను నిల్వ చేయడానికి ఈ వేరియబుల్స్ ఉపయోగించబడతాయని సూచించడానికి అవుట్ కీవర్డ్ ఉపయోగించబడుతుంది.
పద్ధతిలో, ఇన్‌పుట్ శ్రేణిలోని మొదటి విలువకు min మరియు max వేరియబుల్స్ ప్రారంభించబడతాయి. ఈ పద్ధతి శ్రేణిలోని మిగిలిన విలువల ద్వారా పునరావృతమవుతుంది, ఎదుర్కొన్న విలువల ఆధారంగా అవసరమైన min మరియు max వేరియబుల్స్‌ను నవీకరించడం.
చివరగా, పద్ధతి పూర్తయినప్పుడు, min మరియు max కోసం నవీకరించబడిన విలువలు అవుట్ పారామితుల ద్వారా అందించబడతాయి. ప్రధాన పద్ధతిలో, ఈ అవుట్‌పుట్ విలువలు WriteLine పద్ధతిని ఉపయోగించి కన్సోల్‌కు ముద్రించబడతాయి.
మీరు ఒక పద్ధతి నుండి ఒకటి కంటే ఎక్కువ విలువలను తిరిగి ఇవ్వాల్సిన సందర్భాల్లో బహుళ విలువలను తిరిగి ఇవ్వడానికి అవుట్ కీవర్డ్‌ని ఉపయోగించడం ఉపయోగకరమైన టెక్నిక్. అయితే, అవుట్ పారామీటర్‌ల ఉపయోగం కోడ్‌ని చదవడం మరియు అర్థం చేసుకోవడం కష్టతరం చేస్తుందని గమనించాలి, ప్రత్యేకించి మరింత సంక్లిష్టమైన కోడ్‌తో వ్యవహరించేటప్పుడు మరియు సాధారణంగా ఈ పద్ధతిని తక్కువగా మరియు అవసరమైనప్పుడు మాత్రమే ఉపయోగించడం మంచి ఆలోచన.
2: కస్టమ్ క్లాస్‌ని ఉపయోగించి C#లో మెథడ్ కాలర్‌కి బహుళ విలువలను తిరిగి ఇవ్వడం ఎలా
C#లో బహుళ విలువలను అందించడానికి మూడవ మార్గం కస్టమ్ క్లాస్‌ని ఉపయోగించడం మరియు మీరు తిరిగి ఇవ్వదలిచిన ప్రతి విలువకు లక్షణాలు లేదా ఫీల్డ్‌లను కలిగి ఉన్న తరగతిని సృష్టించడం మరియు ఆపై మీ పద్ధతి నుండి తరగతి యొక్క ఉదాహరణను తిరిగి ఇవ్వడం, ఇక్కడ ఒక ఉదాహరణ ఉంది:
వ్యవస్థను ఉపయోగించడం;నేమ్‌స్పేస్ MyNamspace
{
పబ్లిక్ క్లాస్ MinMaxResult
{
పబ్లిక్ int Min { పొందండి; సెట్ ; }
పబ్లిక్ పూర్ణాంక మాక్స్ { పొందండి; సెట్ ; }
}
పబ్లిక్ స్టాటిక్ క్లాస్ MinMax కాలిక్యులేటర్
{
పబ్లిక్ స్టాటిక్ MinMaxResult GetMinMax ( int [ ] సంఖ్యలు )
{
int min = సంఖ్యలు [ 0 ] ;
int max = సంఖ్యలు [ 0 ] ;
కోసం ( int i = 1 ; i < సంఖ్యలు.పొడవు; i++ )
{
ఉంటే ( సంఖ్యలు [ i ] < నిమి )
{
min = సంఖ్యలు [ i ] ;
}
ఉంటే ( సంఖ్యలు [ i ] > గరిష్టంగా )
{
max = సంఖ్యలు [ i ] ;
}
}
తిరిగి కొత్త MinMaxResult { Min = నిమి, గరిష్టం = గరిష్టం } ;
}
}
తరగతి కార్యక్రమం
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
int [ ] సంఖ్యలు = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 } ;
MinMaxResult ఫలితం = MinMaxCalculator.GetMinMax ( సంఖ్యలు ) ;
కన్సోల్.WriteLine ( $ 'కనిష్టం: {result.Min}, గరిష్టం: {result.Max}' ) ;
}
}
}
ఈ C# కోడ్ 'MyNamespace' అనే పేరుగల నేమ్‌స్పేస్‌ను నిర్వచిస్తుంది, ఇందులో రెండు తరగతులు ఉన్నాయి: 'MinMaxResult' మరియు 'MinMaxCalculator'.
'MinMaxResult' తరగతికి రెండు లక్షణాలు ఉన్నాయి: 'Min' మరియు 'Max', ఇవి వరుసగా కనిష్ట మరియు గరిష్ట విలువలను నిల్వ చేయడానికి ఉపయోగించబడతాయి.
'MinMax కాలిక్యులేటర్' క్లాస్ స్టాటిక్‌గా ప్రకటించబడింది మరియు 'GetMinMax' అనే పేరుతో ఒకే పద్ధతిని కలిగి ఉంది, ఇది పూర్ణాంకాల శ్రేణిని ఇన్‌పుట్‌గా తీసుకుంటుంది. ఈ పద్ధతి శ్రేణి ద్వారా పునరావృతం చేయడానికి మరియు కనిష్ట మరియు గరిష్ట విలువలను కనుగొనడానికి లూప్‌ను ఉపయోగిస్తుంది. ఇది 'MinMaxResult' తరగతికి కొత్త ఉదాహరణను సృష్టిస్తుంది మరియు పద్ధతి యొక్క అవుట్‌పుట్‌గా తిరిగి ఇచ్చే ముందు దాని 'Min' మరియు 'Max' లక్షణాలను కనుగొన్న విలువలతో ప్రారంభిస్తుంది.
చివరగా, “ప్రోగ్రామ్” క్లాస్ “మెయిన్” అనే స్టాటిక్ మెథడ్‌ని కలిగి ఉంది, ఇది ప్రోగ్రామ్ యొక్క ఎంట్రీ పాయింట్ మరియు ఈ పద్ధతిలో పూర్ణాంకాల శ్రేణి ప్రారంభించబడింది మరియు పొందేందుకు “MinMaxCalculator” తరగతిలోని “GetMinMax” పద్ధతికి పంపబడుతుంది. కనిష్ట మరియు గరిష్ట విలువలు.
ముగింపు
సంక్లిష్ట డేటా లేదా గణనలతో పని చేస్తున్నప్పుడు C#లోని మెథడ్ కాలర్‌కి బహుళ విలువలను అందించడం ఒక ముఖ్యమైన లక్షణం. అవుట్ పారామీటర్‌లు మరియు అనుకూల తరగతులు వంటి బహుళ విలువలను అందించడానికి అందుబాటులో ఉన్న విభిన్న పద్ధతులను అర్థం చేసుకోవడం ద్వారా, మీరు మీ నిర్దిష్ట పరిస్థితికి ఉత్తమమైన విధానాన్ని ఎంచుకోవచ్చు. ఈ టెక్నిక్‌లను ఉపయోగించడం వల్ల మీ కోడ్‌ను మరింత సమర్థవంతంగా, సులభంగా చదవడానికి మరియు చివరికి మీ అప్లికేషన్ పనితీరును మెరుగుపరచవచ్చు.