I C# fungerar arrayer som behållare för att lagra element av samma datatyp. När du skapar en array finns det flera sätt att initiera den med element. Den här artikeln fördjupar sig i de olika metoderna för att initiera arrayer i C#, vilket ger en omfattande utforskning av varje tillvägagångssätt.
Metoder för att initiera arrayer i C#
Arrayer är en viktig datastruktur i datorprogrammering som gör att du kan lagra och manipulera en samling element av samma datatyp på sammanhängande minnesplatser. Här är några sätt att initiera arrayer i C#:
1: Initiera arrayer med Array Initializer-syntax
Det enklaste tillvägagångssättet för att initiera en array är att använda arrayinitieringssyntaxen eftersom detta innebär att arrayelementen omges av klammerparenteser, separerade med kommatecken, till exempel:
int [ ] siffror = { 1 , 2 , 3 , 4 , 5 } ;
I den här koden skapas en heltalsmatris med namnet 'nummer' och initieras med värdena 1 till 5. På samma sätt kan du använda samma syntax för att initiera en flerdimensionell matris.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Här är en exempelkod som använder initialiseringssyntaxen för att initiera en 1D- och 2D-array i C#:
använder System;
klass array
{
statiskt tomrum Main ( sträng [ ] args )
{
// Initiera en 1D-array med hjälp av initialiseringssyntaxen
int [ ] array1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Värden i array1D:' ) ;
för ( int i = 0 ; i < array1D.Length; i++ ) {
Console.WriteLine ( array1D [ i ] ) ;
}
// Initiera en 2D-array med hjälp av initialiseringssyntaxen
int [ , ] array2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Värden i array2D:' ) ;
för ( int i = 0 ; i < array2D.GetLength ( 0 ) ; i++ ) {
för ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, array2D [ I j ] ) ;
}
}
}
}
I den här koden använder vi initialiseringssyntaxen för att initiera en 1-dimensionell heltalsmatris som kallas array1D med värdena 1, 2, 3, 4 och 5.
Vi använder också initialiseringssyntaxen för att initiera en 2-dimensionell heltalsmatris som kallas array2D med värdena {1, 2}, {3, 4} och {5, 6}.
Vi använder sedan extra for-loopar för att iterera genom varje element i varje array och skriva ut dess värde till konsolen.
2: Initiera matriser med det nya nyckelordet
En ytterligare metod för att initiera en array involverar att använda ny nyckelord. Detta innebär att specificera storleken på arrayen inom hakparenteser, följt av det nya nyckelordet, och sedan datatypen för arrayelementen. Till exempel:
int [ ] siffror = ny int [ 5 ] ;
Den här koden skapar en heltalsmatris med namnet nummer med storleken 5 och initierar alla element till deras standardvärde, vilket är 0 för heltalsmatriser.
Här är syntaxen för att initiera en flerdimensionell array med det nya nyckelordet i C#:
< typ > [ , ] < arrayName > = ny < typ > [ < längd1 > , < längd2 > , ... ] { { < initialvärden > } } ;
I den här syntaxen är
Här är ett exempel på hur man använder denna syntax för att initiera en 2-dimensionell heltalsmatris:
int [ , ] myArray = ny int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
I det här exemplet initierar vi en 2d heltalsarray som heter myArray med 3 rader och 2 kolumner med det nya nyckelordet. Vi tillhandahåller också initiala värden för varje element i arrayen med hjälp av syntaxen med dubbla krulliga klammerparenteser. Värdena är {1, 2}, {3, 4} och {5, 6}, motsvarande elementen i varje rad.
Här är ett exempel på hur du använder det nya nyckelordet för att initiera både en 1-dimensionell och en 2-dimensionell array i C#, tillsammans med kod för att skriva ut värdena i varje array:
använder System;klassuppsättning
{
statiskt tomrum Main ( sträng [ ] args )
{
// Initiera a 1 -dimensionell array
int [ ] myArray1D = ny int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Värden i myArray1D:' ) ;
för ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Initiera a 2 -dimensionell array
int [ , ] myArray2D = ny int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Värden i myArray2D:' ) ;
för ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
för ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ I j ] ) ;
}
}
}
}
I den här koden använder vi det nya nyckelordet för att initiera en endimensionell heltalsmatris som kallas myArray1D med värdena 1, 2, 3, 4 och 5, och en 2-dimensionell heltalsmatris som kallas myArray2D med värdena {1, 2}, {3, 4} och {5, 6}.
Vi använder sedan for loops för att iterera genom varje element i varje array och skriva ut dess värde till konsolen. Observera att för den 2-dimensionella arrayen använder vi GetLength() för att bestämma antalet rader och kolumner och använda kapslade för loopar för att iterera genom varje element.
3: Initiera arrayer med loopar
Matriser kan också initieras med loopar. Ett tillvägagångssätt är att använda en for-loop, som gör att du kan iterera genom arrayen och tilldela värden till varje element.
int [ ] siffror = ny int [ 5 ] ;för ( int i = 0 ; i < siffror.Längd; i++ )
{
tal [ i ] = i + 1 ;
}
Den här koden skapar en heltalsmatris med namnet nummer med storleken 5 och tilldelar varje element ett värde lika med dess index plus 1. Här är ett exempel på hur man initierar en 2-dimensionell heltalsmatris i C# med loopar:
för ( int i = 0 ; i < 3 ; i++ )
{
för ( int j = 0 ; j < 2 ; j++ )
{
myArray [ I j ] = i + j;
}
}
I det här exemplet använder vi kapslade för loopar för att iterera genom varje element i en 2-dimensionell heltalsmatris som kallas myArray , som har 3 rader och 2 kolumner. För varje element sätter vi dess värde till summan av dess rad- och kolumnindex med hjälp av uttrycket i + j.
Här är ett exempel på hur man använder loopar för att initiera både en 1-dimensionell och en 2-dimensionell array i C#, tillsammans med kod för att skriva ut värdena i varje array:
använder System;klass array
{
statiskt tomrum Main ( sträng [ ] args )
{
// Initiera a 1 -dimensionell array med hjälp av en slinga
int [ ] myArray1D = ny int [ 5 ] ;
för ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = i + 1 ;
}
Console.WriteLine ( 'Värden i myArray1D:' ) ;
för ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Initiera a 2 -dimensionell array med hjälp av kapslade loopar
int [ , ] myArray2D = ny int [ 3 , 2 ] ;
för ( int i = 0 ; i < 3 ; i++ )
{
för ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ I j ] = i + j;
}
}
Console.WriteLine ( 'Värden i myArray2D:' ) ;
för ( int i = 0 ; i < 3 ; i++ )
{
för ( int j = 0 ; j < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ I j ] ) ;
}
}
}
}
I den här koden använder vi en for-loop för att initiera en 1-dimensionell heltalsmatris som kallas myArray1D med värdena 1, 2, 3, 4 och 5. Vi använder också kapslade för loopar för att initiera en 2-dimensionell heltalsmatris som kallas myArray2D med värdena {0, 1}, {1, 2} och {2, 3} med uttrycket i + j.
Använd sedan extra for-loopar för att iterera genom varje element i varje array och skriva ut dess värde till konsolen.
4: Initiera arrayer med Array.Copy()
Ett alternativt tillvägagångssätt för att initiera en array involverar att använda Array.Copy()-funktionen. Detta innebär att skapa en källmatris med de önskade elementen och sedan kopiera dem till en målmatris. Till exempel:
int [ ] källa = { 1 , 2 , 3 , 4 , 5 } ;int [ ] mål = ny int [ källa.Längd ] ;
Array.Copy ( källa , mål, källa.Längd ) ;
Den här koden skapar en heltalsmatris med namnet källa med värdena 1 till 5, skapar en ny heltalsmatris med namnet mål med samma storlek som källan och kopierar sedan elementen från källa till mål.
Tillåt mig att presentera ett exempel som visar användningen av Array.Copy för att initiera en tvådimensionell heltalsmatris i C#:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = ny int [ 3 , 2 ] ;
Array.Copy ( sourceArray, destinationArray, sourceArray.Length ) ;
I det här exemplet har vi en 2-dimensionell heltalsmatris som kallas sourceArray med 3 rader och 2 kolumner. Vi använder Array.Copy() att kopiera innehållet i sourceArray till en ny 2-dimensionell heltalsarray som kallas destinationArray, som också har 3 rader och 2 kolumner.
De Array.Copy() metoden tar tre argument : den källarray , den destinationsuppsättning , och den längd av de uppgifter som ska kopieras. I det här fallet kopierar vi hela innehållet i sourceArray in i destinationArray , så vi passerar sourceArray.Length som det tredje argumentet.
Observera att du kan använda Array.Copy() för att initiera matriser med valfritt antal dimensioner, så länge som käll- och målmatriserna har samma antal dimensioner och samma storlek i varje dimension.
Tänk också på det Array.Copy() utför en ytlig kopia av källmatrisen, vilket innebär att om källmatrisen innehåller referenstyper kommer referenserna att kopieras men själva objekten kommer inte att dupliceras.
Här är den fullständiga koden som används Array.Copy() funktion för att initiera arrayen i C#:
använder System;klass array
{
statiskt tomrum Main ( sträng [ ] args )
{
// Initiera a 1 -dimensionell array med Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = ny int [ 5 ] ;
Array.Copy ( sourceArray1D, destinationArray1D, sourceArray1D.Length ) ;
Console.WriteLine ( 'Värden i destinationArray1D:' ) ;
för ( int i = 0 ; i < destinationArray1D.Length; i++ ) {
Console.WriteLine ( destinationArray1D [ i ] ) ;
}
// Initiera a 2 -dimensionell array med Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] destinationArray2D = ny int [ 3 , 2 ] ;
Array.Copy ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( 'Värden i destinationArray2D:' ) ;
för ( int i = 0 ; i < destinationArray2D.GetLength ( 0 ) ; i++ ) {
för ( int j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, destinationArray2D [ I j ] ) ;
}
}
}
}
I den här koden använder vi Array.Copy() att initiera en 1-dimensionell heltalsmatris som kallas destinationArray1D med värdena 1, 2, 3, 4 och 5 från en källmatris som kallas sourceArray1D.
Vi använder också Array.Copy() för att initiera en 2-dimensionell heltalsmatris som kallas destinationArray2D med värdena {1, 2}, {3, 4} och {5, 6} från en källmatris som heter sourceArray2D.
Vi använder sedan extra for-loopar för att iterera genom varje element i varje array och skriva ut dess värde till konsolen.
Slutsats
I den här artikeln utforskade vi olika sätt att initiera arrayer i C#. Vi täckte upp arrayinitieringssyntaxen med det nya nyckelordet, initierade arrayer med loopar och använde Array.Copy()-metoden. Beroende på det specifika användningsfallet har var och en av dessa metoder sin egen uppsättning fördelar och nackdelar. Genom att bekanta dig med dessa olika tillvägagångssätt kan du välja den mest lämpliga för just dina behov.