Nilalaman

• Isang mabilis na pagpapakilala - C # vs Java
• Hello World! sa C #
• Pagsisimula sa C #: mga pamamaraan at klase
• Paggamit ng mga pamamaraan
• Paggamit ng mga variable
• Ang pagpasa ng mga argumento at paggamit ng mga string
• Alamin ang control ng C # at bumuo ng mga simpleng pagsusulit!
• Sa susunod

Sa post na ito, malalaman mo ang tungkol sa C # programming para sa Android, pati na rin kung saan umaangkop ito sa engrandeng pamamaraan ng pag-unlad ng Android.

Kung interesado kang maging isang developer ng Android, maaaring nasa ilalim ka ng impression na kailangan mong malaman ang isa sa dalawang wika: Java o Kotlin. Ito ang dalawang wika na opisyal na sinusuportahan ng Android Studio, at samakatuwid ang dalawang wika na maraming mga gabay at mga pagtuon ay nakatuon. Ang pag-unlad ng Android ay mas nababaluktot at iba-iba kaysa doon, at maraming mga paraan upang lapitan ito. Marami sa mga ito ay nagsasangkot ng C #.

Basahin:Nais kong bumuo ng mga Android apps - kung anong mga wika ang dapat kong malaman?

Ang C # ay ang wikang pang-programming na gagamitin mo kung pipiliin mong bumuo ng isang laro sa Unity halimbawa - na nangyayari din na ang pinakatanyag at malawak na ginagamit na engine ng laro sa Play Store. Sa pangkalahatan, kapaki-pakinabang na malaman ang C # programming kung ikaw ay interesado sa pagbuo ng laro.

Dapat mo ring malaman ang C # programming kung nais mong gamitin ang Xamarin. Ang Xamarin ay isang tool na nagbibigay-daan sa mga developer na bumuo ng mga app gamit ang Visual Studio na madaling maipakita sa parehong iOS at Android, perpekto para sa mga proyekto ng cross platform.

Kaya, sa sinabi na, mayroong tiyak na magandang dahilan upang malaman ang C # programming para sa Android. Tingnan natin ang dapat mong malaman.

Isang mabilis na pagpapakilala - C # vs Java

Ang C # ay isang object-oriented na wika ng programming na binuo ng Microsoft sa paligid ng 2000, na may layunin na maging moderno, simple, at may kakayahang umangkop. Tulad ng Java (na binuo ng Sun Microsystem noong 1990), ito ay orihinal na nagbago mula sa C ++, tinitiyak na maraming pagkakapareho sa pagitan ng dalawa. Halimbawa, ang parehong gumamit ng parehong "syntactic base," na nangangahulugang epektibong gumagamit sila ng maraming pare-parehong terminolohiya at istraktura. Mayroong ilang mga menor de edad na pagkakaiba, ngunit kung pamilyar ka sa isang wika, dapat mong maunawaan ang marami sa iba pang hindi kinakailangang natutunan ito nang partikular. Para sa mga nagsisimula bagaman, marami ang makakahanap na medyo madali itong matuto ng C # programming.

Bilang object-oriented na mga wika, ang parehong C # at Java ay ilalarawan ang mga bagay sa pamamagitan ng mga klase. Ito ay isang modular na diskarte sa programming, na nagbibigay-daan sa mga snippet ng code na ginagamit nang paulit-ulit.

Kung saan ang C # ay naiiba sa Java bagaman, ay sa paggamit ng mga delegado, ang diskarte nito sa pakikinig sa kaganapan, virtual vs panghuling pag-aari, implicit na paghahagis, at marami pa.

Ang mabuting balita: hindi mo talaga kailangang malaman kung ano ang ibig sabihin nito nang una kang magsimulang malaman ang C #. Ang pangunahing takeaway ay ang istraktura ay medyo madali lamang upang matuto sa C # at may posibilidad na mangailangan ng mas kaunting pag-type. Ito ay totoo lalo na isinasaalang-alang na kapag nalaman mo ang Java para sa Android, kakailanganin mong maging pamilyar sa maraming mga klase at kinakailangang mga API upang bumuo ng mga Android apps. Sa gayon, maaari mo ring malaman ang C # programming bilang isang hakbang sa Java.

Hello World! sa C #

Ang tradisyon sa mundo ng coding ay anumang oras na malaman mo ang isang bagong wika, dapat kang lumikha ng isang simpleng programa upang maipakita ang "Hello World!" Sa screen. Tiyak na tinitiyak nito na makukuha mo ang mga kinakailangang tool at patakbuhin at isama ang isang bagay na simple. Tulad ng pagbabasa ng "pagsubok, pagsubok, 1, 2, 3" sa isang mikropono!

Sa kasong ito, gagamitin namin ang Visual Studio upang lumikha ng isang console app. Kaya kapag nauna ka na at nai-download ang Visual Studio (libre ito), i-click ang:

File> Bago> Proyekto

At pagkatapos:

Visual C #> Windows Classic Desktop> Console App (.NET Framework)

Ito ay kung paano kami nagtatayo ng isang app na tatakbo sa Windows console.

Gamit na, ang hubad na istraktura ng buto ng iyong proyekto ay lilitaw sa pangunahing window. Ipakita sa iyo ang code na ganito:

namespace ConsoleApp3 {Program Program {static void Main (string args) {}}}

Ngayon magdagdag lamang ng dalawang linya, tulad nito:

namespace ConsoleApp3 {Program Program {static void Main (string args) {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}}

Pupunta ito sa pagsulat ng "Hello World!" Sa screen, at pagkatapos ay naghihintay ng isang key pindutin. Kapag hinawakan ng gumagamit ang anumang susi, ang programa ay matatapos at awtomatikong lalabas.

Tandaan na ang parehong mga linya na ito ay nagtatapos sa isang semicolon. Ito ay dahil ang anumang pahayag sa C # ay dapat magtapos sa isang semicolon, na nakikipag-usap sa C # na ang linya ay tapos na (pareho ito sa Java). Ang tanging pagbubukod ay kapag ang linya ay sinusundan kaagad ng isang bukas na bracket, na ipapaliwanag namin sa isang sandali.

Pindutin ang pindutan ng "Start" sa tuktok ng screen, at dapat itong ilunsad ang app, na pinapayagan kang makita ito sa pagsasanay.

Ang mga klase ay mga piraso ng code na naglalarawan ng mga bagay, na epektibong piraso ng data

Kaya, ano ba talaga ang nangyayari dito?

Pagsisimula sa C #: mga pamamaraan at klase

Upang malaman ang C # programming para sa Android, kailangan mong maunawaan ang mga klase at pamamaraan.

Ang mga klase ay mga piraso ng code na naglalarawan ng mga bagay, na epektibong piraso ng data. Hindi mo kailangang mag-alala nang labis tungkol sa ito upang magsimula sa: alam lamang na ang pahina ng code na nagtatrabaho ka sa ngayon ay tinatawag na isang "klase" at maaari kang makipag-ugnay sa iba pang mga klase sa iyong proyekto. Ang isang proyekto ay maaaring magkaroon lamang ng isang klase, kasama ang lahat ng iyong code na nagtatrabaho mula doon, o maaari itong magkaroon ng maramihang.

Sa loob ng bawat klase, magkakaroon ka rin ng mga pamamaraan. Ang mga pamamaraan na ito ay mga snippet ng code na maaari mong sumangguni sa anumang oras mula sa loob ng klase na iyon - at kung minsan mula sa labas nito.

Sa kasong ito, tinawag ang klase Program. Ito ay tinukoy mismo sa tuktok ng linya na bumabasa: Program ng klase. At kung binuksan mo ang window ng "Solution Explorer" sa kanan, makakahanap ka ng Program.cs. Ang pangalan ng klase ay palaging pareho sa filename.

Gumagamit kami pagkatapos ng isang kulot na bracket upang maglaman ng lahat ng mga code na sumusunod. Sabihin sa amin ng mga kulot na bracket na ang lahat ng sumusunod ay kabilang sa magkasama. Kaya, hanggang sa magsara ang bracket, ang lahat ng mga sumusunod na code ay bahagi ng Program.

Sinusundan ito ng aming unang pamamaraan, tukuyin ng sumusunod na linya:

static na walang bisa Main (string args)

Susundan ito pagkatapos ng mas bukas na bracket, na nangangahulugang ang susunod na piraso ng code ay bahagi ng "Main" na pamamaraan (na nasa loob pa rin ng klase ng Program). At doon na inilalagay ang aming "Hello World".

Mahalagang sabihin sa amin ng "Static void" na ang pamamaraang ito ay gumagawa ng isang bagay na nasa sarili (sa halip na pagmamanipula ng data na gagamitin ng mas malawak na programa) at hindi ito mai-refer ng mga klase sa labas. Ang "string args" na bagay ay nagbibigay-daan sa amin upang maipasa ang impormasyon sa pamamaraan upang manipulahin ang paglaon. Ang mga ito ay tinatawag na "mga parameter" at "mga argumento". Muli, hindi mo na kailangang mag-alala tungkol sa anuman sa ngayon. Alamin lamang na ang "static na walang bisa" na sinusundan ng isang salita, bracket, at mga kulot na bracket, ay minarkahan ang pagsisimula ng isang bagong pamamaraan.

Ang susunod na dalawang linya ay ang mga naidagdag namin: nakakakuha sila ng console at pagkatapos ay i-access ang mga utos nito upang sumulat sa screen at maghintay para sa isang key press.

Sa wakas, isinasara namin ang lahat ng aming mga bracket: una ang pamamaraan, pagkatapos ay ang klase, at pagkatapos ay ang "namespace" na kung saan ay ang pangalan ng proyekto na pag-aari ng klase (sa kasong ito "ConsoleApp3" - Ginawa ko ang mga nakaraang apps ng pagsubok sa ganitong paraan) .

Nalilito? Huwag kang mag-alala, malapit nang magkaroon ng kahulugan.

Paggamit ng mga pamamaraan

Kaya ang mga pamamaraan ay mga bundle ng code na may mga pangalan. Upang ipakita kung bakit gumagamit kami ng mga pamamaraan, makakatulong ito upang lumikha ng bago at ilagay ito upang gumana bilang isang halimbawa.

Kaya, lumikha ng isang bagong pamamaraan na nakatira sa loob ng klase ng Program (kaya kinakailangang nasa loob ng mga kulot na bracket, ngunit sa labas ng mga kulot na bracket na kabilang sa "Main").

Tawagan itong "NewMethod", at pagkatapos ay ilagay ang dalawang linya na isinulat mo lamang sa loob dito. Ito ay dapat magmukhang ganito:

Programa ng klase {static void Main (string args) {} static na walang bisa NewMethod () {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}

Ngayon magdagdag ng isang sanggunian sa NewMethod sa iyong Pangunahing pamamaraan, tulad ng:

static na walang bisa Main (string args) {ar ​​NewMethod (); }

Pupunta ito pagkatapos na "tawagan" ang pamamaraan na nilikha mo lamang, mahalagang panunudyo ang programa sa direksyong iyon. Pindutin ang Start at makikita mo ang parehong bagay na nangyayari tulad ng dati. Maliban ngayon kung nais mo, maaari mong isulat ang "NewMethod ();" nang maraming beses hangga't gusto mo at patuloy na ulitin ang teksto nang hindi kinakailangang sumulat ng maraming code.

Sa paglipas ng isang malaking programa, ang kakayahang mag-refer ng mga snippet ng code tulad nito ay nagiging hindi kapani-paniwalang malakas. Ito ay isa sa mga pinakamahalagang bagay upang maunawaan kapag sinubukan mong malaman ang C # programming para sa Android.

Maaari kaming lumikha ng maraming mga pamamaraan hangga't gusto namin sa ganitong paraan at sa ganoong paraan ay may isang napaka-maayos at organisadong piraso ng code. Kasabay nito, maaari rin tayong sumangguni ng mga pamamaraan na "itinayo" sa C # at anumang mga aklatan na maaaring magamit namin. Ang "Main" ay isang halimbawa ng isang "built-in" na pamamaraan. Ito ang pamamaraan na magsisimula ang lahat ng mga programa, at nauunawaan ng C # na dapat muna itong maisagawa. Kung wala kang inilalagay dito, walang mangyayari!

Ang mga pangangatwiran na kasama sa mga bracket sa kasong ito ay kinakailangan lamang dahil iyon ang paraan na idinisenyo ng Microsoft ang Pangunahing pamamaraan. Gayunpaman, mabuti kaming iwanan na walang laman ang aming mga bracket.

Paggamit ng mga variable

Ngayon na oras na talagang gumawa ng isang bagay na medyo kawili-wili sa aming code. Partikular, tingnan kung paano mo gagamitin ang mga variable upang gawing mas pabago-bago ang programa. Ito ay isa sa mga pinakamahalagang bagay upang maunawaan kung nais mong malaman ang C # programming.

Ang isang variable ay karaniwang isang lalagyan para sa isang piraso ng data. Ibalik ang iyong isip sa matematika sa highschool, at maaari mong tandaan na makita ang mga bagay na ganito:

10 + x = 13
Maghanap ng x

Dito, ang "x" ay isang variable, at syempre ang halaga na kinakatawan nito ay "3".

Ito rin ay eksakto kung paano gumagana ang isang variable sa programming. Maliban dito, ang isang variable ay maaaring kumatawan ng maraming iba't ibang mga uri ng data: kabilang ang teksto.

Upang lumikha ng isang bagong variable, kailangan muna nating sabihin sa C # kung anong uri ng data na ito ay gagamitin upang maglaman.

Kaya sa loob ng iyong NewMethod () na pamamaraan, una kang gagawa ng iyong variable, at pagkatapos ay bibigyan mo ito ng isang halaga. Pagkatapos ay idagdag namin ito sa aming utos na "WritingLine":

int number; bilang = 10; Console.WriteLine ("Hello World!" + Number);

Gumamit kami ng isang uri ng variable na tinatawag na "integer" na maaaring maging anumang buo na numero. Sa C #, tinutukoy namin ang mga ito gamit ang "int". Gayunpaman, madali lamang naming ginamit ang isang "float" halimbawa, na kung saan ay isang "lumulutang point variable" at pinapayagan kaming gumamit ng mga lugar na desimal.

Kung nagpapatakbo ka ng code na ito, dapat na ngayon ay sumulat ng "Kamusta sa Mundo! 10 "sa screen. At syempre, mababago natin ang halaga ng "bilang" sa anumang oras upang mabago ang.

Dahil ang "number" ay nilikha sa loob ng NewMethod (), hindi namin ma-access ito mula sa ibang lugar sa aming code. Ngunit kung inilalagay natin ito sa labas ng lahat ng mga pamamaraan, pagkatapos ay magagamit ito sa buong mundo. Upang gawin iyon, kailangan nating tiyakin na ang variable ay static din subalit:

Program ng klase {static int number = 10; static na walang bisa Main (string args) {NewMethod (); } static na walang bisa NewMethod () {Console.WriteLine ("Hello World!" + number); Console.ReadKey (); }}

Sa wakas, may isa pang paraan upang maipasa namin ang data na ito, at iyon ay gamitin ito bilang isang argumento, sa gayon ay ipapasa ito sa aming pamamaraan. Ito ay maaaring magmukhang ganito:

static na walang bisa Main (string args) {int number = 10; Console.WriteLine ("Kumusta doon, anong pangalan mo?"); NewMethod (bilang); } static na walang bisa NewMethod (int number) {Console.WriteLine ("Hello World!" + number); Console.ReadKey (); }}

Dito, tinukoy namin ang aming pamamaraan ng NewMethod bilang nangangailangan ng isang argumento, na dapat maging isang integer, at kung saan ay tinutukoy sa loob ng pamamaraan bilang "bilang". Ginagawa namin ito sa pamamagitan lamang ng pagdaragdag ng impormasyong iyon sa mga kulot na braket. Kung gayon, kapag tinawag natin ang pamamaraan mula sa kahit saan pa sa programa, kailangan nating "ipasa" ang halagang iyon sa loob ng mga bracket. Maaari kang lumikha ng mga pamamaraan na may maraming mga parameter, kung saan, ihiwalay mo lamang ang mga nakalistang variable na may mga koma.

Mayroong iba't ibang mga sitwasyon kung saan ang paggamit ng lahat ng mga iba't ibang mga diskarte upang mag-juggle ng data ay angkop. Ang mahusay na programming ay nangangahulugang paghahanap ng tama para sa trabaho!

Ang pagpasa ng mga argumento at paggamit ng mga string

Subukang patakbuhin ang susunod na piraso ng code at makita kung ano ang mangyayari:

Program ng klase {static void Main (string args) {Console.WriteLine ("Kumusta doon, ano ang pangalan mo?"); NewMethod (Console.ReadLine ()); } static na walang bisa NewMethod (String UserName) {Console.WriteLine ("Hello" + UserName); Console.ReadKey (); }}

Dapat mong makita na sinenyasan ka na ipasok ang iyong pangalan, at ang Console pagkatapos ay magaling ka sa pamamagitan nito. Ang simpleng piraso ng code na ito ay naglalaman ng isang bilang ng mga kapaki-pakinabang na aralin.

Una, nakikita namin ang isang halimbawa kung paano gumamit ng ibang uri ng variable, na tinatawag na isang String. Ang String ay isang serye ng mga character, na maaaring maging isang pangalan, o maaaring maging isang buong kuwento.

Kaya, madali mong isulat ang UserName = "Adam". Ngunit sa halip, nakakakuha kami ng string mula sa console kasama ang pahayag: Console.ReadLine ().

Maaaring nakasulat kami:

Gumagamit ng String; Gumagamit = Console.ReadLine (); NewMethod (Gumagamit);

Ngunit upang mapanatili ang aming code nang maayos hangga't maaari, nilaktawan namin ang mga hakbang na ito at inilagay ang direktang "ReadLine" sa loob ng mga bracket.

Pagkatapos ay ipinapasa namin ang string na iyon sa aming NewMethod, at binabati namin ang gumagamit, gamit ang pamamaraan na pamilyar ka na.

Ang String ay isang serye ng mga character, na maaaring maging isang pangalan, o maaaring maging isang buong kuwento.

Inaasahan, nagsisimula ka nang maunawaan nang kaunti tungkol sa kung bakit nakasulat ang C # kung paano ito, at kung paano mo magagamit ang mga bagay tulad ng mga variable at pamamaraan upang lumikha ng ilang kakayahang umangkop at malakas na software.

Ngunit mayroong isang mas mahalagang aspeto na dapat mong malaman kung nais mong malaman ang C # programming: control control.

Alamin ang control ng C # at bumuo ng mga simpleng pagsusulit!

Ang isa sa mga kadahilanan na gumagamit kami ng mga variable kapag coding, upang madali naming mai-edit ang aming mga programa sa paglaon. Ang isa pa ay upang makakuha ka ng impormasyon mula sa gumagamit, o mabuo ito nang sapalaran.

Ngunit marahil ang pinakamahusay na dahilan upang malaman ang mga variable ng # #, ay upang ang iyong mga programa ay maaaring maging pabago-bago: upang maaari silang gumanti nang naiiba depende sa kung paano ito ginagamit.

Sa puntong iyon, kailangan natin ng "control control", o "kondisyon na mga pahayag". Ito ay talagang magarbong mga paraan ng pagsasabi na magsasagawa kami ng code sa higit sa isang paraan, depende sa halaga ng isang variable.

At isa sa pinakamalakas na paraan upang gawin iyon ay may pahayag na "kung". Sa halimbawang ito, batiin natin ang aming pangunahing gumagamit nang iba kaysa sa iba sa pamamagitan ng paghanap ng kanilang username.

static na walang bisa NewMethod (String UserName) {Console.WriteLine ("Hello" + UserName); kung (UserName.Equals ("Adam")) {Console.WriteLine ("Welcome back sir"); } Console.ReadKey (); }

Ang mga pahayag na "Kung" ay gumagana sa pamamagitan ng pagsubok sa bisa ng isang pahayag, na papasok sa loob ng mga bracket. Sa kasong ito, tatanungin namin kung ang string ng UserName ay katulad ng string na "Adam". Kung ang pahayag na iyon sa mga bracket ay totoo - ang dalawang mga string ay pareho - kung gayon ang code sa sumusunod na mga kulot na bracket ay papatayin. Kung hindi, pagkatapos ay laktawan ang mga linyang iyon.

Gayundin, maaari nating ihambing ang mga integer at floats, at maaari nating subukan upang makita kung ang isa ay mas malaki kaysa sa iba pa, atbp Maaari pa nating gamitin ang maraming magkakaibang kung ang mga pahayag sa loob ng isa't isa tulad ng mga manika ng Russia. Tinatawag namin itong mga "nested ifs".

Sa susunod

Marami pang mga diskarte na maaari mong gamitin para sa control control - kabilang ang mga bagay tulad ng mga pahayag sa switch. Sana, kahit na, maaari mo nang makita kung paano namin magagamit ang mga pahayag at pamamaraan na ito upang simulan ang paggawa ng ilang mga kapaki-pakinabang na bagay. Madali mong i-on ang code na ito sa isang pagsusulit na!

Sa kalaunan C # na may mga tool tulad ng Unity ay magpapahintulot sa iyo na bumuo ng ganap na pagganap na mga laro!

Ngunit upang talagang makagawa ng mga kamangha-manghang tool at laro, may ilang mga bagay na kailangan nating galugarin. Kaya sorpresa! May magiging bahagi ng dalawa!

Sa susunod na aralin, matutuklasan mo kung paano lumikha ng mga loop na umulit sa paglipas ng panahon, pati na rin kung paano lumikha ng mga bagong klase at makihalubilo sa kanila. Makita ka nga!