Handledning för C# Array: Skapa, deklarera, initiera

Vad är en Arrays i C#?

En array används för att lagra en samling eller serie av element. Dessa element kommer att vara av samma typ.

Så om du till exempel hade en array med heltalsvärden, kan arrayen vara en samling värden som [1, 2, 3, 4]. Här är antalet element i arrayen 4.

Matriser är användbara när du vill lagra en samling värden av samma typ. Så istället för att deklarera en variabel för varje element kan du bara deklarera en variabel.

Denna variabel kommer att peka på en array eller lista med element, som kommer att vara ansvarig för att lagra elementen i arrayen.

Låt oss titta på hur vi kan arbeta med arrayer i C#. I vårt exempel kommer vi att deklarera en array av heltal och arbeta med dem därefter.

Observera att all kod nedan görs till filen Program.cs.

Steg 1) Deklarera en array – Det första steget är att deklarera en array. Låt oss se hur vi kan uppnå detta genom kodexemplet nedan.

Code Förklaring:-

1. Den första delen är data typ. Den anger vilken typ av element som används i arrayen. Så i vårt fall skapar vi en uppsättning heltal.
2. Den andra delen [ ], som specificerar rangordningen för arrayen. (Rangen är en platshållare som anger antalet element som arrayen kommer att innehålla)
3. Nästa är namnet på arrayen som i vårt fall är "värden". Observera att du ser en grön snirklig underlinje, oroa dig inte för det. Det är bara .Net som säger att du har deklarerat en array, men att du inte använder den någonstans.

Steg 2) Nästa steg är att initiera arrayen. Här kommer vi att specificera antalet värden som arrayen kommer att hålla. Vi kommer också att tilldela värden till varje element i arrayen.

Code Förklaring:-

1. Först ställer vi in ​​antalet element som arrayen kommer att innehålla till 3. Så inom hakparenteser säger vi att arrayen kommer att innehålla 3 element.
2. Sedan tilldelar vi värden till varje element i arrayen. Vi kan göra detta genom att ange variabelnamnet + indexpositionen i arrayen. Så values[0] betyder att vi lagrar ett värde i den första positionen i arrayen. På samma sätt, för att komma åt den andra positionen, använder vi notationen values[1] och så vidare.

Anmärkningar: – I Arrays börjar indexpositionen från 0.

Steg 3) Låt oss nu visa de individuella elementen i arrayen i konsolen. Låt oss lägga till koden nedan för att uppnå detta.

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 Förklaring:-

Detta är den enkla delen där vi bara använder Console.WriteLine-metoden för att skicka varje värde på elementet till konsolen.

Observera att vi återigen kommer åt varje element med hjälp av arrayvariabelns namn tillsammans med indexpositionen.

Om ovanstående kod matas in korrekt och programmet körs, kommer följande utdata att visas.

Produktion:

Från utgången kan du se alla värden för arrayen som visas i konsolen.

Hur man loopar igenom en C#-array med hjälp av foreach

Att läsa varje element utifrån dess index fungerar, men det blir tråkigt när en array innehåller många värden. Foreach-loopen erbjuder ett renare sätt att besöka varje element i en array i ordning utan tracskapa en indexvariabel själv.

foreach-satsen tar varje element från arrayen ett i taget och kopierar det till en loopvariabel. Du använder sedan den variabeln inuti loopens innehåll. Eftersom loopen stannar automatiskt vid det sista elementet eliminerar foreach risken att läsa förbi slutet av arrayen.

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();
  }
 }
}

Exemplet ovan deklarerar och initierar en array med tre heltal, och går sedan igenom den med foreach. Vid varje överföring används variabeln objektet tar emot nästa värde och Console.WriteLine skriver ut det. Utdata är siffrorna 1, 2 och 3 på separata rader.

Viktiga punkter att komma ihåg om foreach med arrayer:

• Loopvariabeln är skrivskyddad, så foreach är bäst för att läsa värden snarare än att ändra dem på plats.
• Att modifiera element under lookingping, använd en for-loop med ett index istället.
• foreach fungerar med endimensionella arrayer, flerdimensionella arrayer och alla samlingar som stöder iteration.

C# flerdimensionella arrayer

De arrayer som visats hittills är endimensionella, vilket innebär att de lagrar en enkel lista med värden. C# stöder även flerdimensionella arrayer, som arrangerar element i ett rutnät av rader och kolumner. En tvådimensionell array är den vanligaste formen och passar för data som matriser, spelplaner och tabeller.

Du deklarerar en tvådimensionell array genom att placera ett kommatecken inom hakparenteserna. Varje extra kommatecken lägger till ytterligare en dimension, så int[,] är tvådimensionell och int[,,] är tredimensionell. Element nås sedan med ett index per dimension.

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();
  }
 }
}

Här innehåller arraymatrisen två rader och två kolumner. Elementet matrix[0, 0] returnerar 1, och matrix[1, 1] returnerar 4. Antalet dimensioner är fast när arrayen deklareras, medan storleken på varje dimension anges när arrayen skapas.

C# Jagged Arrays

En taggig array är en array vars element själva är arrayer. Till skillnad från en rektangulär flerdimensionell array kan varje inre array ha olika längd, vilket är anledningen till att en taggig array ofta kallas en array av arrayer. Denna flexibilitet är till hjälp när rader naturligt innehåller olika antal värden.

Du deklarerar en taggig array med två uppsättningar hakparenteser och skapar sedan varje inre array separat. Följande exempel bygger en taggig array där den första raden innehåller tre värden och den andra raden innehåller två.

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();
  }
 }
}

Uttrycket jagged[0][2] läser det tredje elementet i den första raden, vilket är 3, och jagged[1][1] läser det andra elementet i den andra raden, vilket är 5. Eftersom varje rad är en separat array använder jagged-arrayer minne effektivt när radlängderna varierar, även om de behöver ett extra steg för att initiera varje inre array.

Vanliga frågor