உள்ளடக்கம்

• ஒரு விரைவான அறிமுகம் - சி # vs ஜாவா
• வணக்கம் உலகம்! சி # இல்
• சி # உடன் தொடங்குதல்: முறைகள் மற்றும் வகுப்புகள்
• முறைகளைப் பயன்படுத்துதல்
• மாறிகளைப் பயன்படுத்துதல்
• வாதங்களை கடந்து சரங்களை பயன்படுத்துதல்
• சி # ஓட்டக் கட்டுப்பாட்டைக் கற்றுக் கொள்ளுங்கள் மற்றும் எளிய வினாடி வினாக்களை உருவாக்குங்கள்!
• அடுத்த முறை

இந்த இடுகையில், Android க்கான C # நிரலாக்கத்தைப் பற்றியும், அண்ட்ராய்டு வளர்ச்சியின் மகத்தான திட்டத்தில் அது எங்கு பொருந்துகிறது என்பதையும் அறிந்து கொள்வீர்கள்.

Android டெவலப்பராக மாற நீங்கள் விரும்பினால், ஜாவா அல்லது கோட்லின் என்ற இரண்டு மொழிகளில் ஒன்றைக் கற்றுக்கொள்ள வேண்டும் என்ற எண்ணத்தில் நீங்கள் இருக்கலாம். அண்ட்ராய்டு ஸ்டுடியோ அதிகாரப்பூர்வமாக ஆதரிக்கும் இரண்டு மொழிகள் இவை, எனவே இரண்டு மொழிகளும் பல வழிகாட்டிகளும் பயிற்சிகளும் கவனம் செலுத்துகின்றன. அண்ட்ராய்டு மேம்பாடு அதை விட மிகவும் நெகிழ்வானது மற்றும் மாறுபட்டது, மேலும் அதை அணுக நிறைய வழிகள் உள்ளன. இவற்றில் பல சி # ஐ உள்ளடக்கியது.

படிக்க:நான் Android பயன்பாடுகளை உருவாக்க விரும்புகிறேன் - நான் எந்த மொழிகளைக் கற்றுக்கொள்ள வேண்டும்?

சி # என்பது யூனிட்டியில் ஒரு விளையாட்டை உருவாக்க நீங்கள் தேர்வுசெய்தால் நீங்கள் பயன்படுத்தும் நிரலாக்க மொழியாகும் - இது பிளே ஸ்டோரில் மிகவும் பிரபலமான மற்றும் பரவலாக பயன்படுத்தப்படும் கேம் எஞ்சினாகவும் இருக்கும். பொதுவாக, நீங்கள் விளையாட்டு வளர்ச்சியில் ஆர்வமாக இருந்தால் சி # நிரலாக்கத்தைக் கற்றுக்கொள்வது பயனுள்ளது.

நீங்கள் Xamarin ஐப் பயன்படுத்த விரும்பினால் C # நிரலாக்கத்தையும் கற்றுக்கொள்ள வேண்டும். Xamarin என்பது டெவலப்பர்களை விஷுவல் ஸ்டுடியோவைப் பயன்படுத்தி பயன்பாடுகளை உருவாக்க அனுமதிக்கும் ஒரு கருவியாகும், இது iOS மற்றும் Android இரண்டிற்கும் எளிதாக அனுப்பப்படலாம், இது குறுக்கு மேடை திட்டங்களுக்கு ஏற்றது.

எனவே, அண்ட்ராய்டுக்கான சி # நிரலாக்கத்தைக் கற்றுக்கொள்ள நிச்சயமாக நல்ல காரணம் இருக்கிறது. நீங்கள் தெரிந்து கொள்ள வேண்டியதைப் பார்ப்போம்.

ஒரு விரைவான அறிமுகம் - சி # vs ஜாவா

சி # என்பது ஒரு பொருள் சார்ந்த நிரலாக்க மொழியாகும், இது மைக்ரோசாப்ட் 2000 ஆம் ஆண்டில் உருவாக்கப்பட்டது, இது நவீன, எளிய மற்றும் நெகிழ்வானதாக இருக்க வேண்டும். ஜாவாவைப் போலவே (1990 இல் சன் மைக்ரோசிஸ்டம் உருவாக்கியது), இது முதலில் சி ++ இலிருந்து உருவானது, இரண்டிற்கும் இடையே நிறைய ஒற்றுமைகள் இருப்பதை உறுதி செய்கிறது. எடுத்துக்காட்டாக, இரண்டும் ஒரே மாதிரியான “தொடரியல் தளத்தை” பயன்படுத்துகின்றன, அதாவது அவை ஒரே மாதிரியான சொற்களையும் கட்டமைப்பையும் திறம்பட பயன்படுத்துகின்றன. சில சிறிய வேறுபாடுகள் உள்ளன, ஆனால் நீங்கள் ஒரு மொழியைப் பற்றி நன்கு அறிந்திருந்தால், நீங்கள் அதைக் கற்றுக் கொள்ளத் தேவையில்லாமல் மற்றொன்றைப் புரிந்து கொள்ள முடியும். ஆரம்பத்தில், சி # நிரலாக்கத்தைக் கற்றுக்கொள்வது சற்று எளிதானது என்பதை பலர் கண்டுபிடிப்பார்கள்.

பொருள் சார்ந்த மொழிகளாக, சி # மற்றும் ஜாவா இரண்டும் வகுப்புகள் மூலம் பொருட்களை விவரிக்கும். இது நிரலாக்கத்திற்கான ஒரு மட்டு அணுகுமுறையாகும், இது குறியீட்டின் துணுக்குகளை மீண்டும் மீண்டும் பயன்படுத்த அனுமதிக்கிறது.

சி # ஜாவாவிலிருந்து வேறுபடுகின்ற இடத்தில், அதன் பிரதிநிதிகளின் பயன்பாட்டில் உள்ளது, நிகழ்வு கேட்பதற்கான அணுகுமுறை, மெய்நிகர் vs இறுதி பண்புகள், மறைமுகமான வார்ப்பு மற்றும் பல.

நல்ல செய்தி: நீங்கள் முதலில் சி # ஐக் கற்றுக்கொள்ளத் தொடங்கும் போது இதன் பெரும்பகுதி என்ன என்பதை நீங்கள் அறியத் தேவையில்லை. சி # இல் கட்டமைப்பது கொஞ்சம் எளிதானது மற்றும் குறைந்த தட்டச்சு தேவைப்படுவதே முக்கிய பயணமாகும். Android க்கான ஜாவாவைக் கற்றுக் கொள்ளும்போது, ​​Android பயன்பாடுகளை உருவாக்கத் தேவையான பல வகுப்புகள் மற்றும் API களையும் நீங்கள் அறிந்து கொள்ள வேண்டும் என்பதை கருத்தில் கொண்டு இது குறிப்பாக உண்மை. எனவே, நீங்கள் ஜாவாவுக்கு ஒரு படிப்படியாக சி # நிரலாக்கத்தையும் கற்றுக்கொள்ளலாம்.

வணக்கம் உலகம்! சி # இல்

குறியீட்டு உலகில் உள்ள பாரம்பரியம் என்னவென்றால், நீங்கள் ஒரு புதிய மொழியைக் கற்றுக் கொள்ளும் எந்த நேரத்திலும், “ஹலோ வேர்ல்ட்!” ஐ திரையில் காண்பிக்க ஒரு எளிய நிரலை உருவாக்க வேண்டும். இது அடிப்படையில் தேவையான கருவிகளை இயக்கவும் இயங்கவும் எளிய ஒன்றை தொகுக்கவும் முடியும் என்பதை உறுதி செய்கிறது. இது மைக்ரோஃபோனில் “சோதனை, சோதனை, 1, 2, 3” ஐப் படிப்பது போன்றது!

இந்த வழக்கில், கன்சோல் பயன்பாட்டை உருவாக்க விஷுவல் ஸ்டுடியோவைப் பயன்படுத்த உள்ளோம். எனவே நீங்கள் மேலே சென்று விஷுவல் ஸ்டுடியோவை பதிவிறக்கம் செய்தவுடன் (இது இலவசம்), கிளிக் செய்க:

கோப்பு> புதிய> திட்டம்

பின்னர்:

விஷுவல் சி #> விண்டோஸ் கிளாசிக் டெஸ்க்டாப்> கன்சோல் பயன்பாடு (.நெட் கட்டமைப்பு)

விண்டோஸ் கன்சோலில் இயங்கும் பயன்பாட்டை நாங்கள் உருவாக்குவது இதுதான்.

அது முடிந்ததும், உங்கள் திட்டத்தின் வெற்று எலும்புகளின் அமைப்பு பிரதான சாளரத்தில் தோன்றும். இது போன்ற குறியீடு உங்களுக்கு வழங்கப்படும்:

பெயர்வெளி கன்சோல்ஆப் 3 {வகுப்பு நிரல் {நிலையான வெற்றிடம் முதன்மை (சரம் ஆர்க்ஸ்) {}}}

இப்போது வெறுமனே இரண்டு வரிகளைச் சேர்க்கவும்:

பெயர்வெளி கன்சோல்ஆப் 3 {வகுப்பு நிரல் {நிலையான வெற்றிடம் முதன்மை (சரம் ஆர்க்ஸ்) {கன்சோல்.ரைட்லைன் ("ஹலோ வேர்ல்ட்!"); Console.ReadKey (); }}}

இது திரையில் “ஹலோ வேர்ல்ட்!” என்று எழுதப் போகிறது, பின்னர் ஒரு முக்கிய பத்திரிகைக்கு காத்திருக்கிறது. பயனர் எந்த விசையையும் தொட்டவுடன், நிரல் முடிவுக்கு வந்து தானாகவே வெளியேறும்.

இந்த இரண்டு வரிகளும் அரைக்காற்புள்ளியுடன் முடிவடைகின்றன என்பதை நினைவில் கொள்க. ஏனென்றால், சி # இல் உள்ள எந்தவொரு அறிக்கையும் அரைக்காற்புள்ளியுடன் முடிவடைய வேண்டும், இது சி # உடன் வரி முடிந்தது என்று தொடர்பு கொள்கிறது (இது ஜாவாவிலும் அதேதான்). ஒரே ஒரு விதிவிலக்கு என்னவென்றால், ஒரு திறந்த அடைப்புக்குறி உடனடியாக வரியைப் பின்தொடரும் போது, ​​அதை நாங்கள் ஒரு கணத்தில் விளக்குவோம்.

திரையின் மேற்புறத்தில் உள்ள “தொடங்கு” பொத்தானை அழுத்தவும், அது பயன்பாட்டைத் தொடங்க வேண்டும், இதை நடைமுறையில் காண உங்களை அனுமதிக்கிறது.

வகுப்புகள் என்பது பொருள்களை விவரிக்கும் குறியீட்டின் துண்டுகள், அவை திறம்பட தரவுகளின் துண்டுகள்

எனவே, இங்கே சரியாக என்ன நடக்கிறது?

சி # உடன் தொடங்குதல்: முறைகள் மற்றும் வகுப்புகள்

Android க்கான C # நிரலாக்கத்தைக் கற்றுக்கொள்ள, நீங்கள் வகுப்புகள் மற்றும் முறைகளைப் புரிந்து கொள்ள வேண்டும்.

வகுப்புகள் என்பது பொருள்களை விவரிக்கும் குறியீட்டின் துண்டுகள், அவை திறம்பட தரவுகளின் துண்டுகள். இதைத் தொடங்க நீங்கள் அதிகம் கவலைப்படத் தேவையில்லை: நீங்கள் இப்போது பணிபுரியும் குறியீட்டின் பக்கம் “வகுப்பு” என்று அழைக்கப்படுகிறது என்பதையும், உங்கள் திட்டத்தில் உள்ள பிற வகுப்புகளுடன் நீங்கள் தொடர்பு கொள்ளலாம் என்பதையும் அறிந்து கொள்ளுங்கள். ஒரு திட்டத்திற்கு ஒரு வகுப்பு மட்டுமே இருக்க முடியும், உங்கள் எல்லா குறியீடுகளும் அங்கிருந்து வேலை செய்கின்றன, அல்லது அதற்கு பல இருக்கலாம்.

ஒவ்வொரு வகுப்பிலும், உங்களுக்கு முறைகளும் இருக்கும். இந்த முறைகள் குறியீட்டின் துணுக்குகளாகும், அவை அந்த வகுப்பினுள் இருந்து எந்த நேரத்திலும் நீங்கள் குறிப்பிடலாம் - சில சமயங்களில் அதற்கு வெளியேயும்.

இந்த வழக்கில், வகுப்பு அழைக்கப்படுகிறது திட்டம். இது மேலே உள்ள வரியால் வரையறுக்கப்படுகிறது: வகுப்பு நிரல். வலதுபுறத்தில் “தீர்வு எக்ஸ்ப்ளோரர்” சாளரத்தைத் திறந்தால், நீங்கள் Program.cs ஐக் கண்டுபிடிக்க முடியும். வகுப்பின் பெயர் எப்போதும் கோப்பு பெயரைப் போலவே இருக்கும்.

பின் வரும் அனைத்து குறியீடுகளையும் கொண்டிருக்க சுருள் அடைப்புக்குறியைப் பயன்படுத்துகிறோம். சுருள் அடைப்புக்குறிப்புகள் பின்வருபவை அனைத்தும் ஒன்றாகவே உள்ளன என்று கூறுகின்றன. எனவே, அடைப்புக்குறி மூடப்படும் வரை, பின்வரும் குறியீடு அனைத்தும் நிரலின் ஒரு பகுதியாகும்.

இதை எங்கள் முதல் முறை பின்பற்றுகிறது, பின்வரும் வரியால் வரையறுக்கவும்:

நிலையான வெற்றிடம் முதன்மை (சரம் ஆர்க்ஸ்)

இதைத் தொடர்ந்து மேலும் திறந்த அடைப்புக்குறிகள் உள்ளன, அதாவது அடுத்த பிட் குறியீடு “முதன்மை” முறையின் ஒரு பகுதியாகும் (இது இன்னும் நிரல் வகுப்பிற்குள் உள்ளது). எங்களுடைய “ஹலோ வேர்ல்ட்” ஐ வைத்துள்ளோம்.

"நிலையான வெற்றிடம்" அடிப்படையில் இந்த முறை தன்னிறைவான ஒன்றைச் செய்கிறது (பரந்த நிரலால் பயன்படுத்தப்பட வேண்டிய தரவைக் கையாளுவதற்குப் பதிலாக) செய்கிறது, மேலும் அதை வெளி வகுப்பினரால் குறிப்பிட முடியாது. "சரம் ஆர்க்ஸ்" பொருள் பின்னர் கையாளுவதற்கான முறைக்கு தகவல்களை அனுப்ப அனுமதிக்கிறது. இவை “அளவுருக்கள்” மற்றும் “வாதங்கள்” என்று அழைக்கப்படுகின்றன. மீண்டும், நீங்கள் இதுவரை எதையும் பற்றி கவலைப்பட தேவையில்லை. ஒரு சொல், அடைப்புக்குறிப்புகள் மற்றும் சுருள் அடைப்புக்குறிகளைத் தொடர்ந்து “நிலையான வெற்றிடம்” என்பது ஒரு புதிய முறையின் தொடக்கத்தைக் குறிக்கிறது என்பதை அறிந்து கொள்ளுங்கள்.

அடுத்த இரண்டு வரிகள் நாங்கள் சேர்த்தவை: அவை கன்சோலைப் பெற்று அதன் கட்டளைகளை திரையில் எழுத ஒரு விசை அழுத்தத்திற்காக காத்திருக்கின்றன.

இறுதியாக, நாங்கள் எங்கள் எல்லா அடைப்புக்குறிகளையும் மூடுகிறோம்: முதலில் முறை, பின்னர் வகுப்பு, பின்னர் வர்க்கத்திற்கு சொந்தமான திட்டத்தின் பெயரான “பெயர்வெளி” (இந்த விஷயத்தில் “கன்சோல்ஆப் 3” - முந்தைய சோதனை பயன்பாடுகளை இந்த வழியில் செய்துள்ளேன்) .

குழப்பமான? கவலைப்பட வேண்டாம், இது இன்னும் அர்த்தமுள்ளதாக இருக்கும்.

முறைகளைப் பயன்படுத்துதல்

எனவே முறைகள் பெயர்களைக் கொண்ட குறியீட்டின் மூட்டைகளாகும். நாங்கள் ஏன் முறைகளைப் பயன்படுத்துகிறோம் என்பதை நிரூபிக்க, புதிய ஒன்றை உருவாக்கி அதை ஒரு எடுத்துக்காட்டுக்கு வைக்க உதவியாக இருக்கும்.

எனவே, நிரல் வகுப்பினுள் வாழும் ஒரு புதிய முறையை உருவாக்கவும் (எனவே அது அந்த சுருள் அடைப்புக்குறிக்குள் இருக்க வேண்டும், ஆனால் “முதன்மை” க்கு சொந்தமான சுருள் அடைப்புக்குறிக்கு வெளியே இருக்க வேண்டும்).

இந்த “புதிய முறை” என்று அழைக்கவும், பின்னர் நீங்கள் எழுதிய இரண்டு வரிகளையும் இங்கே வைக்கவும். இது இப்படி இருக்க வேண்டும்:

வகுப்பு நிரல் {நிலையான வெற்றிடம் முதன்மை (சரம் ஆர்க்ஸ்)}} நிலையான வெற்றிடமான புதிய முறை () {கன்சோல்.ரைட்லைன் ("ஹலோ வேர்ல்ட்!"); Console.ReadKey (); }}

இப்போது உங்கள் முதன்மை முறைமையில் புதிய முறைக்கு ஒரு குறிப்பைச் சேர்க்கவும்:

நிலையான வெற்றிடத்தை முதன்மை (சரம் ஆர்க்ஸ்) New ar புதிய முறை (); }

இது நீங்கள் உருவாக்கிய முறையை "அழைக்க" போகிறது, அடிப்படையில் அந்த திசையில் நிரலை இயக்குகிறது. தொடக்கத்தை அழுத்தவும், முன்பு போலவே நடப்பதை நீங்கள் காண்பீர்கள். இப்போது நீங்கள் விரும்பினால் தவிர, நீங்கள் விரும்பிய பல முறை “புதிய முறை ();” ஐ எழுதலாம் மற்றும் நிறைய குறியீடுகளை எழுதாமல் உரையை மீண்டும் சொல்லலாம்.

ஒரு பெரிய திட்டத்தின் போது, ​​இது போன்ற குறியீட்டின் துணுக்குகளைக் குறிப்பிடுவது நம்பமுடியாத சக்திவாய்ந்ததாகிறது. Android க்கான C # நிரலாக்கத்தைக் கற்றுக்கொள்ள முயற்சிக்கும்போது புரிந்து கொள்ள வேண்டிய மிக முக்கியமான விஷயங்களில் இதுவும் ஒன்றாகும்.

இந்த வழியை நாம் விரும்பும் பல முறைகளை நாம் உருவாக்க முடியும், அந்த வழியில் மிகவும் சுத்தமாகவும் ஒழுங்கமைக்கப்பட்ட குறியீடும் உள்ளது. அதே நேரத்தில், சி # க்கு “கட்டமைக்கப்பட்ட” முறைகள் மற்றும் நாம் பயன்படுத்தக்கூடிய எந்த நூலகங்களையும் குறிப்பிடலாம். “மெயின்” என்பது “உள்ளமைக்கப்பட்ட” முறையின் ஒரு எடுத்துக்காட்டு. எல்லா நிரல்களும் தொடங்கும் முறை இதுதான், மேலும் இது முதலில் இயக்கப்பட வேண்டும் என்பதை சி # புரிந்துகொள்கிறது. நீங்கள் இங்கு எதையும் வைக்கவில்லை என்றால், எதுவும் நடக்காது!

இந்த வழக்கில் அடைப்புக்குறிக்குள் சேர்க்கப்பட்டுள்ள வாதங்கள் மட்டுமே தேவைப்படுகின்றன, ஏனெனில் மைக்ரோசாப்ட் பிரதான முறையை வடிவமைத்தது. எவ்வாறாயினும் எங்கள் அடைப்புக்குறிகளை காலியாக விட நாங்கள் நன்றாக இருந்தோம்.

மாறிகளைப் பயன்படுத்துதல்

இப்போது எங்கள் குறியீட்டில் கொஞ்சம் சுவாரஸ்யமான ஒன்றைச் செய்ய வேண்டிய நேரம் வந்துவிட்டது. குறிப்பாக, நிரலை மேலும் ஆற்றல் மிக்கதாக மாற்றங்களை எவ்வாறு பயன்படுத்துவீர்கள் என்பதைப் பார்ப்போம். நீங்கள் சி # நிரலாக்கத்தைக் கற்றுக்கொள்ள விரும்பினால் புரிந்து கொள்ள வேண்டிய மிக முக்கியமான விஷயங்களில் இதுவும் ஒன்றாகும்.

ஒரு மாறி என்பது அடிப்படையில் ஒரு தரவுக்கான கொள்கலன். உங்கள் மனதை உயர்நிலைப் பள்ளி கணிதத்திற்குத் திருப்பி விடுங்கள், இது போன்ற விஷயங்களைப் பார்த்ததை நீங்கள் நினைவில் வைத்திருக்கலாம்:

10 + x = 13
X ஐக் கண்டறியவும்

இங்கே, “x” என்பது ஒரு மாறி, நிச்சயமாக அது குறிக்கும் மதிப்பு “3” ஆகும்.

நிரலாக்கத்தில் ஒரு மாறி எவ்வாறு செயல்படுகிறது என்பதும் இதுதான். இங்கே தவிர, ஒரு மாறி பல்வேறு வகையான தரவைக் குறிக்கும்: உரை உட்பட.

ஒரு புதிய மாறியை உருவாக்க, முதலில் சி # க்கு எந்த வகையான தரவுகளைக் கொண்டிருக்கப் போகிறது என்பதைச் சொல்ல வேண்டும்.

எனவே உங்கள் புதிய முறை () முறைக்குள், முதலில் உங்கள் மாறியை உருவாக்குவீர்கள், பின்னர் அதற்கு ஒரு மதிப்பை வழங்குவீர்கள். அதை எங்கள் “ரைட்லைன்” கட்டளையில் சேர்க்கப் போகிறோம்:

எண்ணாக எண்; எண் = 10; கன்சோல்.ரைட்லைன் ("ஹலோ வேர்ல்ட்!" + எண்);

எந்தவொரு முழு எண்ணாக இருக்கக்கூடிய “முழு எண்” எனப்படும் ஒரு வகை மாறியை நாங்கள் பயன்படுத்தியுள்ளோம். சி # இல், “int” ஐப் பயன்படுத்தி இவற்றைக் குறிப்பிடுகிறோம். எவ்வாறாயினும், நாம் ஒரு "மிதவை" எளிதாகப் பயன்படுத்தியிருக்கலாம், இது ஒரு "மிதக்கும் புள்ளி மாறி" மற்றும் தசம இடங்களைப் பயன்படுத்த அனுமதிக்கிறது.

இந்த குறியீட்டை நீங்கள் இயக்கினால், அது இப்போது “ஹலோ வேர்ல்ட்! திரையில் 10 ”. நிச்சயமாக, "எண்ணின்" மதிப்பை எந்த நேரத்திலும் மாற்றலாம்.

புதிய எண் () க்குள் “எண்” உருவாக்கப்பட்டுள்ளதால், அதை எங்கள் குறியீட்டில் வேறு இடத்திலிருந்து அணுக முடியாது. ஆனால் நாம் அதை அனைத்து முறைகளுக்கும் வெளியே வைத்தால், அது உலகளவில் கிடைக்கும். அதைச் செய்ய, மாறியும் நிலையானது என்பதை உறுதிப்படுத்த வேண்டும்:

வகுப்பு நிரல் {நிலையான எண்ணின் எண் = 10; நிலையான வெற்றிடம் முதன்மை (சரம் ஆர்க்ஸ்) {புதிய முறை (); } நிலையான வெற்றிடமான புதிய முறை () {கன்சோல்.ரைட்லைன் ("ஹலோ வேர்ல்ட்!" + எண்); Console.ReadKey (); }}

இறுதியாக, இந்தத் தரவை நாம் கடந்து செல்ல இன்னும் ஒரு வழி உள்ளது, அது ஒரு வாதமாகப் பயன்படுத்தப்பட வேண்டும், இதன் மூலம் அதை எங்கள் முறைக்கு அனுப்பலாம். இது அப்படித் தோன்றலாம்:

நிலையான வெற்றிடம் முதன்மை (சரம் ஆர்க்ஸ்) {int எண் = 10; கன்சோல்.ரைட்லைன் ("ஹாய், உங்கள் பெயர் என்ன?"); NewMethod (எண்); } நிலையான வெற்றிடமான புதிய முறை (முழு எண்) {கன்சோல்.ரைட்லைன் ("ஹலோ வேர்ல்ட்!" + எண்); Console.ReadKey (); }}

இங்கே, எங்கள் நியூமெதட் முறையை ஒரு வாதம் தேவை என்று வரையறுக்கிறோம், இது ஒரு முழு எண்ணாக இருக்க வேண்டும், மேலும் இது முறைக்குள் “எண்” என்று குறிப்பிடப்படும். சுருள் அடைப்புக்குறிக்குள் அந்த தகவலைச் சேர்ப்பதன் மூலம் இதைச் செய்கிறோம். பின்னர், நிரலில் வேறு எங்கிருந்தும் முறையை அழைக்கும்போது, ​​அந்த மதிப்பை அடைப்புக்குறிக்குள் "கடந்து" செல்ல வேண்டும். நீங்கள் பல அளவுருக்களைக் கொண்டு முறைகளை உருவாக்கலாம், இந்நிலையில் நீங்கள் பட்டியலிடப்பட்ட மாறிகளை கமாக்களுடன் பிரிக்கலாம்.

தரவை ஏமாற்றுவதற்கு இந்த வெவ்வேறு உத்திகளைப் பயன்படுத்துவது பொருத்தமானதாக இருக்கும் வெவ்வேறு காட்சிகள் உள்ளன. நல்ல நிரலாக்கமானது வேலைக்கு சரியானதைக் கண்டுபிடிப்பதாகும்!

வாதங்களை கடந்து சரங்களை பயன்படுத்துதல்

இந்த அடுத்த குறியீட்டை இயக்க முயற்சிக்கவும், என்ன நடக்கிறது என்று பார்க்கவும்:

வகுப்பு நிரல் {நிலையான வெற்றிடம் முதன்மை (சரம் ஆர்க்ஸ்) {கன்சோல்.ரைட்லைன் ("ஹாய், உங்கள் பெயர் என்ன?"); NewMethod (Console.ReadLine ()); } நிலையான வெற்றிடமான புதிய முறை (சரம் பயனர் பெயர்) {கன்சோல்.ரைட்லைன் ("ஹலோ" + பயனர் பெயர்); Console.ReadKey (); }}

உங்கள் பெயரை உள்ளிடும்படி கேட்கப்படுவதை நீங்கள் கண்டுபிடிக்க வேண்டும், மேலும் கன்சோல் அதன் மூலம் உங்களுக்கு சிறந்தது. இந்த எளிய குறியீடு பல பயனுள்ள பாடங்களைக் கொண்டுள்ளது.

முதலில், ஒரு சரம் எனப்படும் வேறுபட்ட வகை மாறியை எவ்வாறு பயன்படுத்துவது என்பதற்கான எடுத்துக்காட்டைக் காண்கிறோம். ஒரு சரம் என்பது தொடர்ச்சியான எழுத்துக்கள், இது ஒரு பெயராக இருக்கலாம் அல்லது முழு கதையாக இருக்கலாம்.

எனவே, நீங்கள் எளிதாக UserName = “ஆடம்” என்று எழுதலாம். ஆனால் அதற்கு பதிலாக, கன்சோலில் இருந்து சரம் பெறுகிறோம்: கன்சோல். ரீட்லைன் ().

நாங்கள் எழுதியிருக்கலாம்:

சரம் பயனர்; பயனர் = கன்சோல்.ரெட்லைன் (); NewMethod (பயனர்);

ஆனால் எங்கள் குறியீட்டை முடிந்தவரை சுத்தமாக வைத்திருக்க, நாங்கள் அந்த படிகளைத் தவிர்த்து, “ரீட்லைனை” நேரடியாக அடைப்புக்குறிக்குள் வைத்திருக்கிறோம்.

நாங்கள் அந்த சரத்தை எங்கள் புதிய முறைக்கு அனுப்புகிறோம், மேலும் நீங்கள் ஏற்கனவே அறிந்த முறையைப் பயன்படுத்தி பயனரை வாழ்த்துகிறோம்.

ஒரு சரம் என்பது தொடர்ச்சியான எழுத்துக்கள், இது ஒரு பெயராக இருக்கலாம் அல்லது முழு கதையாக இருக்கலாம்.

சி # ஏன் எழுதப்பட்டிருக்கிறது என்பதையும், சில நெகிழ்வான மற்றும் சக்திவாய்ந்த மென்பொருளை உருவாக்க மாறிகள் மற்றும் முறைகள் போன்றவற்றை எவ்வாறு பயன்படுத்தலாம் என்பதையும் பற்றி இப்போது நீங்கள் கொஞ்சம் புரிந்துகொள்ளத் தொடங்குகிறீர்கள் என்று நம்புகிறோம்.

ஆனால் நீங்கள் சி # நிரலாக்கத்தைக் கற்றுக்கொள்ள விரும்பினால் இன்னும் முக்கியமான ஒரு அம்சம் உள்ளது: ஓட்ட கட்டுப்பாடு.

சி # ஓட்டக் கட்டுப்பாட்டைக் கற்றுக் கொள்ளுங்கள் மற்றும் எளிய வினாடி வினாக்களை உருவாக்குங்கள்!

குறியீட்டு போது நாம் மாறிகளைப் பயன்படுத்துவதற்கான ஒரு காரணம், இதன் மூலம் எங்கள் நிரல்களை எளிதாகத் திருத்த முடியும். மற்றொன்று, நீங்கள் பயனரிடமிருந்து தகவல்களைப் பெறலாம் அல்லது தோராயமாக உருவாக்கலாம்.

ஆனால் சி # மாறிகளைக் கற்றுக்கொள்வதற்கான சிறந்த காரணம், உங்கள் நிரல்கள் மாறும் தன்மையைக் கொண்டிருக்கக்கூடும்: இதனால் அவை எவ்வாறு பயன்படுத்தப்படுகின்றன என்பதைப் பொறுத்து அவை வித்தியாசமாக செயல்பட முடியும்.

அதற்காக, எங்களுக்கு “ஓட்ட கட்டுப்பாடு” அல்லது “நிபந்தனை அறிக்கைகள்” தேவை. இவை உண்மையில் ஒரு மாறியின் மதிப்பைப் பொறுத்து ஒன்றுக்கு மேற்பட்ட வழிகளில் குறியீட்டை இயக்கப் போகிறோம் என்று சொல்வதற்கான ஆடம்பரமான வழிகள்.

அதைச் செய்வதற்கான மிக சக்திவாய்ந்த வழிகளில் ஒன்று “if” அறிக்கையுடன் உள்ளது. இந்த எடுத்துக்காட்டில், எங்கள் முக்கிய பயனரின் பயனர்பெயரைப் பார்த்து மற்றவர்களை விட வித்தியாசமாக வாழ்த்துவோம்.

நிலையான வெற்றிடமான புதிய முறை (சரம் பயனர் பெயர்) {கன்சோல்.ரைட்லைன் ("ஹலோ" + பயனர் பெயர்); if (UserName.Equals ("Adam")) {Console.WriteLine ("மீண்டும் வருக ஐயா"); } கன்சோல்.ரெட்கே (); }

ஒரு அறிக்கையின் செல்லுபடியை சோதிப்பதன் மூலம் “என்றால்” அறிக்கைகள் செயல்படுகின்றன, இது அடைப்புக்குறிக்குள் செல்லும். இந்த விஷயத்தில், UserName என்ற சரம் “ஆடம்” என்ற சரத்திற்கு சமமானதா என்று கேட்கிறோம். அடைப்புக்குறிக்குள் அந்த அறிக்கை உண்மையாக இருந்தால் - இரண்டு சரங்களும் ஒரே மாதிரியானவை - பின்னர் பின்வரும் சுருள் அடைப்புகளில் உள்ள குறியீடு இயங்கும். அது இல்லையென்றால், அந்த வரிகள் தவிர்க்கப்படும்.

அதேபோல், நாம் முழு எண்களையும் மிதவைகளையும் ஒப்பிடலாம், மேலும் ஒன்று மற்றொன்றை விட பெரிதாக இருக்கிறதா என்று சோதிக்கலாம். ரஷ்ய பொம்மைகளைப் போல ஒருவருக்கொருவர் அறிக்கைகள் இருந்தால் கூட நாம் பல வேறுபட்டவற்றைப் பயன்படுத்தலாம். இந்த "உள்ளமை ifs" என்று அழைக்கிறோம்.

அடுத்த முறை

சுவிட்ச் ஸ்டேட்மென்ட் போன்ற விஷயங்கள் உட்பட - ஓட்டம் கட்டுப்பாட்டுக்கு நீங்கள் பயன்படுத்த இன்னும் பல உத்திகள் உள்ளன. இருப்பினும், சில பயனுள்ள விஷயங்களை உருவாக்கத் தொடங்க இந்த அறிக்கைகளையும் நுட்பங்களையும் எவ்வாறு பயன்படுத்தலாம் என்பதை நீங்கள் ஏற்கனவே பார்க்கலாம். இந்த குறியீட்டை ஏற்கனவே வினாடி வினாவாக மாற்றலாம்!

இறுதியில் யூனிட்டி போன்ற கருவிகளைக் கொண்ட சி # முழு செயல்பாட்டு விளையாட்டுகளை உருவாக்க உங்களை அனுமதிக்கும்!

ஆனால் உண்மையில் சுவாரஸ்யமான கருவிகள் மற்றும் விளையாட்டுகளை உருவாக்க, நாம் ஆராய இன்னும் சில விஷயங்கள் உள்ளன. எனவே ஆச்சரியம்! ஒரு பகுதி இரண்டு இருக்க போகிறது!

அடுத்த பாடத்தில், காலப்போக்கில் மீண்டும் சுழலும் சுழல்களை எவ்வாறு உருவாக்குவது என்பதையும், புதிய வகுப்புகளை உருவாக்குவது மற்றும் அவற்றுடன் எவ்வாறு தொடர்புகொள்வது என்பதையும் கண்டுபிடிப்பீர்கள். பிறகு பார்க்கலாம்!