Tömbök

Egy tömbadat-struktúrában több azonos típusú változót is tárolhat. A tömböket az elemek típusának megadásával deklarálhatja. Ha azt szeretné, hogy a tömb bármilyen típusú elemeket tároljon, megadhatja object annak típusát. A C#egyesített típusrendszerében minden típus, előre definiált és felhasználó által definiált referenciatípus és értéktípus közvetlenül vagy közvetve Objectörököl.

type[] arrayName;

A tömbök a következő tulajdonságokkal rendelkeznek:

• A tömbök lehetnek egydimenziósak, többdimenziósak vagy szaggatottak.
• A dimenziók száma tömbváltozó deklarálásakor lesz beállítva. Az egyes dimenziók hossza a tömbpéldány létrehozásakor jön létre. Ezek az értékek nem módosíthatók a példány élettartama alatt.
• A szaggatott tömb tömbök tömbje, és minden tagtömb alapértelmezett értéke null.
• A tömbök indexelése nulla: az elemeket tartalmazó n tömbök indexelése a céln-1.0
• A tömbelemek bármilyen típusúak lehetnek, beleértve a tömbtípust is.
• A tömbtípusok az absztrakt alaptípusból Arrayszármaztatott referenciatípusok. Minden tömb implementál IList és IEnumerable. A foreach utasítással egy tömbön keresztül iterálhat. Egydimenziós tömbök is implementálják IList<T> és IEnumerable<T>.

A tömb elemei a tömb létrehozásakor inicializálhatók ismert értékekre. A C# 12-től kezdődően az összes gyűjteménytípus inicializálható gyűjteménykifejezéssel. A nem inicializált elemek az alapértelmezett értékre vannak beállítva. Az alapértelmezett érték a 0 bites minta. Minden referenciatípus (beleértve a nem null értékű típusokat is) rendelkezik az értékekkelnull. Minden értéktípushoz tartoznak a 0 bites minták. Ez azt jelenti, hogy a Nullable<T>.HasValue tulajdonság az, false és a Nullable<T>.Value tulajdonság nincs meghatározva. A .NET-implementációban a Value tulajdonság kivételt jelez.

Az alábbi példa egydimenziós, többdimenziós és szaggatott tömböket hoz létre:

// Declare a single-dimensional array of 5 integers.
int[] array1 = new int[5];

// Declare and set array element values.
int[] array2 = [1, 2, 3, 4, 5, 6];

// Declare a two dimensional array.
int[,] multiDimensionalArray1 = new int[2, 3];

// Declare and set array element values.
int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };

// Declare a jagged array.
int[][] jaggedArray = new int[6][];

// Set the values of the first array in the jagged array structure.
jaggedArray[0] = [1, 2, 3, 4];

Egydimenziós tömbök

Az egydimenziós tömb hasonló elemek sorozata. Egy elemet az indexen keresztül érhet el. Az index a sorrendben elfoglalt sorrendje. A tömb első eleme az indexben 0van. Egydimenziós tömböt hozhat létre az új operátorral, amely megadja a tömbelem típusát és az elemek számát. Az alábbi példa egydimenziós tömböket deklarál és inicializál:

int[] array = new int[5];
string[] weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];

Console.WriteLine(weekDays[0]);
Console.WriteLine(weekDays[1]);
Console.WriteLine(weekDays[2]);
Console.WriteLine(weekDays[3]);
Console.WriteLine(weekDays[4]);
Console.WriteLine(weekDays[5]);
Console.WriteLine(weekDays[6]);

/*Output:
Sun
Mon
Tue
Wed
Thu
Fri
Sat
*/

Az első deklaráció egy öt egész számból álló, nem inicializált tömböt deklarál.array[0]array[4] A tömb elemei az elemtípus alapértelmezett értékére inicializálódnak egész 0 számok esetében. A második deklaráció sztringtömböt deklarál, és inicializálja a tömb mind a hét értékét. Egy utasítássorozat Console.WriteLine a tömb összes elemét kinyomtatja weekDay . Az egydimenziós tömbök esetében az utasítás az elemeket az foreach indexek sorrendjének növelésében dolgozza fel, kezdve a 0 indexkel, majd az indexgel Length - 1végződik.

Egydimenziós tömbök átadása argumentumként

Egy inicializált egydimenziós tömböt átadhat egy metódusnak. Az alábbi példában a sztringek tömbje inicializálódik, és argumentumként továbbítja a sztringek metódusának DisplayArray . A metódus megjeleníti a tömb elemeit. Ezután a ChangeArray metódus megfordítja a tömbelemeket, majd a ChangeArrayElements metódus módosítja a tömb első három elemét. Az egyes metódusok visszatérése után a DisplayArray metódus azt mutatja, hogy a tömbök érték szerinti átadása nem akadályozza meg a tömbelemek módosítását.

class ArrayExample
{
    static void DisplayArray(string[] arr) => Console.WriteLine(string.Join(" ", arr));

    // Change the array by reversing its elements.
    static void ChangeArray(string[] arr) => Array.Reverse(arr);

    static void ChangeArrayElements(string[] arr)
    {
        // Change the value of the first three array elements.
        arr[0] = "Mon";
        arr[1] = "Wed";
        arr[2] = "Fri";
    }

    static void Main()
    {
        // Declare and initialize an array.
        string[] weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
        // Display the array elements.
        DisplayArray(weekDays);
        Console.WriteLine();

        // Reverse the array.
        ChangeArray(weekDays);
        // Display the array again to verify that it stays reversed.
        Console.WriteLine("Array weekDays after the call to ChangeArray:");
        DisplayArray(weekDays);
        Console.WriteLine();

        // Assign new values to individual array elements.
        ChangeArrayElements(weekDays);
        // Display the array again to verify that it has changed.
        Console.WriteLine("Array weekDays after the call to ChangeArrayElements:");
        DisplayArray(weekDays);
    }
}
// The example displays the following output:
//         Sun Mon Tue Wed Thu Fri Sat
//
//        Array weekDays after the call to ChangeArray:
//        Sat Fri Thu Wed Tue Mon Sun
//
//        Array weekDays after the call to ChangeArrayElements:
//        Mon Wed Fri Wed Tue Mon Sun

Többdimenziós tömbök

A tömbök több dimenzióval is rendelkezhetnek. A következő deklarációk például négy tömböt hoznak létre: kettő két dimenzióval, kettő három dimenzióval rendelkezik. Az első két deklaráció az egyes dimenziók hosszát deklarálja, de ne inicializálja a tömb értékeit. A második két deklaráció inicializálóval állítja be a többdimenziós tömb egyes elemeinek értékeit.

int[,] array2DDeclaration = new int[4, 2];

int[,,] array3DDeclaration = new int[4, 2, 3];

// Two-dimensional array.
int[,] array2DInitialization =  { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
// Three-dimensional array.
int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                                { { 7, 8, 9 }, { 10, 11, 12 } } };

// Accessing array elements.
System.Console.WriteLine(array2DInitialization[0, 0]);
System.Console.WriteLine(array2DInitialization[0, 1]);
System.Console.WriteLine(array2DInitialization[1, 0]);
System.Console.WriteLine(array2DInitialization[1, 1]);

System.Console.WriteLine(array2DInitialization[3, 0]);
System.Console.WriteLine(array2DInitialization[3, 1]);
// Output:
// 1
// 2
// 3
// 4
// 7
// 8

System.Console.WriteLine(array3D[1, 0, 1]);
System.Console.WriteLine(array3D[1, 1, 2]);
// Output:
// 8
// 12

// Getting the total count of elements or the length of a given dimension.
var allLength = array3D.Length;
var total = 1;
for (int i = 0; i < array3D.Rank; i++)
{
    total *= array3D.GetLength(i);
}
System.Console.WriteLine($"{allLength} equals {total}");
// Output:
// 12 equals 12

Többdimenziós tömbök esetén az elemek úgy haladnak be, hogy a jobb szélső dimenzió indexei először növekednek, majd a következő bal dimenzió és így tovább a bal szélső indexre kerülnek. Az alábbi példa egy 2D és egy 3D tömböt is számba vett:

int[,] numbers2D = { { 9, 99 }, { 3, 33 }, { 5, 55 } };

foreach (int i in numbers2D)
{
    System.Console.Write($"{i} ");
}
// Output: 9 99 3 33 5 55

int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                        { { 7, 8, 9 }, { 10, 11, 12 } } };
foreach (int i in array3D)
{
    System.Console.Write($"{i} ");
}
// Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Egy 2D tömbben a bal oldali indexet sorként, a jobb oldali indexet pedig oszlopként tekintheti.

A többdimenziós tömbök esetében azonban a hurkokba ágyazott tömbök nagyobb mértékben szabályozják a tömbelemek feldolgozásának sorrendjét:

int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                        { { 7, 8, 9 }, { 10, 11, 12 } } };

for (int i = 0; i < array3D.GetLength(0); i++)
{
    for (int j = 0; j < array3D.GetLength(1); j++)
    {
        for (int k = 0; k < array3D.GetLength(2); k++)
        {
            System.Console.Write($"{array3D[i, j, k]} ");
        }
        System.Console.WriteLine();
    }
    System.Console.WriteLine();
}
// Output (including blank lines): 
// 1 2 3
// 4 5 6
// 
// 7 8 9
// 10 11 12
//

Többdimenziós tömbök átadása argumentumként

Egy inicializált többdimenziós tömböt ugyanúgy ad át egy metódusnak, mint egy egydimenziós tömböt. Az alábbi kód egy olyan nyomtatási módszer részleges deklarációját mutatja be, amely argumentumként elfogad egy kétdimenziós tömböt. Egy lépésben inicializálhat és átadhat egy új tömböt, ahogyan az az alábbi példában is látható. Az alábbi példában az egész számok kétdimenziós tömbje inicializálódik, és átadja a Print2DArray metódusnak. A metódus megjeleníti a tömb elemeit.

static void Print2DArray(int[,] arr)
{
    // Display the array elements.
    for (int i = 0; i < arr.GetLength(0); i++)
    {
        for (int j = 0; j < arr.GetLength(1); j++)
        {
            System.Console.WriteLine("Element({0},{1})={2}", i, j, arr[i, j]);
        }
    }
}
static void ExampleUsage()
{
    // Pass the array as an argument.
    Print2DArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });
}
/* Output:
    Element(0,0)=1
    Element(0,1)=2
    Element(1,0)=3
    Element(1,1)=4
    Element(2,0)=5
    Element(2,1)=6
    Element(3,0)=7
    Element(3,1)=8
*/

Szaggatott tömbök

A szaggatott tömb olyan tömb, amelynek elemei tömbök, esetleg különböző méretűek. A szaggatott tömböket néha "tömbök tömbjének" is nevezik. Elemei referenciatípusok, és inicializálva vannak a következőre null: . Az alábbi példák bemutatják, hogyan deklarálhatja, inicializálhatja és érheti el a szaggatott tömböket. Az első példa egy jaggedArrayutasításban deklarálva van. Minden egyes tartalmazott tömb a következő utasításokban jön létre. A második példa jaggedArray2 egy utasításban deklarálva és inicializálva van. A szaggatott és a többdimenziós tömbök is keverhetőek. Az utolsó példa jaggedArray3egy egydimenziós szaggatott tömb deklarációja és inicializálása, amely három különböző méretű kétdimenziós tömbelemet tartalmaz.

int[][] jaggedArray = new int[3][];

jaggedArray[0] = [1, 3, 5, 7, 9];
jaggedArray[1] = [0, 2, 4, 6];
jaggedArray[2] = [11, 22];

int[][] jaggedArray2 = 
[
    [1, 3, 5, 7, 9],
    [0, 2, 4, 6],
    [11, 22]
];

// Assign 77 to the second element ([1]) of the first array ([0]):
jaggedArray2[0][1] = 77;

// Assign 88 to the second element ([1]) of the third array ([2]):
jaggedArray2[2][1] = 88;

int[][,] jaggedArray3 =
[
    new int[,] { {1,3}, {5,7} },
    new int[,] { {0,2}, {4,6}, {8,10} },
    new int[,] { {11,22}, {99,88}, {0,9} }
];

Console.Write("{0}", jaggedArray3[0][1, 0]);
Console.WriteLine(jaggedArray3.Length);

Használatuk előtt inicializálni kell a szaggatott tömb elemeit. Minden elem maga egy tömb. Inicializálókkal is kitöltheti a tömbelemeket értékekkel. Inicializálók használatakor nincs szükség a tömb méretére.

Ez a példa egy tömböt készít, amelynek elemei maguk a tömbök. A tömbelemek mindegyike eltérő méretű.

// Declare the array of two elements.
int[][] arr = new int[2][];

// Initialize the elements.
arr[0] = [1, 3, 5, 7, 9];
arr[1] = [2, 4, 6, 8];

// Display the array elements.
for (int i = 0; i < arr.Length; i++)
{
    System.Console.Write("Element({0}): ", i);

    for (int j = 0; j < arr[i].Length; j++)
    {
        System.Console.Write("{0}{1}", arr[i][j], j == (arr[i].Length - 1) ? "" : " ");
    }
    System.Console.WriteLine();
}
/* Output:
    Element(0): 1 3 5 7 9
    Element(1): 2 4 6 8
*/

Implicit módon beírt tömbök

Létrehozhat egy implicit módon beírt tömböt, amelyben a tömbpéldány típusa a tömb inicializálójában megadott elemekből származik. Az implicit módon beírt változókra vonatkozó szabályok implicit módon beírt tömbökre is vonatkoznak. További információ: Implicit módon beírt helyi változók.

Az alábbi példák bemutatják, hogyan hozhat létre implicit módon beírt tömböt:

int[] a = new[] { 1, 10, 100, 1000 }; // int[]

// Accessing array
Console.WriteLine("First element: " + a[0]);
Console.WriteLine("Second element: " + a[1]);
Console.WriteLine("Third element: " + a[2]);
Console.WriteLine("Fourth element: " + a[3]);
/* Outputs
First element: 1
Second element: 10
Third element: 100
Fourth element: 1000
*/

var b = new[] { "hello", null, "world" }; // string[]

// Accessing elements of an array using 'string.Join' method
Console.WriteLine(string.Join(" ", b));
/* Output
hello  world
*/

// single-dimension jagged array
int[][] c =
[
    [1,2,3,4],
    [5,6,7,8]
];
// Looping through the outer array
for (int k = 0; k < c.Length; k++)
{
    // Looping through each inner array
    for (int j = 0; j < c[k].Length; j++)
    {
        // Accessing each element and printing it to the console
        Console.WriteLine($"Element at c[{k}][{j}] is: {c[k][j]}");
    }
}
/* Outputs
Element at c[0][0] is: 1
Element at c[0][1] is: 2
Element at c[0][2] is: 3
Element at c[0][3] is: 4
Element at c[1][0] is: 5
Element at c[1][1] is: 6
Element at c[1][2] is: 7
Element at c[1][3] is: 8
*/

// jagged array of strings
string[][] d =
[
    ["Luca", "Mads", "Luke", "Dinesh"],
    ["Karen", "Suma", "Frances"]
];

// Looping through the outer array
int i = 0;
foreach (var subArray in d)
{
    // Looping through each inner array
    int j = 0;
    foreach (var element in subArray)
    {
        // Accessing each element and printing it to the console
        Console.WriteLine($"Element at d[{i}][{j}] is: {element}");
        j++;
    }
    i++;
}
/* Outputs
Element at d[0][0] is: Luca
Element at d[0][1] is: Mads
Element at d[0][2] is: Luke
Element at d[0][3] is: Dinesh
Element at d[1][0] is: Karen
Element at d[1][1] is: Suma
Element at d[1][2] is: Frances
*/

Az előző példában figyelje meg, hogy implicit módon beírt tömbök esetén a rendszer nem használ szögletes zárójeleket az inicializálási utasítás bal oldalán. Emellett a szaggatott tömbök inicializálása new [] ugyanúgy történik, mint az egydimenziós tömbök.

Tömböt tartalmazó névtelen típus létrehozásakor a tömböt implicit módon be kell gépelni a típus objektum inicializálójában. Az alábbi példában contacts egy névtelen típusok implicit módon beírt tömbje látható, amelyek mindegyike egy elnevezett PhoneNumberstömböt tartalmaz. A var kulcsszó nem az objektum inicializálóiban van használva.

var contacts = new[]
{
    new
    {
        Name = "Eugene Zabokritski",
        PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
    new
    {
        Name = "Hanying Feng",
        PhoneNumbers = new[] { "650-555-0199" }
    }
};