உள்ளடக்கம்

• வகுப்புகள் மற்றும் பொருள் சார்ந்த நிரலாக்கத்தைப் புரிந்துகொள்வது
• புதிய வகுப்பை உருவாக்குதல்
• நடத்தைகளைச் சேர்த்தல்
• அதில் முயல்கள் போல
• பிபோனச்சி
• நாங்கள் இங்கிருந்து எங்கு செல்வோம்? Android க்கான C # ஐ எவ்வாறு கற்றுக்கொள்வது

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

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

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

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

வகுப்புகள் மற்றும் பொருள் சார்ந்த நிரலாக்கத்தைப் புரிந்துகொள்வது

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

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

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

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

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

புதிய வகுப்பை உருவாக்குதல்

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

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

வலதுபுறத்தில் உள்ள உங்கள் சொல்யூஷன் எக்ஸ்ப்ளோரரில் நீங்கள் சரிபார்த்தால், Program.cs க்கு கீழே Rabbit.cs என்ற புதிய கோப்பு உருவாக்கப்பட்டுள்ளதை நீங்கள் காண்பீர்கள். நல்லது - நீங்கள் Android க்கான C # ஐக் கற்றுக்கொள்ள விரும்புகிறீர்களா என்பதை அறிய இது மிக முக்கியமான விஷயங்களில் ஒன்றாகும்!

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

பெயர்வெளி கன்சோல்ஆப் 2 {வகுப்பு முயல் {}}

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

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

பெயர்வெளி கன்சோல்ஆப் 2 {வகுப்பு முயல் {பொது சரம் முயல் பெயர்; பொது சரம் ராபிட் கலர்; public int RabbitAge; பொது எண்ணாக ராபிட்வெயிட்; பொது முயல் (சரம் பெயர், சரம் நிறம், முழு வயது, முழு எடை) {முயல் பெயர் = பெயர்; முயல் வண்ணம் = நிறம்; முயல் வயது = வயது; முயல் எடை = எடை; }}}

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

முயல் முயல் 1 = புதிய முயல் (“ஜெஃப்”, “பழுப்பு”, 1, 1);

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

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

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

அதை நிரூபிக்க, நீங்கள் இப்போது இந்த வரியைப் பயன்படுத்தலாம்:

Console.WriteLine (Rabbit1.RabbitName);

இது நீங்கள் உருவாக்கிய முயலின் பெயரை உங்களுக்குத் தெரிவிக்கும்!

நம்முடைய முயலின் எடையும் இதேபோல் அதிகரிக்கலாம்:

Rabbit1.RabbitWeight ++; கன்சோல்.ரைட்லைன் (Rabbit1.RabbitName + "எடைகள்" + Rabbit1.RabbitWeight + "kg");

எதையாவது முடிவில் “++” சேர்ப்பது அதன் மதிப்பை ஒவ்வொன்றாக அதிகரிக்கும் என்பதை இங்கே கவனியுங்கள் (நீங்கள் “RabbitWeight = RabbitWeight + 1” என்றும் எழுதலாம்).

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

நடத்தைகளைச் சேர்த்தல்

எங்கள் முயலுக்கு ஒருவித நடத்தை கொடுக்க நாங்கள் தேர்வு செய்யலாம். இந்த விஷயத்தில், அவர்களை சாப்பிட விடுவோம்.

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

public void Eat () {Console.WriteLine (RabbitName + ": Nibble nibble!"); RabbitWeight ++; }

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

பின்னர், Program.cs இன் உள்ளே இருந்து, இந்த முறையை நாம் அழைக்க முடியும், இது நமக்கு விருப்பமான முயலை சாப்பிட்டு பெரிதாக மாற்றும்:

கன்சோல்.ரைட்லைன் (Rabbit1.RabbitName + "எடைகள்" + Rabbit1.RabbitWeight + "kg"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit1.Eat (); கன்சோல்.ரைட்லைன் (Rabbit1.RabbitName + "எடைகள்" + Rabbit1.RabbitWeight + "kg");

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

கன்சோல்.ரைட்லைன் (Rabbit1.RabbitName + "எடைகள்" + Rabbit1.RabbitWeight + "kg"); கன்சோல்.ரைட்லைன் (Rabbit2.RabbitName + "எடைகள்" + Rabbit2.RabbitWeight + "kg"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit2.Eat (); Rabbit2.Eat (); Rabbit1.Eat (); கன்சோல்.ரைட்லைன் (Rabbit1.RabbitName + "எடைகள்" + Rabbit1.RabbitWeight + "kg"); கன்சோல்.ரைட்லைன் (Rabbit2.RabbitName + "எடைகள்" + Rabbit2.RabbitWeight + "kg");

அதில் முயல்கள் போல

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

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

பட்டியல் முயல் பட்டியல் = புதிய பட்டியல்(); முயல் பட்டியல். சேர் (புதிய முயல் ("ஜெஃப்", "பழுப்பு", 1, 1)); முயல் பட்டியல்.ஆடு (புதிய முயல் ("சாம்", "வெள்ளை", 1, 2%);

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

முயல் முயல் 3 = புதிய முயல் ("ஜானி", "ஆரஞ்சு", 1, 1); RabbitList.Add (Rabbit3);

எந்த வழியில், ஒரு பொருள் உருவாக்கப்பட்டு பட்டியலில் சேர்க்கப்பட்டுள்ளது.

எங்கள் முயல்களின் பட்டியலிலிருந்து தகவல்களை நாங்கள் வசதியாகவும் நேர்த்தியாகவும் திரும்பப் பெறலாம்:

foreach (rabbitList இல் var Rabbit) {Console.WriteLine (Rabbit.RabbitName + "எடைகள்" + Rabbit.RabbitWeight + "kg"); }

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

RabbitList.Eat ();

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

பிபோனச்சி

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

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

1,1,2,3,5,8,13,21,34

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

அருமையான விஷயம் என்னவென்றால், நாம் அதைப் பிரதிபலிக்க முடியும்.

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

for (int months = 0; months <100; months ++) {// ஏதாவது செய்யுங்கள்}

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

இது எவ்வாறு ஃபைபோனச்சி வரிசையாக மாறும் என்பதைப் பார்க்க விரும்புகிறீர்களா? இதோ:

பெயர்வெளி கன்சோல்ஆப் 2 {வகுப்பு நிரல் {நிலையான வெற்றிடம் முதன்மை (சரம் ஆர்க்ஸ்) {பட்டியல் முயல் பட்டியல் = புதிய பட்டியல்(); முயல் பட்டியல். சேர் (புதிய முயல் ("ஜெஃப்", "பழுப்பு", 0, 1%); முயல் பட்டியல்.ஆடு (புதிய முயல் ("சாம்", "வெள்ளை", 0, 1)); for (int months = 0; months <10; months ++) {int firstRabbit = 0; int timesToReproduce = 0; foreach (முயல் பட்டியலில் var முயல்) {Console.Write ("R"); if (Rabbit.RabbitAge> 0) {if (firstRabbit == 0) {firstRabbit = 1; } else {firstRabbit = 0; timesToReproduce ++; }} முயல்.ராபிட்அஜ் ++; } for (int i = 0; i <timesToReproduce; i ++) {RabbitList.Add (புதிய முயல் ("NewBabyRabbit", "brown", 0, 1%); RabbitList.Add (புதிய முயல் ("NewBabyRabbit", "brown", 0, 1%); Console.Write ( "ஆர்"); Console.Write ( "ஆர்"); } கன்சோல்.ரைட்லைன் ("---" + முயல் பட்டியல். எண்ணிக்கை / 2 + "ஜோடி முயல்கள் உள்ளன!"); Console.WriteLine ( ""); } கன்சோல்.ரைட்லைன் ("அனைத்தும் முடிந்தது!"); Console.ReadKey (); }}}

சரி, நான் நினைத்ததை விட கடினமாக இருந்தது!

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

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

வேறு எந்த அணுகுமுறைகளையும் காண விரும்புகிறேன்!

நாங்கள் இங்கிருந்து எங்கு செல்வோம்? Android க்கான C # ஐ எவ்வாறு கற்றுக்கொள்வது

அந்த அறிவு அனைத்தையும் உங்கள் பெல்ட்டின் கீழ் கொண்டு, பெரிய விஷயங்களைத் தொடங்க நீங்கள் தயாராக உள்ளீர்கள். குறிப்பாக, Xamarin அல்லது Unity இல் C # உடன் Android நிரலாக்கத்தில் குத்துவதற்கு நீங்கள் தயாராக உள்ளீர்கள்.

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

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

• Xamarin உடன் Android பயன்பாட்டை எவ்வாறு உருவாக்குவது
• உங்கள் முதல் Android விளையாட்டை 7 நிமிடங்களில் ஒற்றுமையுடன் உருவாக்கவும்

வரவிருக்கும் பாடத்தில், நீங்கள் எவ்வாறு யு-டர்ன் எடுத்து விண்டோஸ் பயன்பாடுகளை உருவாக்க இதைப் பயன்படுத்தலாம் என்பதையும் பார்ப்போம்!