I C# tjener arrays som beholdere til lagring af elementer af samme datatype. Når du opretter et array, er der flere metoder til at initialisere det med elementer. Denne artikel dykker ned i de forskellige metoder til initialisering af arrays i C#, hvilket giver en omfattende udforskning af hver tilgang.
Metoder til at initialisere arrays i C#
Arrays er en vigtig datastruktur i computerprogrammering, der giver dig mulighed for at gemme og manipulere en samling af elementer af samme datatype i sammenhængende hukommelsesplaceringer. Her er nogle måder at initialisere arrays i C#:
1: Initialisering af arrays ved hjælp af Array Initializer-syntaksen
Den mest ligetil tilgang til at initialisere et array er ved at bruge array-initialiseringssyntaksen, da dette involverer at omslutte array-elementerne i klammer, adskilt af kommaer, for eksempel:
int [ ] tal = { 1 , 2 , 3 , 4 , 5 } ;
I denne kode oprettes en heltalsmatrix med navnet 'numbers' og initialiseres med værdierne 1 til 5. På samme måde kan du bruge den samme syntaks til at initialisere en multidimensional matrix.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Her er et eksempel på en kode, der bruger initialiseringssyntaksen til at initialisere et 1D- og 2D-array i C#:
bruger System;
klasse array
{
statisk tomrum Main ( snor [ ] args )
{
// Initialisering af et 1D-array ved hjælp af initialiseringssyntaksen
int [ ] array1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Værdier i array1D:' ) ;
til ( int i = 0 ; jeg < array1D.Længde; i++ ) {
Console.WriteLine ( array1D [ jeg ] ) ;
}
// Initialisering af et 2D-array ved hjælp af initialiseringssyntaksen
int [ , ] array2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Værdier i array2D:' ) ;
til ( int i = 0 ; jeg < array2D.GetLength ( 0 ) ; i++ ) {
til ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, array2D [ jeg, j ] ) ;
}
}
}
}
I denne kode bruger vi initialiseringssyntaksen til at initialisere et 1-dimensionelt heltalsarray kaldet array1D med værdierne 1, 2, 3, 4 og 5.
Vi bruger også initialiseringssyntaksen til at initialisere et 2-dimensionelt heltalsarray kaldet array2D med værdierne {1, 2}, {3, 4} og {5, 6}.
Vi bruger derefter yderligere for loops til at iterere gennem hvert element i hvert array og udskrive dets værdi til konsollen.
2: Initialisering af arrays ved hjælp af det nye nøgleord
En yderligere metode til initialisering af et array involverer at bruge ny søgeord. Dette involverer at angive størrelsen af arrayet i firkantede parenteser, efterfulgt af det nye nøgleord og derefter datatypen for array-elementerne. For eksempel:
int [ ] tal = ny int [ 5 ] ;
Denne kode opretter et heltalsarray med navnet numre med en størrelse på 5 og initialiserer alle elementer til deres standardværdi, som er 0 for heltalsarrays.
Her er syntaksen til initialisering af et multidimensionelt array ved hjælp af det nye nøgleord i C#:
< type > [ , ] < matrixnavn > = ny < type > [ < længde 1 > , < længde 2 > , ... ] { { < initialværdier > } } ;
I denne syntaks er
Her er et eksempel på, hvordan man bruger denne syntaks til at initialisere en 2-dimensionel heltalsmatrix:
int [ , ] myArray = ny int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
I dette eksempel initialiserer vi et 2d heltalsarray kaldet myArray med 3 rækker og 2 kolonner ved hjælp af det nye nøgleord. Vi leverer også startværdier for hvert element i arrayet ved hjælp af syntaksen med dobbelt krøllede klammer. Værdierne er {1, 2}, {3, 4} og {5, 6}, svarende til elementerne i hver række.
Her er et eksempel på, hvordan man bruger det nye nøgleord til at initialisere både et 1-dimensionelt og et 2-dimensionelt array i C#, sammen med kode til at udskrive værdierne i hvert array:
bruger System;klasse array
{
statisk tomrum Main ( snor [ ] args )
{
// Initialisering af en 1 -dimensionelt array
int [ ] myArray1D = ny int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Værdier i myArray1D:' ) ;
til ( int i = 0 ; jeg < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ jeg ] ) ;
}
// Initialisering af en 2 -dimensionelt array
int [ , ] myArray2D = ny int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Værdier i myArray2D:' ) ;
til ( int i = 0 ; jeg < myArray2D.GetLength ( 0 ) ; i++ )
{
til ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ jeg, j ] ) ;
}
}
}
}
I denne kode bruger vi det nye nøgleord til at initialisere et endimensionelt heltalsarray kaldet myArray1D med værdierne 1, 2, 3, 4 og 5 og et 2-dimensionelt heltalsarray kaldet myArray2D med værdierne {1, 2}, {3, 4} og {5, 6}.
Vi bruger derefter for loops til at iterere gennem hvert element i hvert array og udskrive dets værdi til konsollen. Bemærk, at for det 2-dimensionelle array bruger vi GetLength() for at bestemme antallet af rækker og kolonner og bruge indlejrede for loops til at iterere gennem hvert element.
3: Initialisering af arrays ved hjælp af loops
Arrays kan også initialiseres ved hjælp af loops. En tilgang er at anvende en for-løkke, som gør det muligt for dig at iterere gennem arrayet og tildele værdier til hvert element.
int [ ] tal = ny int [ 5 ] ;til ( int i = 0 ; jeg < tal.Længde; i++ )
{
tal [ jeg ] = i + 1 ;
}
Denne kode opretter et heltalsarray med navnet numre med en størrelse på 5 og tildeler hvert element en værdi svarende til dets indeks plus 1. Her er et eksempel på, hvordan man initialiserer et 2-dimensionelt heltalsarray i C# ved hjælp af loops:
til ( int i = 0 ; jeg < 3 ; i++ )
{
til ( int j = 0 ; j < 2 ; j++ )
{
myArray [ jeg, j ] = i + j;
}
}
I dette eksempel bruger vi nestet for loops til at iterere gennem hvert element i en 2-dimensional heltalsmatrix kaldet myArray , som har 3 rækker og 2 kolonner. For hvert element sætter vi dets værdi til summen af dets række- og kolonneindeks ved hjælp af udtrykket i + j.
Her er et eksempel på, hvordan man bruger loops til at initialisere både et 1-dimensionelt og et 2-dimensionelt array i C#, sammen med kode til at udskrive værdierne i hvert array:
bruger System;klasse array
{
statisk tomrum Main ( snor [ ] args )
{
// Initialisering af en 1 -dimensionelle array ved hjælp af en løkke
int [ ] myArray1D = ny int [ 5 ] ;
til ( int i = 0 ; jeg < myArray1D.Length; i++ )
{
myArray1D [ jeg ] = i + 1 ;
}
Console.WriteLine ( 'Værdier i myArray1D:' ) ;
til ( int i = 0 ; jeg < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ jeg ] ) ;
}
// Initialisering af en 2 -dimensionelle array ved hjælp af indlejrede løkker
int [ , ] myArray2D = ny int [ 3 , 2 ] ;
til ( int i = 0 ; jeg < 3 ; i++ )
{
til ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ jeg, j ] = i + j;
}
}
Console.WriteLine ( 'Værdier i myArray2D:' ) ;
til ( int i = 0 ; jeg < 3 ; i++ )
{
til ( int j = 0 ; j < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ jeg, j ] ) ;
}
}
}
}
I denne kode bruger vi en for-løkke til at initialisere et 1-dimensionelt heltalsarray kaldet myArray1D med værdierne 1, 2, 3, 4 og 5. Vi bruger også nestet for loops til at initialisere et 2-dimensionelt heltalsarray kaldet myArray2D med værdierne {0, 1}, {1, 2} og {2, 3} ved hjælp af udtrykket i + j.
Brug derefter yderligere for-løkker til at iterere gennem hvert element i hvert array og udskrive dets værdi til konsollen.
4: Initialisering af arrays ved hjælp af Array.Copy()
En alternativ tilgang til initialisering af et array involverer at bruge Array.Copy()-funktionen. Dette involverer oprettelse af et kildearray med de ønskede elementer og derefter kopiering af dem til et målarray. For eksempel:
int [ ] kilde = { 1 , 2 , 3 , 4 , 5 } ;int [ ] mål = ny int [ kilde.Længde ] ;
Array.Copy ( kilde , mål, kilde.Længde ) ;
Denne kode opretter en heltalsarray med navnet kilde med værdierne 1 til 5, opretter en ny heltalsarray med navnet target med samme størrelse som kilden og kopierer derefter elementerne fra kilde til mål.
Tillad mig at præsentere et eksempel, der demonstrerer brugen af Array.Copy til at initialisere en todimensional heltalsmatrix i C#:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = ny int [ 3 , 2 ] ;
Array.Copy ( sourceArray, destinationArray, sourceArray.Length ) ;
I dette eksempel har vi et 2-dimensionelt heltalsarray kaldet sourceArray med 3 rækker og 2 kolonner. Vi bruger Array.Copy() at kopiere indholdet af sourceArray til et nyt 2-dimensionelt heltalsarray kaldet destinationArray, som også har 3 rækker og 2 kolonner.
Det Array.Copy() metode tager tre argumenter : det kilde array , det destinationsmatrix , og længde af de data, der skal kopieres. I dette tilfælde kopierer vi hele indholdet af sourceArray ind i destinationArray , så vi passerer sourceArray.Length som det tredje argument.
Bemærk, at du kan bruge Array.Copy() at initialisere arrays med et vilkårligt antal dimensioner, så længe kilde- og destinationsarrays har det samme antal dimensioner og samme størrelse i hver dimension.
Husk det også Array.Copy() udfører en overfladisk kopi af kildearrayet, hvilket betyder, at hvis kildearrayet indeholder referencetyper, vil referencerne blive kopieret, men selve objekterne bliver ikke duplikeret.
Her er den komplette kode, der bruger Array.Copy() funktion til at initialisere arrayet i C#:
bruger System;klasse array
{
statisk tomrum Main ( snor [ ] args )
{
// Initialisering af en 1 -dimensionelle array ved hjælp af Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = ny int [ 5 ] ;
Array.Copy ( sourceArray1D, destinationArray1D, sourceArray1D.Length ) ;
Console.WriteLine ( 'Værdier i destinationArray1D:' ) ;
til ( int i = 0 ; jeg < destinationArray1D.Length; i++ ) {
Console.WriteLine ( destinationArray1D [ jeg ] ) ;
}
// Initialisering af en 2 -dimensionelle array ved hjælp af 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ærdier i destinationArray2D:' ) ;
til ( int i = 0 ; jeg < destinationArray2D.GetLength ( 0 ) ; i++ ) {
til ( int j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, destinationArray2D [ jeg, j ] ) ;
}
}
}
}
I denne kode bruger vi Array.Copy() at initialisere et 1-dimensionelt heltalsarray kaldet destinationArray1D med værdierne 1, 2, 3, 4 og 5 fra et kildearray kaldet sourceArray1D.
Vi bruger også Array.Copy() at initialisere et 2-dimensionelt heltalsarray kaldet destinationArray2D med værdierne {1, 2}, {3, 4} og {5, 6} fra et kildearray kaldet sourceArray2D.
Vi bruger derefter yderligere for-løkker til at iterere gennem hvert element i hvert array og udskrive dets værdi til konsollen.
Konklusion
I denne artikel undersøgte vi forskellige måder at initialisere arrays på i C#. Vi dækkede array-initialiseringssyntaksen ved at bruge det nye nøgleord, initialisere arrays ved hjælp af loops og bruge Array.Copy()-metoden. Afhængigt af den specifikke brugssituation har hver af disse metoder sit eget sæt af fordele og ulemper. At sætte dig ind i disse forskellige tilgange vil gøre dig i stand til at vælge den bedst egnede til dine særlige behov.