Sa C#, ang mga array ay nagsisilbing mga lalagyan para sa pag-iimbak ng mga elemento ng parehong uri ng data. Kapag gumagawa ng isang array, mayroong maraming mga diskarte upang simulan ito sa mga elemento. Sinisiyasat ng artikulong ito ang iba't ibang paraan ng pagsisimula ng mga array sa C#, na nagbibigay ng komprehensibong paggalugad ng bawat diskarte.
Mga Paraan Upang Magsimula ng Mga Array sa C#
Ang mga array ay isang mahalagang istruktura ng data sa computer programming na nagbibigay-daan sa iyong mag-imbak at magmanipula ng isang koleksyon ng mga elemento ng parehong uri ng data sa magkadikit na mga lokasyon ng memorya. Narito ang ilang mga paraan upang simulan ang mga array sa C#:
1: Pagsisimula ng Array Gamit ang Array Initializer Syntax
Ang pinakasimpleng diskarte sa pagsisimula ng array ay sa pamamagitan ng paggamit ng array initializer syntax dahil kinapapalooban nito ang mga elemento ng array sa mga braces, na pinaghihiwalay ng mga kuwit, halimbawa:
int [ ] mga numero = { 1 , 2 , 3 , 4 , 5 } ;
Sa code na ito, ang isang integer array na pinangalanang 'mga numero' ay ginawa at sinisimulan gamit ang mga halaga 1 hanggang 5. Sa katulad na paraan, maaari mong gamitin ang parehong syntax upang simulan ang isang multidimensional array.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Narito ang isang halimbawang code na gumagamit ng initializer syntax upang simulan ang isang 1D at 2D array sa C#:
gamit ang System;
hanay ng klase
{
static void Main ( string [ ] args )
{
// Pagsisimula ng 1D array gamit ang initializer syntax
int [ ] array1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Mga halaga sa array1D:' ) ;
para sa ( int i = 0 ; i < array1D.Length; i++ ) {
Console.WriteLine ( array1D [ i ] ) ;
}
// Pagsisimula ng 2D array gamit ang initializer syntax
int [ , ] array2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Mga halaga sa array2D:' ) ;
para sa ( int i = 0 ; i < array2D.GetLength ( 0 ) ; i++ ) {
para sa ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, array2D [ ako, j ] ) ;
}
}
}
}
Sa code na ito, ginagamit namin ang initializer syntax upang simulan ang isang 1-dimensional na integer array na tinatawag na array1D na may mga value na 1, 2, 3, 4, at 5.
Ginagamit din namin ang initializer syntax upang simulan ang isang 2-dimensional na integer array na tinatawag na array2D na may mga value na {1, 2}, {3, 4}, at {5, 6}.
Gumagamit kami ng karagdagang para sa mga loop upang umulit sa bawat elemento ng bawat array at i-print ang halaga nito sa console.
2: Pagsisimula ng Mga Array Gamit ang bagong Keyword
Ang isang karagdagang paraan para sa pagsisimula ng isang array ay kinabibilangan ng paggamit ng bago keyword. Kabilang dito ang pagtukoy sa laki ng array sa mga square bracket, na sinusundan ng bagong keyword, at pagkatapos ay ang uri ng data ng mga elemento ng array. Halimbawa:
int [ ] mga numero = bagong int [ 5 ] ;
Lumilikha ang code na ito ng integer array na pinangalanang mga numero na may sukat na 5 at sinisimulan ang lahat ng elemento sa kanilang default na halaga, na 0 para sa mga integer array.
Narito ang syntax para sa pagsisimula ng multidimensional array gamit ang bagong keyword sa C#:
< uri > [ , ] < arrayName > = bago < uri > [ < haba1 > , < haba2 > ,... ] { { < initialValues > } } ;
Sa syntax na ito, ang
Narito ang isang halimbawa kung paano gamitin ang syntax na ito upang simulan ang isang 2-dimensional na integer array:
int [ , ] myArray = bagong int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Sa halimbawang ito, sinisimulan namin ang isang 2d integer array na tinatawag na myArray na may 3 row at 2 column gamit ang bagong keyword. Nagbibigay din kami ng mga paunang halaga para sa bawat elemento ng array gamit ang double curly braces syntax. Ang mga halaga ay {1, 2}, {3, 4}, at {5, 6}, na tumutugma sa mga elemento sa bawat hilera.
Narito ang isang halimbawa kung paano gamitin ang bagong keyword upang simulan ang parehong 1-dimensional at 2-dimensional na array sa C#, kasama ang code upang i-print ang mga halaga sa bawat array:
gamit ang System;hanay ng klase
{
static void Main ( string [ ] args )
{
// Pagsisimula a 1 -dimensional na hanay
int [ ] myArray1D = bagong int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Mga halaga sa myArray1D:' ) ;
para sa ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Pagsisimula a 2 -dimensional na hanay
int [ , ] myArray2D = bagong int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Mga halaga sa myArray2D:' ) ;
para sa ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
para sa ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ ako, j ] ) ;
}
}
}
}
Sa code na ito, ginagamit namin ang bagong keyword upang simulan ang isang one-dimensional integer array na tinatawag myArray1D na may mga value na 1, 2, 3, 4, at 5, at isang 2-dimensional integer array na tinatawag na myArray2D na may mga halagang {1, 2}, {3, 4}, at {5, 6}.
Pagkatapos ay ginagamit namin ang para sa mga loop upang umulit sa bawat elemento ng bawat array at i-print ang halaga nito sa console. Tandaan na para sa 2-dimensional na array, ginagamit namin GetLength() upang matukoy ang bilang ng mga row at column, at paggamit ng nested para sa mga loop upang umulit sa bawat elemento.
3: Pagsisimula ng Mga Array Gamit ang Mga Loop
Ang mga array ay maaari ding masimulan gamit ang mga loop. Ang isang diskarte ay ang paggamit ng isang for loop, na nagbibigay-daan sa iyong umulit sa array at magtalaga ng mga halaga sa bawat elemento.
int [ ] mga numero = bagong int [ 5 ] ;para sa ( int i = 0 ; i < mga numero.Haba; i++ )
{
numero [ i ] = ako + 1 ;
}
Lumilikha ang code na ito ng integer array na pinangalanang mga numero na may sukat na 5 at nagtatalaga sa bawat elemento ng value na katumbas ng index nito plus 1. Narito ang isang halimbawa kung paano magsisimula ng 2-dimensional integer array sa C# gamit ang mga loop:
para sa ( int i = 0 ; i < 3 ; i++ )
{
para sa ( int j = 0 ; j < 2 ; j++ )
{
myArray [ ako, j ] = i + j;
}
}
Sa halimbawang ito, gumagamit kami ng nested para sa mga loop upang umulit sa bawat elemento ng isang 2-dimensional na integer array na tinatawag myArray , na mayroong 3 row at 2 column. Para sa bawat elemento, itinatakda namin ang halaga nito sa kabuuan ng mga index ng row at column nito gamit ang expression na i + j.
Narito ang isang halimbawa kung paano gumamit ng mga loop upang masimulan ang parehong 1-dimensional at 2-dimensional na array sa C#, kasama ang code upang i-print ang mga halaga sa bawat array:
gamit ang System;hanay ng klase
{
static void Main ( string [ ] args )
{
// Pagsisimula a 1 -dimensional array gamit ang isang loop
int [ ] myArray1D = bagong int [ 5 ] ;
para sa ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = ako + 1 ;
}
Console.WriteLine ( 'Mga halaga sa myArray1D:' ) ;
para sa ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Pagsisimula a 2 -dimensional array gamit ang nested loops
int [ , ] myArray2D = bagong int [ 3 , 2 ] ;
para sa ( int i = 0 ; i < 3 ; i++ )
{
para sa ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ ako, j ] = i + j;
}
}
Console.WriteLine ( 'Mga halaga sa myArray2D:' ) ;
para sa ( int i = 0 ; i < 3 ; i++ )
{
para sa ( int j = 0 ; j < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ ako, j ] ) ;
}
}
}
}
Sa code na ito, gumagamit kami ng for loop para masimulan ang 1-dimensional integer array na tinatawag na myArray1D na may mga value na 1, 2, 3, 4, at 5. Gumagamit din kami ng nested for loops para makapagsimula ng 2-dimensional integer array na tinatawag na myArray2D na may mga value na {0, 1}, {1, 2}, at {2, 3} gamit ang expression na i + j.
Pagkatapos ay gumamit ng karagdagang para sa mga loop upang umulit sa bawat elemento ng bawat array at i-print ang halaga nito sa console.
4: Pagsisimula ng mga Array Gamit ang Array.Copy()
Ang isang alternatibong diskarte sa pagsisimula ng isang array ay kinabibilangan ng paggamit ng Array.Copy() function. Kabilang dito ang paggawa ng source array na may mga gustong elemento at pagkatapos ay pagkopya sa mga ito sa target na array. Halimbawa:
int [ ] pinagmulan = { 1 , 2 , 3 , 4 , 5 } ;int [ ] target = bagong int [ pinagmulan.Haba ] ;
Array.Kopya ( pinagmulan , target, source.Length ) ;
Ang code na ito ay gumagawa ng integer array na pinangalanang source na may mga value na 1 hanggang 5, lumilikha ng bagong integer array na pinangalanang target na may parehong laki bilang source, at pagkatapos ay kinokopya ang mga elemento mula sa source patungo sa target.
Pahintulutan akong magpakita ng isang halimbawa na nagpapakita ng paggamit ng Array.Copy upang simulan ang isang two-dimensional integer array sa C#:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = bagong int [ 3 , 2 ] ;
Array.Kopya ( sourceArray, destinationArray, sourceArray.Length ) ;
Sa halimbawang ito, mayroon kaming 2-dimensional na integer array na tinatawag sourceArray na may 3 row at 2 column. Ginagamit namin Array.Copy() upang kopyahin ang mga nilalaman ng sourceArray sa isang bagong 2-dimensional na integer array na tinatawag na destinationArray, na mayroon ding 3 row at 2 column.
Ang Array.Copy() tumatagal ng pamamaraan tatlong argumento : ang hanay ng pinagmulan , ang hanay ng patutunguhan , at ang haba ng data na kokopyahin. Sa kasong ito, kinokopya namin ang buong nilalaman ng sourceArray sa destinationArray , kaya pumasa kami sourceArray.Length bilang ikatlong argumento.
Tandaan na maaari mong gamitin Array.Copy() upang simulan ang mga array na may anumang bilang ng mga dimensyon, hangga't ang source at destination array ay may parehong bilang ng mga dimensyon at parehong laki sa bawat dimensyon.
Gayundin, tandaan na Array.Copy() gumaganap ng mababaw na kopya ng source array, na nangangahulugan na kung ang source array ay naglalaman ng mga uri ng reference, ang mga reference ay makokopya ngunit ang mga object mismo ay hindi madodoble.
Narito ang kumpletong code na gumagamit Array.Copy() function upang simulan ang array sa C#:
gamit ang System;hanay ng klase
{
static void Main ( string [ ] args )
{
// Pagsisimula a 1 -dimensional array gamit ang Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = bagong int [ 5 ] ;
Array.Kopya ( sourceArray1D, destinationArray1D, sourceArray1D.Length ) ;
Console.WriteLine ( 'Mga halaga sa destinationArray1D:' ) ;
para sa ( int i = 0 ; i < destinationArray1D.Length; i++ ) {
Console.WriteLine ( destinationArray1D [ i ] ) ;
}
// Pagsisimula a 2 -dimensional array gamit ang Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] destinationArray2D = bagong int [ 3 , 2 ] ;
Array.Kopya ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( 'Mga halaga sa destinationArray2D:' ) ;
para sa ( int i = 0 ; i < destinationArray2D.GetLength ( 0 ) ; i++ ) {
para sa ( int j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, destinationArray2D [ ako, j ] ) ;
}
}
}
}
Sa code na ito, ginagamit namin Array.Copy() upang simulan ang isang 1-dimensional na integer array na tinatawag na destinationArray1D na may mga value na 1, 2, 3, 4, at 5 mula sa isang source array na tinatawag na sourceArray1D.
Gumagamit din kami Array.Copy() upang simulan ang isang 2-dimensional na integer array na tinatawag na destinationArray2D na may mga value na {1, 2}, {3, 4}, at {5, 6} mula sa source array na tinatawag na sourceArray2D.
Gumagamit kami ng karagdagang para sa mga loop upang umulit sa bawat elemento ng bawat array at i-print ang halaga nito sa console.
Konklusyon
Sa artikulong ito, ginalugad namin ang iba't ibang paraan ng pagsisimula ng mga array sa C#. Sinasaklaw namin ang array initializer syntax, gamit ang bagong keyword, pagsisimula ng mga array gamit ang mga loop, at gamit ang Array.Copy() method. Depende sa partikular na kaso ng paggamit, ang bawat isa sa mga pamamaraang ito ay nagtataglay ng sarili nitong hanay ng mga pakinabang at disadvantages. Ang pagiging pamilyar sa mga magkakaibang pamamaraang ito ay magbibigay-daan sa iyong pumili ng pinakaangkop para sa iyong mga partikular na pangangailangan.