C# Array-tutorial: creëren, declareren, initialiseren

Wat zijn arrays in C#?

Een array wordt gebruikt om een ​​verzameling of reeks elementen op te slaan. Deze elementen zullen van hetzelfde type zijn.

Als u bijvoorbeeld een array met geheeltallige waarden had, zou de array een verzameling waarden kunnen zijn, zoals [1, 2, 3, 4]. Hier is het aantal elementen in de array 4.

Arrays zijn handig als u een verzameling waarden van hetzelfde type wilt opslaan. Dus in plaats van het declareren van a variabele voor elk element kun je slechts één variabele declareren.

Deze variabele verwijst naar een array of lijst met elementen, die verantwoordelijk is voor het opslaan van de elementen van de array.

Laten we eens kijken hoe we met arrays in C# kunnen werken. In ons voorbeeld declareren we een array van gehele getallen en werken we er dienovereenkomstig mee.

Houd er rekening mee dat alle onderstaande code naar het Program.cs-bestand wordt gemaakt.

Stap 1) Een array declareren – De eerste stap is het declareren van een array. Laten we eens kijken hoe we dit kunnen bereiken met het onderstaande codevoorbeeld.

Code Uitleg:-

1. Het eerste deel is de data type. Het specificeert het type elementen dat in de array wordt gebruikt. In ons geval creëren we dus een array van gehele getallen.
2. Het tweede deel [ ], dat de rangorde van de array specificeert. (De rang is een tijdelijke aanduiding die het aantal elementen specificeert dat de array zal bevatten)
3. Het volgende is de naam van de array, in ons geval 'waarden'. Merk op dat u een groene kronkelige onderstreping ziet, maak u daar geen zorgen over. Dat is gewoon .Net dat zegt dat je een array hebt gedeclareerd, maar deze nergens gebruikt.

Stap 2) De volgende stap is het initialiseren van de array. Hier gaan we het aantal waarden specificeren dat de array zal bevatten. We gaan ook waarden toewijzen aan elk element van de array.

Code Uitleg:-

1. Eerst stellen we het aantal elementen in dat de array zal bevatten in op 3. In de vierkante haken staat dus dat de array 3 elementen zal bevatten.
2. Vervolgens kennen we waarden toe aan elk element van de array. Dit kunnen we doen door de variabelenaam + de indexpositie in de array te specificeren. Dus values[0] betekent dat we een waarde opslaan op de eerste positie van de array. Om toegang te krijgen tot de tweede positie, gebruiken we de notatie values[1], enzovoort.

Note: – In arrays begint de indexpositie vanaf 0.

Stap 3) Laten we nu de afzonderlijke elementen van de array in de console weergeven. Laten we de onderstaande code toevoegen om dit te bereiken.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args) 
  {
   Int32[] value;
   value=new Int32[3];
   
   value[0]=1;
   value[1]=2;
   value[2]=3;
   
   Console.WriteLine(value[0]);
   Console.WriteLine(value[1]);
   Console.WriteLine(value[2]);
    
   Console.ReadKey(); 
  }
 }
}

Code Uitleg:-

Dit is het eenvoudige gedeelte waarin we gewoon de Console.WriteLine-methode gebruiken om elke waarde van het element naar de console te sturen.

Merk op dat we opnieuw toegang krijgen tot elk element met behulp van de naam van de arrayvariabele samen met de indexpositie.

Als de bovenstaande code correct is ingevoerd en het programma wordt uitgevoerd, wordt de volgende uitvoer weergegeven.

Output:

In de uitvoer ziet u dat alle waarden van de matrix in de console worden weergegeven.

Hoe door een C#-array te itereren met behulp van foreach

Het lezen van elk element aan de hand van de index werkt, maar het wordt omslachtig wanneer een array veel waarden bevat. De `foreach`-lus biedt een nettere manier om elk element van een array in de juiste volgorde te doorlopen zonder tracEen indexvariabele zelf aanmaken.

De `foreach`-instructie neemt elk element uit de array één voor één en kopieert het naar een lusvariabele. Deze variabele gebruik je vervolgens binnen de lus. Omdat de lus automatisch stopt bij het laatste element, voorkomt `foreach` dat er voorbij het einde van de array wordt gelezen.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Int32[] values = new Int32[3] {1, 2, 3};
   foreach (Int32 item in values)
   {
    Console.WriteLine(item);
   }
   Console.ReadKey();
  }
 }
}

Het bovenstaande voorbeeld declareert en initialiseert een array van drie gehele getallen en doorloopt deze vervolgens met een foreach-lus. Bij elke iteratie wordt de variabele item De functie ontvangt de volgende waarde en Console.WriteLine print deze. De uitvoer bestaat uit de getallen 1, 2 en 3 op aparte regels.

Belangrijke punten om te onthouden bij het gebruik van foreach met arrays:

• De lusvariabele is alleen-lezen, dus een foreach-lus is het meest geschikt om waarden te lezen in plaats van ze ter plekke te wijzigen.
• Om elementen te wijzigen tijdens het kijkenpingGebruik in plaats daarvan een for-lus met een index.
• `foreach` werkt met eendimensionale arrays, multidimensionale arrays en elke verzameling die iteratie ondersteunt.

C# Multidimensionale arrays

De arrays die tot nu toe zijn getoond, zijn eendimensionaal, wat betekent dat ze een eenvoudige lijst met waarden opslaan. C# ondersteunt ook multidimensionale arrays, die elementen in een raster van rijen en kolommen rangschikken. Een tweedimensionale array is de meest voorkomende vorm en is geschikt voor gegevens zoals matrices, spelborden en tabellen.

Je declareert een tweedimensionale array door een komma binnen de vierkante haken te plaatsen. Elke extra komma voegt een extra dimensie toe, dus int[,] is tweedimensionaal en int[,,] is driedimensionaal. Elementen zijn vervolgens bereikbaar via één index per dimensie.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   int[,] matrix = new int[2, 2] { {1, 2}, {3, 4} };
   Console.WriteLine(matrix[0, 0]);
   Console.WriteLine(matrix[1, 1]);
   Console.ReadKey();
  }
 }
}

De matrix in deze array heeft twee rijen en twee kolommen. Het element matrix[0, 0] geeft 1 terug en matrix[1, 1] geeft 4 terug. Het aantal dimensies wordt vastgelegd bij de declaratie van de array, terwijl de grootte van elke dimensie wordt ingesteld bij het aanmaken van de array.

C# Onregelmatige arrays

Een onregelmatige array is een array waarvan de elementen zelf ook arrays zijn. In tegenstelling tot een rechthoekige multidimensionale array kan elke interne array een andere lengte hebben. Daarom wordt een onregelmatige array vaak een array van arrays genoemd. Deze flexibiliteit is handig wanneer rijen van nature een verschillend aantal waarden bevatten.

Je declareert een onregelmatige array met twee sets vierkante haken en maakt vervolgens elke binnenste array afzonderlijk aan. Het volgende voorbeeld bouwt een onregelmatige array waarbij de eerste rij drie waarden bevat en de tweede rij twee.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   int[][] jagged = new int[2][];
   jagged[0] = new int[] {1, 2, 3};
   jagged[1] = new int[] {4, 5};
   Console.WriteLine(jagged[0][2]);
   Console.WriteLine(jagged[1][1]);
   Console.ReadKey();
  }
 }
}

De expressie jagged[0][2] leest het derde element van de eerste rij, namelijk 3, en jagged[1][1] leest het tweede element van de tweede rij, namelijk 5. Omdat elke rij een aparte array is, gebruiken jagged arrays het geheugen efficiënt wanneer de rijlengtes variëren, hoewel er een extra stap nodig is om elke interne array te initialiseren.

Veelgestelde vragen