C# అనేది ప్రోగ్రామ్‌లు, వెబ్‌సైట్‌లు, ఆండ్రాయిడ్ అప్లికేషన్‌లు, గేమ్‌లు మరియు మరెన్నో అభివృద్ధి చేయడానికి ఉపయోగించే ప్రోగ్రామింగ్ లాంగ్వేజ్. C# అంతర్నిర్మిత ఫంక్షన్లను కలిగి ఉన్న విభిన్న లైబ్రరీలు మరియు ఫ్రేమ్‌వర్క్‌లకు మద్దతు ఇస్తుంది. ఎనుమ్ ఒక గణన, ఇది ఒక తరగతి. ఒక క్లాస్‌లో విభిన్న డేటా రకాలు మరియు ఫంక్షన్‌లు ఉంటాయి, డేటా స్ట్రక్చర్, ఇందులో విభిన్న వేరియబుల్స్ ఉంటాయి. వినియోగదారు దానిలోని డేటా రకాలను నిర్వచించే కంపైల్ సమయంలో అన్ని వేరియబుల్స్ మనకు తెలిసినప్పుడు గణన చాలా ఉపయోగకరంగా ఉంటుంది. Enum విభిన్న విలువలను కలిగి ఉంది మరియు ఆ విలువలు మార్చబడవు. విలువలను తిరిగి పొందవచ్చు మరియు కోడ్‌లో ఉపయోగించవచ్చు కానీ రన్ టైమ్‌లో మేము విలువలను మార్చలేము ఇవి చదవగలిగేవి మరియు మార్చలేనివి మాత్రమే. గణన దానిలోని మొత్తం డేటాను స్ట్రింగ్‌గా పరిగణిస్తుంది, మనం పూర్ణాంక విలువను ఉపయోగించాలనుకుంటే, మనం cast అని టైప్ చేయాలి. గణన ఉపయోగకరంగా ఉంటుంది ఎందుకంటే అవి తక్కువ మెమరీ మరియు స్థలాన్ని తీసుకుంటాయి.
వాక్యనిర్మాణం
enum E_Name { విలువ_1, విలువ_2, విలువ_3,..... } ;
లేదా
enum E_Name { విలువ_1 = 3. 4 , విలువ_2 = 90 , విలువ_3 = 8 ,….. } ;
గుణం 'enum' గణనను నిర్వచించడానికి కీలక పదం. మనకు వినియోగదారు నిర్వచించిన డేటా రకాలు అవసరమైనప్పుడు, ‘ enum' వినియోగదారు నిర్వచించిన డేటా రకాన్ని సృష్టించడానికి కీవర్డ్ ఉపయోగించబడుతుంది. ది ' ఇ_పేరు’ అనేది ఎనమ్ క్లాస్ పేరు. ఈ తరగతి లోపల కర్లీ జంట కలుపులు దానిలోని అన్ని పారామితులు మరియు విలువలను కలిగి ఉంటాయి. మేము ఆర్గ్యుమెంట్‌లను మాత్రమే వ్రాయగలము మరియు కంపైలర్ వాటికి విలువలను కేటాయిస్తుంది. డిఫాల్ట్‌గా, ఇండెక్స్ 0లోని మొదటి విలువ స్టోర్‌ల నుండి మరియు తదుపరిది 1 నుండి మొదలవుతుంది.
ఆర్గ్యుమెంట్‌ల డేటా రకంపై ఎటువంటి పరిమితి లేదు, మేము పూర్ణాంక విలువలు, ఫ్లోటింగ్ పాయింట్ విలువలు, అక్షరాలు, బూలియన్ లేదా స్ట్రింగ్‌ను కేటాయించవచ్చు. కానీ మేము డేటా రకాలను విలువలకు కేటాయించకపోతే, అవి నిల్వ చేయబడిన స్థిరమైన విలువను స్వయంచాలకంగా కేటాయిస్తుంది.
రకాలు
C# భాషలో, రెండు రకాల గణనలు ఉన్నాయి. ఇవి క్రింద ఇవ్వబడ్డాయి:
-
- సాధారణ గణన
- జెండా గణన
సాధారణ గణన
ఈ వర్గంలో, 'enum' తరగతి సభ్యులు ఒకే విలువను కలిగి ఉంటారు.
జెండా గణన
ఈ వర్గంలో, ఫ్లాగ్ enum తరగతి సభ్యుడు బిట్‌వైస్ ఆపరేటర్‌ని ఉపయోగించి లేదా OR (|)ని ఉపయోగించి బహుళ విలువలు లేదా బహుళ విలువలను కలిగి ఉంటారు.
ఉదాహరణ 1:
ఈ సందర్భంలో, మనం సాధారణ 'enum' తరగతిని ఎలా ఉపయోగించవచ్చో మరియు వాటిని వేరియబుల్స్‌కు కేటాయించకుండా విలువలను ఎలా తిరిగి పొందవచ్చో నేర్చుకుంటాము.
C# ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో కోడింగ్ కోసం, మనం ముందుగా కొత్త ప్రాజెక్ట్‌ని సృష్టించి, ఆపై కోడింగ్ ప్రారంభించాలి. మేము కన్సోల్ అప్లికేషన్‌ను సృష్టించాలనుకున్నప్పుడు, మేము కన్సోల్ అప్లికేషన్, C# ఫ్రేమ్‌వర్క్‌ని ఎంచుకోవాలి, అది క్లాస్ మరియు మెయిన్() ఫంక్షన్‌ను స్వయంచాలకంగా వ్రాస్తుంది. కోడ్‌లో పైన ఉన్న 'enum' అనే సాధారణ పదాన్ని ఉపయోగించడానికి, మేము అంతర్గత తరగతి 'ప్రోగ్రామ్'ని నిర్వచించి, ప్రారంభిస్తాము. enum అనేది కీలక పదం మరియు enum తర్వాత వచ్చే పదం 'fruit_names'. కర్లీ జంట కలుపుల లోపల, మనకు కావలసిన జాబితాను మేము నిర్వచించాము. ఇక్కడ, enum క్లాస్ నాలుగు పండ్ల పేర్లను కలిగి ఉంది. మేము ప్రధాన () పద్ధతిలో ఉన్న అన్ని ఫంక్షన్లను పిలుస్తాము. స్టాటిక్ మెయిన్() లోపల, మేము అన్ని enum విలువలను ఒకదాని తర్వాత ఒకటి ప్రదర్శిస్తాము. ఈ కోడ్‌లో, మేము కేవలం enum ఆర్గ్యుమెంట్‌లను వ్రాస్తాము, విలువలు కాదు. కాబట్టి, అది స్వయంచాలకంగా అవి నిల్వ చేయబడిన సూచికలను విలువగా కేటాయిస్తుంది.
Console.writeline() ఫంక్షన్ అవుట్‌పుట్ స్క్రీన్‌పై వ్రాయడానికి ఉపయోగించబడుతుంది మరియు సందేశాన్ని ప్రదర్శించిన తర్వాత, అది కర్సర్‌ను తదుపరి పంక్తికి తరలిస్తుంది. ఈ స్టేట్‌మెంట్ లోపల, ఒక సందేశాన్ని వ్రాసి, నిర్వచించిన సందేశాన్ని విలువతో చూపడానికి దాన్ని ‘+’ గుర్తుతో కలపండి. సంగ్రహించిన తర్వాత 'enum పేరు' అని టైప్ చేసి, నిర్దిష్ట రకం 'enum'ని పరిష్కరించడానికి (.) ఉపయోగించండి: fruit_names.Apple. తర్వాత, తర్వాతి స్టేట్‌మెంట్‌లో, మెసేజ్ మరియు ఇండెక్స్‌తో రకాన్ని భద్రపరచడానికి మళ్లీ (+) గుర్తును ఉపయోగించండి. సూచికను పొందడానికి, మనం ముందుగా టైప్‌కాస్టింగ్ చేయడం ద్వారా దానిని పూర్ణాంకంలోకి మార్చాలి. C# రకంలో, కుండలీకరణాలను ఉపయోగించడం ద్వారా కాస్టింగ్ చేయబడుతుంది. కుండలీకరణం లోపల, మనం టైప్‌కాస్ట్ చేయాలనుకుంటున్న డేటా రకాన్ని వ్రాయండి. కుండలీకరణం వెలుపల, వేరియబుల్ పేరును వ్రాయండి అంటే (int)var_name. ఈ విధంగా, మేము సందేశాన్ని ఎనమ్ విలువ మరియు అది ఎక్కడ నిల్వ చేయబడుతుందో సూచికతో పొందవచ్చు.
దీన్ని మూడుసార్లు పునరావృతం చేయండి; సందేశం మరియు enum రకాన్ని మార్చండి. గణన కోడ్ చక్కగా మరియు శుభ్రంగా కనిపించేలా చేస్తుంది. Console.ReadKey() ఫంక్షన్ మేము కన్సోల్‌ను మూసివేసే వరకు దాన్ని సక్రియంగా ఉంచుతుంది. మేము ఈ ప్రకటనను ఉపయోగించకపోతే, కన్సోల్ ఒకసారి బ్లింక్ అవుతుంది మరియు అది అదృశ్యమవుతుంది.
ఉదాహరణ 2:
ఈ ప్రోగ్రామ్‌లో, మేము తరగతి లక్షణాలకు విభిన్న విలువలను కేటాయించడం ద్వారా సాధారణ ‘enum’ తరగతిని అమలు చేస్తాము.
రెండవ ఉదాహరణలో, మేము మళ్లీ కన్సోల్ అప్లికేషన్ కోసం ఒక ప్రాజెక్ట్‌ను సృష్టించాము మరియు 'enum' అనే కీవర్డ్‌తో అంతర్గత తరగతి 'ప్రోగ్రామ్' లోపల గణనను నిర్వచించాము. ఈసారి అది విభిన్న విలువలతో కూడిన తరగతి ‘ఐటెమ్‌లను’ కలిగి ఉంది. మెయిన్() ఫంక్షన్ లోపల, మేము enum క్లాస్ 'ఐటెమ్స్' యొక్క అన్ని ఎలిమెంట్‌లను యాక్సెస్ చేస్తాము. మనం console.writeLine() పద్ధతిని ఉపయోగించుకుందాం. ఇది దానిలో ఉన్న ప్రతిదాన్ని ప్రదర్శిస్తుంది. ముందుగా, ఒక సందేశాన్ని ప్రదర్శించి, ఆపై మళ్లీ మొదటి అంశాన్ని పరిమాణంతో ప్రదర్శించడానికి Console.WriteLine() ఫంక్షన్‌కు కాల్ చేయండి. మేము టెర్మినల్‌లో ప్రదర్శించాలనుకుంటున్న టెక్స్ట్‌ను నిర్వచించండి మరియు item.chairsతో దాన్ని సంగ్రహించండి. ఇది enum క్లాస్ 'ఐటెమ్స్' యొక్క మొదటి అంశం (కుర్చీలు) పొందుతుంది. ఈ ఐటెమ్ పరిమాణాన్ని పొందడానికి, enum క్లాస్‌లోని డేటా స్ట్రింగ్ రూపంలో ఉన్నందున మనం కాస్టింగ్ చేయాలి. కాబట్టి, వాటి విలువలను యాక్సెస్ చేయడానికి మేము మొదట cast అని టైప్ చేస్తాము. ‘కుర్చీల’ విలువను పొందడానికి, (int)items.chairs వంటి కాస్టింగ్ చేయండి. లేకపోతే, మనకు వస్తువు ‘కుర్చీలు’ మాత్రమే లభిస్తాయి, దాని విలువ కాదు. ఇక్కడ, మనం గమనించినట్లయితే, ‘\n’ మరియు ‘\t’ చిహ్నాలు ఉపయోగించబడతాయి. ‘\t’ని ఉపయోగించడం ద్వారా, మేము ట్యాబ్ స్పేస్ ఇస్తాము మరియు ‘\n’ని ఉపయోగించడం ద్వారా మేము కర్సర్‌ను తదుపరి పంక్తికి తరలిస్తాము. ఈ విధానాన్ని రెండుసార్లు పునరావృతం చేయండి. మేము కేవలం enum విలువలను నవీకరించాలి. ముగింపులో, కన్సోల్‌ను యాక్టివ్‌గా ఉంచడానికి కన్సోల్‌ను వ్రాయండి.ReadKey() తద్వారా మనం అవుట్‌పుట్‌ను చూడగలుగుతాము.
ఉదాహరణ 3:
మేము ఈ దృష్టాంతంలో 'జెండా' ఎనుమ్‌ను ఉపయోగించబోతున్నాము.
సాధారణ గణనలో, మేము enum తరగతి సభ్యునికి ఒక విలువను మాత్రమే కేటాయించగలము. కానీ ఫ్లాగ్ ఎన్యూమరేషన్‌తో, మేము enum క్లాస్‌లోని ఒక సభ్యునికి ఒకటి కంటే ఎక్కువ విలువలను కేటాయించవచ్చు. మేము వేర్వేరు ఎంపికలతో వ్యవహరించేటప్పుడు మరియు మనకు ఒకటి కంటే ఎక్కువ విలువలు ఉన్నప్పుడు ఈ రకమైన గణన సహాయపడుతుంది. ఫ్లాగ్ గణనను ఉపయోగించడానికి, enum తరగతిని నిర్వచించే ముందు, మనం [ఫ్లాగ్‌లు] వ్రాసి, ఆపై enum క్లాస్ 'flag_example' అని వ్రాయాలి. ఇప్పుడు, ఈ తరగతి లోపల, మనం ఒక సభ్యునికి ఒకటి కంటే ఎక్కువ విలువలను సులభంగా కేటాయించవచ్చు. ఈ ఉదాహరణలో, మేము 'డ్రైవర్' లక్షణానికి రెండు విలువలను కేటాయించాము మరియు (|) ఆపరేటర్‌ని ఉపయోగించి రెండు విలువలను వేరు చేసాము. అప్పుడు, మెయిన్() ఫంక్షన్‌లో వేరియబుల్ 'var ఫ్లాగ్స్' డిక్లేర్ చేయండి. కన్సోల్‌లో ఒకటి కంటే ఎక్కువ ఐటెమ్‌లను చూపించడానికి, లేదా (|) ఆపరేటర్‌ని ఉపయోగించుకోండి, ఆపై తరగతి పేరు మరియు ఐటెమ్ పేరుతో enum ఐటెమ్‌లను కాల్ చేయండి. సందేశాన్ని ప్రదర్శించడానికి, Console.WriteLine() పద్ధతిని అమలు చేయండి. ఫ్లాగ్ విలువను సూచించడానికి, మరొక కన్సోల్‌లో 'ఫ్లాగ్' అని వ్రాయండి.Write(). తర్వాతి స్టేట్‌మెంట్‌లో Console.ReadKey() ఫంక్షన్ అంటారు, అది కన్సోల్‌ను మూసివేసే వరకు తెరిచి ఉంచుతుంది.
ముగింపు
ఈ గైడ్‌లో, గణన గురించి, అది ఏమిటి మరియు దానిని మనం C# భాషలో ఎలా ఉపయోగించవచ్చో తెలుసుకున్నాము. గణన కోడ్‌ని సరళంగా మరియు చదవగలిగేలా చేస్తుంది. ఎందుకంటే enum క్లాస్‌లోని విలువలు మార్చబడవు. మారుతున్న విలువలు అవసరం లేని అటువంటి డేటాతో మేము వ్యవహరిస్తున్నప్పుడు ఇది మాకు ప్రయోజనాలను అందిస్తుంది. మేము వివిధ కోడ్‌ల సహాయంతో సింటాక్స్ మరియు గణన రకాలను చర్చించాము. గణన తక్కువ మెమరీని తీసుకుంటుంది మరియు ఉపయోగించడానికి సులభమైనది.