Deklarasyon:
Ang mga array ay idineklara gamit ang “type[] ArrayName;” syntax kung saan ang uri ay nagpapahiwatig ng uri ng mga miyembro sa koleksyon ng array, at ang 'ArrName' ay ang pamagat na itinalaga sa array. Ang isang deklarasyon ng isang array ay tinutukoy ng mga square bracket [].
uri [ ] ArrayName = bagong uri [ ] ; Ang mga listahan ay idineklara gamit ang “List
Listahan < uri > listName = bagong Listahan < uri > ( ) ;
Pagsisimula:
Gumagamit ang mga array ng mga kulot na brace {} upang ilakip ang mga halaga, habang ang mga listahan ay gumagamit ng bagong List
uri [ ] ArrayName = { v1 , v2 , v3 , ... } ;
Listahan < uri > listName = bagong Listahan < uri > { v1 , v2 , v3 , ... } ;
Pagdaragdag ng mga Halaga:
Mahalagang tandaan na ang mga C# array ay nagtataglay ng isang tiyak na laki. Kung kailangan ng ibang laki, kailangang gumawa ng bagong array na 'newArr' na may gustong laki (kasalukuyang haba + bilang ng mga bagong value). Idagdag ang orihinal na array na 'OrgArr' sa bagong array at italaga ang mga bagong value sa mga bagong posisyon sa bagong array at i-update ang reference sa bagong array.
Array. Kopya ( OrgArr , bagongArr , OrgArr. Ang haba ) ;
bagongArr [ OrgArr. Ang haba ] = 14 ; // bagong halaga
bagongArr [ OrgArr. Ang haba + 1 ] = 2 ; // bagong halaga
OrgArr = bagongArr ; // I-update ang reference int[] NewArr = new int[OrgArr.Length + 2];
Nag-aalok ang mga listahan ng flexibility sa mga tuntunin ng pamamahala ng laki. Kapag nasimulan ang isang listahan, magsisimula ito sa isang paunang kapasidad, ngunit maaari itong awtomatikong lumawak habang nagdaragdag ng higit pang mga elemento. Ang kakayahang baguhin ang laki ng dynamic na ito ay nagbibigay-daan sa mga listahan na umangkop sa pagbabago ng mga kinakailangan. Ang mga listahan ng C# ay nagbibigay ng isang Add() function upang idagdag ang mga halaga sa listahan. Narito kung paano ka makakapagdagdag ng mga halaga sa isang listahan ng C#:
Mga Array kumpara sa Mga Listahan : Paghahambing ng Paggamit sa C #
Pag-access sa Mga Halaga
Ang mga halaga sa array number ay ina-access gamit ang index notation [], ibig sabihin, gamit ang index number sa mga bracket at ini-save sa isa pang variable.
uri ng elemento = ArrayName [ index ] ;Upang ma-access ang mga halaga sa isang listahan ng C#, maaari mo ring gamitin ang index notation [] kasama ang nais na posisyon ng index na katulad ng mga array.
uri ng elemento = ListName [ index ] ;
Pag-alis ng mga Halaga
Ang mga array ay may nakatakdang haba. Samakatuwid, para maalis ang mga elemento, dapat gumawa ng bagong array na may mas maliit na laki, at dapat kopyahin ang mga kasalukuyang elemento. Ito ay maaaring gawin sa pamamagitan ng paggamit ng Array.Copy() function gaya ng ipinaliwanag sa seksyong 'Pagdaragdag ng Mga Halaga'. Sa mga listahan ng C#, ang pag-alis ng mga halaga ay mas simple at mas intuitive. Ang klase ng List
Bilangin ang mga Halaga
Upang mabilang ang mga halaga sa isang C# array, maaari mong gamitin ang attribute ng haba ng array. Ang length property ay nagbibigay sa iyo ng kabuuang bilang ng mga value sa array.
int bilangin = arrayName. Ang haba ;Upang mabilang ang mga halaga sa isang listahan ng C#, maaari mong gamitin ang tampok na 'bilang' ng listahan. Ang kabuuang halaga ng mga elemento na kasalukuyang naninirahan sa listahan ay ibinabalik din ng attribute na 'count'.
int bilangin = listName. Bilangin ;Ulitin ang Mga Halaga
Upang umulit sa mga halaga sa isang C# array, maaari kang gumamit ng loop na 'para sa' na may haba ng array bilang kundisyon ng loop.
para sa ( int i = 0 ; i < ArrayName. Ang haba ; i ++ ) {uri e = arrayName [ i ] ;
Console. WriteLine ( Ito ay ) ;
}
Upang umulit sa mga halaga sa isang listahan ng C#, maaari kang gumamit ng 'foreach' na loop dahil pinapasimple nito ang proseso ng pag-ulit sa pamamagitan ng awtomatikong pag-ulit sa mga elemento.
foreach ( i-type ang e sa listName ) {Console. WriteLine ( Ito ay ) ;
}
Halimbawa 1: C# Arrays
Ang ibinigay na code ay nagdedeklara at nagpapasimula ng isang integer array na pinangalanang 'Arr' na may haba na 5 at nagtatalaga ng mga halaga sa mga elemento nito. Ang mga nakatalagang halaga sa mga elemento ng array ay 11, 12, 13, 14, at 15. Ang code ay magpapatuloy sa pagpapakita ng mga elemento ng array gamit ang 'para sa' loop. Ang bawat bahagi ay ipinapakita sa isang natatanging linya gamit ang Console.WriteLine() na paraan.
Pagkatapos ipakita ang mga orihinal na elemento, binago ng code ang elemento sa index 2 sa pamamagitan ng pagtatalaga nito ng bagong halaga na 10. Susunod, ipinapakita ng code ang binagong array sa pamamagitan ng pag-ulit muli sa mga elemento gamit ang 'para sa' loop. Panghuli, ipinapakita ng code ang kabuuang bilang ng mga value na nasa array gamit ang property na 'Arr.Length' na nagbubunga ng haba ng array.
gamit ang System ;klase Dummy {
static walang bisa Pangunahing ( ) {
int [ ] Arr = bago int [ 5 ] { labing-isa , 12 , 13 , 14 , labinlima } ;
Console. WriteLine ( 'Mga elemento:' ) ;
para sa ( int i = 0 ; i < Arr. Ang haba ; i ++ )
{
Console. WriteLine ( Arr [ i ] ) ;
}
Arr [ 2 ] = 10 ;
Console. WriteLine ( 'Binagong array:' ) ;
para sa ( int i = 0 ; i < Arr. Ang haba ; i ++ )
{
Console. WriteLine ( Arr [ i ] ) ;
}
Console. WriteLine ( 'Bilang ng mga elemento: ' + Arr. Ang haba ) ;
}
}
Halimbawa 2: Mga Listahan ng C#
Ang sumusunod na ibinigay na code ay nagpapakita ng paggamit ng isang listahan ng C# upang mag-imbak at magmanipula ng isang koleksyon ng mga integer. Una, sinisimulan ng code ang isang listahan na pinangalanang 'Arr' na may limang integer: 11, 12, 13, 14, at 15. Ito ay nakakamit gamit ang List
Susunod, ipi-print ng program ang mensaheng 'Mga Elemento:' at magpapatuloy sa pag-ulit sa bawat elemento sa listahan gamit ang isang 'foreach' na loop. Sa bawat pag-ulit, ang kasalukuyang elemento ay naka-print sa console gamit ang Console.WriteLine() na paraan.
Pagkatapos, binago ng code ang value sa index 2 ng listahan sa pamamagitan ng pagtatalaga nito ng value na 10 (Arr[2] = 10). Binago ng linyang ito ang ikatlong elemento sa listahan mula 13 hanggang 10. Kasunod ng pagbabago, muling ipi-print ng program ang mensaheng 'Modified list:' at umuulit sa na-update na listahan, na nagpi-print ng bawat elemento sa console. Pagkatapos ay ipinapakita ng code ang bilang ng mga halaga sa listahan gamit ang 'Arr.Count'. Ibinabalik ng property na ito ang bilang ng mga item na naroroon sa listahan na, sa sumusunod na senaryo, ay nangyayari na 5.
Panghuli, inaalis ng code ang elementong may halagang 4 mula sa listahan gamit ang Arr.Remove(4) na paraan. Hinahanap ng pamamaraang ito ang tinukoy na halaga sa listahan at inaalis ang unang paglitaw nito. Sa wakas, ini-print ng program ang mensaheng 'Listahan pagkatapos alisin:' at umuulit muli sa listahan, na ipinapakita ang bawat natitirang elemento pagkatapos ng operasyon sa pag-alis.
gamit ang System ;gamit ang System. Mga koleksyon . Generic ;
klase Dummy {
static walang bisa Pangunahing ( ) {
Listahan < int > Arr = bagong Listahan < int > ( ) { labing-isa , 12 , 13 , 14 , labinlima } ;
Console. WriteLine ( 'Mga elemento:' ) ;
foreach ( int n sa Arr )
{
Console. WriteLine ( n ) ;
}
Arr [ 2 ] = 10 ;
Console. WriteLine ( 'Binagong listahan:' ) ;
foreach ( int n sa Arr )
{
Console. WriteLine ( n ) ;
}
Console. WriteLine ( 'Bilang ng mga elemento: ' + Arr. Bilangin ) ;
Arr. Alisin ( 4 ) ;
Console. WriteLine ( 'Listahan pagkatapos alisin:' ) ;
foreach ( int n sa Arr )
{
Console. WriteLine ( n ) ;
}
}
}
Konklusyon
Sinasaklaw ng gabay na ito ang mga pangunahing pagkakaiba sa syntax sa pagitan ng mga C# array at C# na mga listahan. Ang mga array ay may nakapirming haba at naa-access sa pamamagitan ng index, samantalang ang mga listahan ay dynamic na laki at nagbibigay ng mga karagdagang pamamaraan upang magdagdag at mag-alis ng mga elemento. Kasabay nito, nagbigay kami ng mga programa sa listahan ng C# na nagpapakita ng deklarasyon, pagsisimula, pag-access, pagbabago, pagbibilang, at pagdaragdag ng mga elemento.