విషయము

• శీఘ్ర పరిచయం - C # vs జావా
• హలో వరల్డ్! సి # లో
• C # తో ప్రారంభించడం: పద్ధతులు మరియు తరగతులు
• పద్ధతులను ఉపయోగించడం
• వేరియబుల్స్ ఉపయోగించి
• వాదనలు దాటడం మరియు తీగలను ఉపయోగించడం
• సి # ప్రవాహ నియంత్రణను నేర్చుకోండి మరియు సాధారణ క్విజ్‌లను రూపొందించండి!
• వచ్చే సారి

ఈ పోస్ట్‌లో, మీరు ఆండ్రాయిడ్ కోసం సి # ప్రోగ్రామింగ్ గురించి, అలాగే ఆండ్రాయిడ్ డెవలప్‌మెంట్ యొక్క గొప్ప పథకంలో ఎక్కడ సరిపోతుందో తెలుసుకుంటారు.

మీరు Android డెవలపర్ కావడానికి ఆసక్తి కలిగి ఉంటే, మీరు జావా లేదా కోట్లిన్ అనే రెండు భాషలలో ఒకదాన్ని నేర్చుకోవాలి అనే అభిప్రాయంలో ఉండవచ్చు. ఆండ్రాయిడ్ స్టూడియో అధికారికంగా మద్దతు ఇచ్చే రెండు భాషలు ఇవి, అందువల్ల రెండు భాషలు చాలా గైడ్‌లు మరియు ట్యుటోరియల్‌లపై దృష్టి సారించాయి. ఆండ్రాయిడ్ అభివృద్ధి దాని కంటే చాలా సరళమైనది మరియు వైవిధ్యమైనది మరియు దానిని చేరుకోవడానికి చాలా ఎక్కువ మార్గాలు ఉన్నాయి. వీటిలో చాలా వరకు C # ఉంటుంది.

చదవండి:నేను Android అనువర్తనాలను అభివృద్ధి చేయాలనుకుంటున్నాను - నేను ఏ భాషలను నేర్చుకోవాలి?

C # అనేది మీరు యూనిటీలో ఒక ఆటను నిర్మించాలనుకుంటే మీరు ఉపయోగించే ప్రోగ్రామింగ్ భాష - ఇది ప్లే స్టోర్‌లో అత్యంత ప్రాచుర్యం పొందిన మరియు విస్తృతంగా ఉపయోగించబడే గేమ్ ఇంజిన్‌గా కూడా జరుగుతుంది. సాధారణంగా, మీరు ఆట అభివృద్ధిపై ఆసక్తి కలిగి ఉంటే సి # ప్రోగ్రామింగ్ నేర్చుకోవడం ఉపయోగపడుతుంది.

మీరు Xamarin ఉపయోగించాలనుకుంటే మీరు C # ప్రోగ్రామింగ్ కూడా నేర్చుకోవాలి. Xamarin అనేది విజువల్ స్టూడియోని ఉపయోగించి అనువర్తనాలను రూపొందించడానికి డెవలపర్‌లను అనుమతించే ఒక సాధనం, ఇది iOS మరియు Android రెండింటికీ సులభంగా పోర్ట్ చేయగలదు, ఇది క్రాస్ ప్లాట్‌ఫాం ప్రాజెక్ట్‌లకు సరైనది.

కాబట్టి, ఆండ్రాయిడ్ కోసం సి # ప్రోగ్రామింగ్ నేర్చుకోవడానికి ఖచ్చితంగా మంచి కారణం ఉంది. మీరు తెలుసుకోవలసిన వాటిని పరిశీలిద్దాం.

శీఘ్ర పరిచయం - C # vs జావా

సి # అనేది ఒక ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్, దీనిని మైక్రోసాఫ్ట్ 2000 లో అభివృద్ధి చేసింది, ఇది ఆధునిక, సరళమైన మరియు సౌకర్యవంతమైనది. జావా మాదిరిగా (1990 లో సన్ మైక్రోసిస్టమ్ అభివృద్ధి చేసింది), ఇది మొదట సి ++ నుండి ఉద్భవించింది, ఈ రెండింటి మధ్య చాలా సారూప్యతలు ఉన్నాయని నిర్ధారిస్తుంది. ఉదాహరణకు, రెండూ ఒకే “వాక్యనిర్మాణ స్థావరాన్ని” ఉపయోగిస్తాయి, అంటే అవి ఒకే పరిభాష మరియు నిర్మాణాన్ని చాలా సమర్థవంతంగా ఉపయోగిస్తాయి. కొన్ని చిన్న తేడాలు ఉన్నాయి, కానీ మీకు ఒక భాష గురించి తెలిసి ఉంటే, మీరు ప్రత్యేకంగా నేర్చుకోవలసిన అవసరం లేకుండానే చాలా ఇతర భాషలను అర్థం చేసుకోగలుగుతారు. ప్రారంభకులకు, సి # ప్రోగ్రామింగ్ నేర్చుకోవడం కొంచెం సులభం అని చాలామంది కనుగొంటారు.

ఆబ్జెక్ట్-ఓరియెంటెడ్-లాంగ్వేజెస్ వలె, సి # మరియు జావా రెండూ తరగతుల ద్వారా వస్తువులను వివరిస్తాయి. ఇది ప్రోగ్రామింగ్‌కు మాడ్యులర్ విధానం, ఇది కోడ్ యొక్క స్నిప్పెట్‌లను పదే పదే ఉపయోగించడానికి అనుమతిస్తుంది.

సి # జావా నుండి భిన్నంగా ఉన్నప్పటికీ, దాని ప్రతినిధుల ఉపయోగంలో ఉంది, ఈవెంట్ లిజనింగ్, వర్చువల్ వర్సెస్ ఫైనల్ ప్రాపర్టీస్, ఇంప్లిసిట్ కాస్టింగ్ మరియు మరిన్ని.

శుభవార్త: మీరు మొదట C # నేర్చుకోవడం ప్రారంభించినప్పుడు దీని అర్థం ఏమిటో మీరు నిజంగా తెలుసుకోవలసిన అవసరం లేదు. ప్రధాన టేకావే ఏమిటంటే, నిర్మాణం సి # లో నేర్చుకోవడం కొంచెం సులభం మరియు తక్కువ టైపింగ్ అవసరం. మీరు Android కోసం జావా నేర్చుకున్నప్పుడు, Android అనువర్తనాలను రూపొందించడానికి అవసరమైన అనేక తరగతులు మరియు API ల గురించి కూడా మీరు తెలుసుకోవాలి. అందువల్ల, మీరు జావాకు మెట్టుగా సి # ప్రోగ్రామింగ్‌ను కూడా నేర్చుకోవచ్చు.

హలో వరల్డ్! సి # లో

కోడింగ్ ప్రపంచంలో సాంప్రదాయం ఏమిటంటే, మీరు ఎప్పుడైనా క్రొత్త భాషను నేర్చుకున్నప్పుడు, తెరపై “హలో వరల్డ్!” ప్రదర్శించడానికి మీరు ఒక సాధారణ ప్రోగ్రామ్‌ను సృష్టించాలి. ఇది ప్రాథమికంగా మీరు అవసరమైన సాధనాలను పొందగలరని మరియు సరళమైనదాన్ని సంకలనం చేయగలదని నిర్ధారిస్తుంది. ఇది మైక్రోఫోన్‌లో “పరీక్ష, పరీక్ష, 1, 2, 3” చదవడం లాంటిది!

ఈ సందర్భంలో, మేము కన్సోల్ అనువర్తనాన్ని సృష్టించడానికి విజువల్ స్టూడియోని ఉపయోగించబోతున్నాము. కాబట్టి మీరు ముందుకు వెళ్లి విజువల్ స్టూడియోని డౌన్‌లోడ్ చేసిన తర్వాత (ఇది ఉచితం), క్లిక్ చేయండి:

ఫైల్> క్రొత్త> ప్రాజెక్ట్

ఆపై:

విజువల్ సి #> విండోస్ క్లాసిక్ డెస్క్‌టాప్> కన్సోల్ అనువర్తనం (.నెట్ ఫ్రేమ్‌వర్క్)

విండోస్ కన్సోల్‌లో అమలు అయ్యే అనువర్తనాన్ని మేము ఈ విధంగా నిర్మిస్తాము.

అది పూర్తయిన తర్వాత, మీ ప్రాజెక్ట్ యొక్క ఎముకల నిర్మాణం ప్రధాన విండోలో కనిపిస్తుంది. మీకు ఇలా కనిపించే కోడ్ మీకు అందించబడుతుంది:

నేమ్‌స్పేస్ కన్సోల్అప్ 3 {క్లాస్ ప్రోగ్రామ్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్) {}}}

ఇప్పుడు ఇలా రెండు పంక్తులను జోడించండి:

నేమ్‌స్పేస్ కన్సోల్అప్ 3 {క్లాస్ ప్రోగ్రామ్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్) {కన్సోల్.రైట్‌లైన్ ("హలో వరల్డ్!"); Console.ReadKey (); }}}

ఇది స్క్రీన్‌కు “హలో వరల్డ్!” అని వ్రాయబోతుంది, ఆపై కీ ప్రెస్ కోసం వేచి ఉంటుంది. వినియోగదారు ఏదైనా కీని తాకిన తర్వాత, ప్రోగ్రామ్ ముగింపుకు వస్తుంది మరియు స్వయంచాలకంగా నిష్క్రమిస్తుంది.

ఈ రెండు పంక్తులు సెమికోలన్‌తో ముగుస్తాయని గమనించండి. ఎందుకంటే సి # లోని ఏదైనా స్టేట్‌మెంట్ సెమికోలన్‌తో ముగుస్తుంది, ఇది సి # కి లైన్ పూర్తయిందని కమ్యూనికేట్ చేస్తుంది (ఇది జావాలో కూడా అదే). ఓపెన్ బ్రాకెట్ ద్వారా పంక్తిని వెంటనే అనుసరించినప్పుడు మాత్రమే మినహాయింపు, ఇది మేము క్షణంలో వివరిస్తాము.

స్క్రీన్ ఎగువన ఉన్న “ప్రారంభించు” బటన్‌ను నొక్కండి, మరియు ఇది అనువర్తనాన్ని ప్రారంభించాలి, ఇది ఆచరణలో చూడటానికి మిమ్మల్ని అనుమతిస్తుంది.

తరగతులు అంటే వస్తువులను వివరించే కోడ్ ముక్కలు, ఇవి సమర్థవంతంగా డేటా ముక్కలు

కాబట్టి, ఇక్కడ ఖచ్చితంగా ఏమి జరుగుతోంది?

C # తో ప్రారంభించడం: పద్ధతులు మరియు తరగతులు

Android కోసం C # ప్రోగ్రామింగ్ నేర్చుకోవడానికి, మీరు తరగతులు మరియు పద్ధతులను అర్థం చేసుకోవాలి.

తరగతులు అంటే వస్తువులను వివరించే కోడ్ ముక్కలు, ఇవి సమర్థవంతంగా డేటా ముక్కలు. దీనితో ప్రారంభించడానికి మీరు పెద్దగా ఆందోళన చెందాల్సిన అవసరం లేదు: మీరు ప్రస్తుతం పనిచేస్తున్న కోడ్ యొక్క పేజీని “క్లాస్” అని పిలుస్తారు మరియు మీ ప్రాజెక్ట్‌లోని ఇతర తరగతులతో సంభాషించవచ్చని తెలుసుకోండి. ఒక ప్రాజెక్ట్ కేవలం ఒక తరగతిని కలిగి ఉంటుంది, మీ కోడ్ అంతా అక్కడ నుండి పనిచేస్తుంది లేదా దానికి బహుళ ఉంటుంది.

ప్రతి తరగతి లోపల, మీకు పద్ధతులు కూడా ఉంటాయి. ఈ పద్ధతులు కోడ్ యొక్క స్నిప్పెట్స్, మీరు ఎప్పుడైనా ఆ తరగతి నుండి - మరియు కొన్నిసార్లు దాని వెలుపల నుండి సూచించవచ్చు.

ఈ సందర్భంలో, తరగతి అంటారు ప్రోగ్రామ్. క్లాస్ ప్రోగ్రామ్: ఇది చదివిన పంక్తి ద్వారా ఎగువ భాగంలో నిర్వచించబడుతుంది. మరియు మీరు కుడి వైపున “సొల్యూషన్ ఎక్స్‌ప్లోరర్” విండోను తెరిస్తే, మీరు Program.cs ను కనుగొనగలరు. తరగతి పేరు ఎల్లప్పుడూ ఫైల్ పేరుతో సమానంగా ఉంటుంది.

మేము అనుసరించే అన్ని కోడ్‌లను కలిగి ఉండటానికి కర్లీ బ్రాకెట్‌ను ఉపయోగిస్తాము. వంకర బ్రాకెట్లు అనుసరించే ప్రతిదీ కలిసి ఉన్నాయని మాకు చెబుతుంది. అందువల్ల, బ్రాకెట్ మూసివేసే వరకు, ఈ క్రింది అన్ని కోడ్ ప్రోగ్రామ్‌లో భాగం.

ఇది మా మొదటి పద్ధతి తరువాత, ఈ క్రింది పంక్తి ద్వారా నిర్వచించండి:

స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్)

దీని తరువాత మరింత ఓపెన్ బ్రాకెట్‌లు అనుసరిస్తాయి, అనగా తదుపరి బిట్ కోడ్ “మెయిన్” పద్ధతిలో భాగం (ఇది ఇప్పటికీ ప్రోగ్రామ్ క్లాస్ లోపల ఉంది). అక్కడే మేము మా “హలో వరల్డ్” ను ఉంచాము.

“స్టాటిక్ శూన్యత” తప్పనిసరిగా ఈ పద్ధతి స్వయం ప్రతిపత్తిని (విస్తృత ప్రోగ్రామ్ ఉపయోగించాల్సిన డేటాను మార్చడం కంటే) చేస్తుంది మరియు బయటి తరగతులచే సూచించబడదని మాకు చెబుతుంది. "స్ట్రింగ్ అర్గ్స్" స్టఫ్ తరువాత సమాచారాన్ని మార్చటానికి పద్ధతిలో సమాచారాన్ని పంపించడానికి అనుమతిస్తుంది. వీటిని “పారామితులు” మరియు “వాదనలు” అంటారు. మళ్ళీ, మీరు దీని గురించి ఇంకా ఆందోళన చెందాల్సిన అవసరం లేదు. “స్టాటిక్ శూన్యత” తరువాత ఒక పదం, బ్రాకెట్‌లు మరియు వంకర బ్రాకెట్‌లు కొత్త పద్ధతి యొక్క ప్రారంభాన్ని సూచిస్తాయని తెలుసుకోండి.

తరువాతి రెండు పంక్తులు మేము జోడించినవి: అవి కన్సోల్‌ని పొందుతాయి, ఆపై స్క్రీన్‌కు వ్రాయడానికి దాని ఆదేశాలను యాక్సెస్ చేస్తాయి మరియు కీ ప్రెస్ కోసం వేచి ఉంటాయి.

చివరగా, మేము మా అన్ని బ్రాకెట్లను మూసివేస్తాము: మొదట పద్ధతి, తరువాత తరగతి, ఆపై తరగతికి చెందిన ప్రాజెక్ట్ పేరు అయిన “నేమ్‌స్పేస్” (ఈ సందర్భంలో “కన్సోల్ఆప్ 3” - నేను మునుపటి పరీక్ష అనువర్తనాలను ఈ విధంగా చేసాను) .

గందరగోళం? చింతించకండి, ఇది మరింత అర్ధవంతం కానుంది.

పద్ధతులను ఉపయోగించడం

కాబట్టి పద్ధతులు పేర్లతో కూడిన కోడ్ యొక్క కట్టలు. మేము పద్ధతులను ఎందుకు ఉపయోగిస్తున్నామో ప్రదర్శించడానికి, క్రొత్తదాన్ని సృష్టించడానికి మరియు దానిని ఉదాహరణగా ఉంచడానికి ఇది సహాయపడుతుంది.

కాబట్టి, ప్రోగ్రామ్ తరగతిలో నివసించే క్రొత్త పద్ధతిని సృష్టించండి (కనుక ఇది ఆ వంకర బ్రాకెట్లలో ఉండాలి, కానీ “మెయిన్” కి చెందిన వంకర బ్రాకెట్ల వెలుపల ఉండాలి).

ఈ “న్యూ మెథడ్” కి కాల్ చేసి, ఆపై మీరు వ్రాసిన రెండు పంక్తులను ఇక్కడ ఉంచండి. ఇది ఇలా ఉండాలి:

తరగతి ప్రోగ్రామ్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్)}} స్టాటిక్ శూన్య న్యూమెథడ్ () {కన్సోల్.రైట్‌లైన్ ("హలో వరల్డ్!"); Console.ReadKey (); }}

ఇప్పుడు మీ ప్రధాన పద్ధతిలో న్యూమెథడ్‌కు సూచనను జోడించండి:

స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్) New ar న్యూమెథడ్ (); }

ఇది మీరు సృష్టించిన పద్ధతిని "కాల్" చేయబోతోంది, ముఖ్యంగా ప్రోగ్రామ్‌ను ఆ దిశలో నిర్దేశిస్తుంది. ప్రారంభం నొక్కండి మరియు మునుపటిలాగే అదే జరుగుతుందని మీరు చూస్తారు. మీరు కోరుకుంటే ఇప్పుడు తప్ప, మీరు “న్యూమెథడ్ ();” ను మీకు కావలసినన్ని సార్లు వ్రాయవచ్చు మరియు చాలా కోడ్ రాయకుండా వచనాన్ని పునరావృతం చేయవచ్చు.

ఒక భారీ ప్రోగ్రామ్ సమయంలో, ఈ విధమైన కోడ్ యొక్క స్నిప్పెట్లను సూచించటం చాలా శక్తివంతమైనది. మీరు Android కోసం C # ప్రోగ్రామింగ్ నేర్చుకోవడానికి ప్రయత్నించినప్పుడు అర్థం చేసుకోవలసిన ముఖ్యమైన విషయాలలో ఇది ఒకటి.

మనకు ఈ విధంగా నచ్చినంత ఎక్కువ పద్ధతులను సృష్టించవచ్చు మరియు ఆ విధంగా చాలా చక్కగా మరియు వ్యవస్థీకృత కోడ్ ఉంటుంది. అదే సమయంలో, మేము C # కు “అంతర్నిర్మిత” పద్ధతులను మరియు మనం ఉపయోగించగల ఏదైనా లైబ్రరీలను కూడా సూచించవచ్చు. “అంతర్నిర్మిత” పద్ధతికి “మెయిన్” ఒక ఉదాహరణ. ఇది అన్ని ప్రోగ్రామ్‌లతో ప్రారంభమయ్యే పద్ధతి, మరియు ఇది మొదట అమలు చేయాలని సి # అర్థం చేసుకుంటుంది. మీరు ఇక్కడ ఏమీ ఉంచకపోతే, అప్పుడు ఏమీ జరగదు!

ఈ సందర్భంలో బ్రాకెట్లలో చేర్చబడిన వాదనలు మాత్రమే అవసరమవుతాయి ఎందుకంటే మైక్రోసాఫ్ట్ ప్రధాన పద్ధతిని రూపొందించింది. మేము మా బ్రాకెట్లను ఖాళీగా ఉంచడం మంచిది.

వేరియబుల్స్ ఉపయోగించి

ఇప్పుడు మా కోడ్‌లో కొంచెం ఆసక్తికరంగా ఏదైనా చేయాల్సిన సమయం వచ్చింది. ప్రత్యేకంగా, ప్రోగ్రామ్‌ను మరింత డైనమిక్‌గా చేయడానికి మీరు వేరియబుల్స్‌ను ఎలా ఉపయోగిస్తారో చూద్దాం. మీరు సి # ప్రోగ్రామింగ్ నేర్చుకోవాలనుకుంటే అర్థం చేసుకోవలసిన ముఖ్యమైన విషయాలలో ఇది ఒకటి.

వేరియబుల్ ప్రాథమికంగా డేటా యొక్క ఒక కంటైనర్. మీ మనస్సును హైస్కూల్ గణితానికి తిరిగి పంపండి మరియు మీరు ఇలాంటివి చూసినట్లు గుర్తుంచుకోవచ్చు:

10 + x = 13
X ను కనుగొనండి

ఇక్కడ, “x” ఒక వేరియబుల్, మరియు అది సూచించే విలువ “3”.

ప్రోగ్రామింగ్‌లో వేరియబుల్ ఎలా పనిచేస్తుందో కూడా ఇదే. ఇక్కడ తప్ప, వేరియబుల్ వివిధ రకాల డేటాను సూచిస్తుంది: టెక్స్ట్‌తో సహా.

క్రొత్త వేరియబుల్ సృష్టించడానికి, మనం మొదట C # కి ఏ రకమైన డేటాను కలిగి ఉండబోతున్నామో చెప్పాలి.

కాబట్టి మీ న్యూమెథడ్ () పద్ధతిలో, మొదట మీరు మీ వేరియబుల్‌ని క్రియేట్ చేస్తారు, ఆపై మీరు దానికి విలువను కేటాయిస్తారు. అప్పుడు మేము దీన్ని మా “రైట్‌లైన్” ఆదేశానికి జోడించబోతున్నాము:

పూర్ణాంక సంఖ్య; సంఖ్య = 10; కన్సోల్.రైట్‌లైన్ ("హలో వరల్డ్!" + సంఖ్య);

మేము “పూర్ణాంకం” అని పిలువబడే ఒక రకమైన వేరియబుల్‌ని ఉపయోగించాము, అది మొత్తం సంఖ్య కావచ్చు. C # లో, మేము వీటిని “int” ఉపయోగించి సూచిస్తాము. అయినప్పటికీ, మేము "ఫ్లోట్" ను సులభంగా ఉపయోగించుకోవచ్చు, ఇది "ఫ్లోటింగ్ పాయింట్ వేరియబుల్" మరియు దశాంశ స్థానాలను ఉపయోగించడానికి అనుమతిస్తుంది.

మీరు ఈ కోడ్‌ను అమలు చేస్తే, అది ఇప్పుడు “హలో వరల్డ్! 10 ”తెరపైకి. వాస్తవానికి, మనం మార్చడానికి “సంఖ్య” విలువను ఎప్పుడైనా మార్చవచ్చు.

న్యూమెథడ్ () లో “సంఖ్య” సృష్టించబడినందున, మేము దానిని మా కోడ్‌లోని ఇతర ప్రాంతాల నుండి యాక్సెస్ చేయలేము. కానీ మేము దానిని అన్ని పద్ధతుల వెలుపల ఉంచితే, అది ప్రపంచవ్యాప్తంగా అందుబాటులోకి వస్తుంది. అలా చేయడానికి, వేరియబుల్ కూడా స్థిరంగా ఉందని మేము నిర్ధారించుకోవాలి:

తరగతి ప్రోగ్రామ్ {స్టాటిక్ పూర్ణాంక సంఖ్య = 10; స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్) {న్యూమెథడ్ (); } స్టాటిక్ శూన్యమైన న్యూ మెథడ్ () {కన్సోల్.రైట్‌లైన్ ("హలో వరల్డ్!" + సంఖ్య); Console.ReadKey (); }}

చివరగా, ఈ డేటాను మనం దాటవేయడానికి మరో మార్గం ఉంది, మరియు దానిని వాదనగా ఉపయోగించడం, తద్వారా దానిని మా పద్ధతిలోకి పంపించడం. ఇది ఇలా ఉండవచ్చు:

స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్) {int సంఖ్య = 10; కన్సోల్.రైట్‌లైన్ ("హాయ్, మీ పేరు ఏమిటి?"); NewMethod (సంఖ్య); } స్టాటిక్ శూన్య న్యూమెథడ్ (పూర్ణాంక సంఖ్య) {కన్సోల్.రైట్‌లైన్ ("హలో వరల్డ్!" + సంఖ్య); Console.ReadKey (); }}

ఇక్కడ, మేము మా న్యూమెథడ్ పద్ధతిని ఒక వాదన అవసరం అని నిర్వచించాము, ఇది ఒక పూర్ణాంకం అయి ఉండాలి మరియు ఇది పద్ధతిలో “సంఖ్య” గా సూచించబడుతుంది. మేము ఆ సమాచారాన్ని కర్లీ బ్రాకెట్‌లకు జోడించడం ద్వారా దీన్ని చేస్తాము. అప్పుడు, మేము ప్రోగ్రామ్‌లో మరెక్కడా నుండి పద్ధతిని పిలిచినప్పుడు, ఆ విలువను బ్రాకెట్లలో “పాస్” చేయాలి. మీరు బహుళ పారామితులతో పద్ధతులను సృష్టించవచ్చు, ఈ సందర్భంలో మీరు కామాతో జాబితా చేయబడిన వేరియబుల్స్‌ను వేరు చేస్తారు.

డేటాను మోసగించడానికి ఈ విభిన్న వ్యూహాలను ఉపయోగించడం సముచితమైన విభిన్న దృశ్యాలు ఉన్నాయి. మంచి ప్రోగ్రామింగ్ అంటే ఉద్యోగానికి సరైనదాన్ని కనుగొనడం!

వాదనలు దాటడం మరియు తీగలను ఉపయోగించడం

ఈ తదుపరి కోడ్‌ను అమలు చేయడానికి ప్రయత్నించండి మరియు ఏమి జరుగుతుందో చూడండి:

తరగతి ప్రోగ్రామ్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్) {కన్సోల్.రైట్‌లైన్ ("హాయ్, మీ పేరు ఏమిటి?"); NewMethod (Console.ReadLine ()); } స్టాటిక్ శూన్యమైన న్యూమెథడ్ (స్ట్రింగ్ యూజర్‌నేమ్) {కన్సోల్.రైట్‌లైన్ ("హలో" + యూజర్‌నేమ్); Console.ReadKey (); }}

మీరు మీ పేరును నమోదు చేయమని ప్రాంప్ట్ చేయబడ్డారని మరియు కన్సోల్ దాని ద్వారా మీకు గొప్పదని మీరు కనుగొనాలి. ఈ సరళమైన కోడ్‌లో చాలా ఉపయోగకరమైన పాఠాలు ఉన్నాయి.

మొదట, స్ట్రింగ్ అని పిలువబడే వేరే రకం వేరియబుల్‌ను ఎలా ఉపయోగించాలో ఉదాహరణను చూస్తాము. స్ట్రింగ్ అనేది అక్షరాల శ్రేణి, ఇది పేరు కావచ్చు లేదా మొత్తం కథ కావచ్చు.

కాబట్టి, మీరు యూజర్‌నేమ్ = “ఆడమ్” ను సులభంగా వ్రాయవచ్చు. బదులుగా, మేము కన్సోల్ నుండి కన్సోల్ నుండి స్ట్రింగ్ పొందుతున్నాము: కన్సోల్. రీడ్లైన్ ().

మేము వ్రాసి ఉండవచ్చు:

స్ట్రింగ్ యూజర్; వాడుకరి = కన్సోల్.రెడ్‌లైన్ (); NewMethod (వాడుకరి);

కానీ మా కోడ్‌ను సాధ్యమైనంత చక్కగా ఉంచడానికి, మేము ఆ దశలను దాటవేసి “రీడ్‌లైన్” ను నేరుగా బ్రాకెట్లలో ఉంచాము.

మేము ఆ స్ట్రింగ్‌ను మా న్యూమెథడ్‌కి పంపుతాము మరియు మీకు ఇప్పటికే తెలిసిన పద్ధతిని ఉపయోగించి మేము వినియోగదారుని పలకరిస్తాము.

స్ట్రింగ్ అనేది అక్షరాల శ్రేణి, ఇది పేరు కావచ్చు లేదా మొత్తం కథ కావచ్చు.

ఆశాజనక, మీరు ఇప్పుడు C # ను ఎందుకు వ్రాశారు, మరియు కొన్ని సరళమైన మరియు శక్తివంతమైన సాఫ్ట్‌వేర్‌లను సృష్టించడానికి వేరియబుల్స్ మరియు పద్ధతులు వంటి వాటిని ఎలా ఉపయోగించవచ్చనే దాని గురించి మీరు కొంచెం అర్థం చేసుకోవడం ప్రారంభించారు.

మీరు సి # ప్రోగ్రామింగ్ నేర్చుకోవాలనుకుంటే మీరు తెలుసుకోవలసిన మరో ముఖ్యమైన అంశం ఉంది: ప్రవాహ నియంత్రణ.

సి # ప్రవాహ నియంత్రణను నేర్చుకోండి మరియు సాధారణ క్విజ్‌లను రూపొందించండి!

కోడింగ్ చేసేటప్పుడు మనం వేరియబుల్స్ ఉపయోగించే ఒక కారణం, తద్వారా మన ప్రోగ్రామ్‌లను సులభంగా సవరించవచ్చు. మరొకటి మీరు యూజర్ నుండి సమాచారాన్ని పొందవచ్చు లేదా యాదృచ్ఛికంగా ఉత్పత్తి చేయవచ్చు.

C # వేరియబుల్స్ నేర్చుకోవటానికి బహుశా మంచి కారణం, తద్వారా మీ ప్రోగ్రామ్‌లు డైనమిక్ అవుతాయి: తద్వారా అవి ఎలా ఉపయోగించబడుతున్నాయో బట్టి అవి భిన్నంగా స్పందించగలవు.

అందుకోసం, మాకు “ప్రవాహ నియంత్రణ” లేదా “షరతులతో కూడిన ప్రకటనలు” అవసరం. ఇవి నిజంగా వేరియబుల్ విలువను బట్టి ఒకటి కంటే ఎక్కువ మార్గాల్లో కోడ్‌ను అమలు చేయబోతున్నామని చెప్పే అద్భుత మార్గాలు.

మరియు దీన్ని చేయడానికి అత్యంత శక్తివంతమైన మార్గాలలో ఒకటి “if” స్టేట్‌మెంట్‌తో ఉంటుంది. ఈ ఉదాహరణలో, మా ప్రధాన వినియోగదారుని వారి వినియోగదారు పేరు కోసం చూడటం ద్వారా ఇతరులకన్నా భిన్నంగా పలకరించండి.

స్టాటిక్ శూన్యమైన న్యూమెథడ్ (స్ట్రింగ్ యూజర్‌నేమ్) {కన్సోల్.రైట్‌లైన్ ("హలో" + యూజర్‌నేమ్); if (UserName.Equals ("Adam")) {Console.WriteLine ("స్వాగతం తిరిగి సర్"); } కన్సోల్.రెడ్‌కే (); }

స్టేట్మెంట్ యొక్క ప్రామాణికతను పరీక్షించడం ద్వారా “ఉంటే” స్టేట్‌మెంట్‌లు పనిచేస్తాయి, ఇది బ్రాకెట్లలోకి వెళ్తుంది. ఈ సందర్భంలో, స్ట్రింగ్ యూజర్‌నేమ్ “ఆడమ్” స్ట్రింగ్‌కు సమానమా అని మేము అడుగుతున్నాము. బ్రాకెట్లలోని ఆ ప్రకటన నిజమైతే - రెండు తీగలు ఒకేలా ఉంటాయి - అప్పుడు కింది వంకర బ్రాకెట్లలోని కోడ్ అమలు అవుతుంది. అది కాకపోతే, ఆ పంక్తులు దాటవేయబడతాయి.

అదేవిధంగా, మనం పూర్ణాంకాలు మరియు ఫ్లోట్లను పోల్చవచ్చు మరియు ఒకటి ఒకదానికొకటి పెద్దదా అని మనం పరీక్షించవచ్చు. మొదలైనవి రష్యన్ బొమ్మల మాదిరిగా ఒకదానికొకటి స్టేట్మెంట్ ఉంటే మనం కూడా చాలా భిన్నంగా ఉపయోగించవచ్చు. మేము వీటిని “నెస్టెడ్ ఇఫ్స్” అని పిలుస్తాము.

వచ్చే సారి

ప్రవాహ నియంత్రణ కోసం మీరు ఇంకా చాలా వ్యూహాలను ఉపయోగించవచ్చు - స్విచ్ స్టేట్‌మెంట్‌లు వంటి వాటితో సహా. ఆశాజనక అయితే, కొన్ని ఉపయోగకరమైన విషయాలు తయారు చేయడం ప్రారంభించడానికి మేము ఈ ప్రకటనలు మరియు పద్ధతులను ఎలా ఉపయోగించవచ్చో మీరు ఇప్పటికే చూడవచ్చు. మీరు ఇప్పటికే ఈ కోడ్‌ను క్విజ్‌గా సులభంగా మార్చవచ్చు!

చివరికి యూనిటీ వంటి సాధనాలతో సి # పూర్తిగా ఫంక్షనల్ ఆటలను రూపొందించడానికి మిమ్మల్ని అనుమతిస్తుంది!

కానీ నిజంగా ఆకట్టుకునే సాధనాలు మరియు ఆటలను చేయడానికి, మనం అన్వేషించాల్సిన మరికొన్ని విషయాలు ఉన్నాయి. కాబట్టి ఆశ్చర్యం! రెండవ భాగం ఉండబోతోంది!

తరువాతి పాఠంలో, కాలక్రమేణా మళ్ళించే లూప్‌లను ఎలా సృష్టించాలో, అలాగే కొత్త తరగతులను ఎలా సృష్టించాలో మరియు వాటితో ఎలా వ్యవహరించాలో మీరు కనుగొంటారు. మరలా కలుద్దాం!