Pole

Do datové struktury pole můžete uložit více proměnných stejného typu. Deklarujete pole zadáním typu jeho prvků. Pokud chcete, aby pole ukládaly prvky libovolného typu, můžete zadat object jako jeho typ. V systému sjednoceného typu jazyka C# všechny typy, předdefinované a uživatelem definované, odkazové typy a typy hodnot, dědí přímo nebo nepřímo z Object.

type[] arrayName;

Pole má následující vlastnosti:

• Pole může být jednorozměrné, multidimenzionální nebo jaggované.
• Počet dimenzí se nastaví při deklarování proměnné pole. Délka každé dimenze se vytvoří při vytvoření instance pole. Tyto hodnoty nelze během životnosti instance změnit.
• Agregovaná matice je matice polí a každé pole členů má výchozí hodnotu null.
• Pole jsou nula indexována: pole s n prvky je indexováno od 0 do n-1.
• Prvky pole můžou být libovolného typu, včetně typu pole.
• Typy pole jsou odkazové typy odvozené od abstraktního základního typu Array. Všechna pole implementují IList a IEnumerable. Příkaz foreach můžete použít k iteraci pole. Jednorozměrná pole také implementují IList<T> a IEnumerable<T>.

Prvky pole lze inicializovat na známé hodnoty při vytvoření pole. Počínaje jazykem C# 12 je možné inicializovat všechny typy kolekcí pomocí výrazu Collection. Elementy, které nejsou inicializovány, jsou nastaveny na výchozí hodnotu. Výchozí hodnota je 0bitový vzor. Všechny odkazové typy (včetně typů bez hodnoty null ) mají hodnoty null. Všechny typy hodnot mají 0bitové vzory. To znamená, že Nullable<T>.HasValue vlastnost je false a Nullable<T>.Value vlastnost není definována. V implementaci .NET vlastnost Value vyvolá výjimku.

Následující příklad vytvoří jednorozměrné, multidimenzionální a jagged arrays:

// 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];

// Collection expressions:
int[] array = [1, 2, 3, 4, 5, 6];
// Alternative syntax:
int[] array2 = {1, 2, 3, 4, 5, 6};

Jednorozměrná pole

Jednorozměrné pole je posloupnost podobných prvků. K elementu se dostanete prostřednictvím jeho indexu. Index je jeho pořadová pozice v sekvenci. První prvek pole je v indexu 0. Jednorozměrné pole vytvoříte pomocí nového operátoru určujícího typ prvku pole a počet prvků. Následující příklad deklaruje a inicializuje jednorozměrná pole:

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
*/

První deklarace deklaruje neinicializované pole pěti celých čísel od array[0] do array[4]. Prvky pole jsou inicializovány na výchozí hodnotu typu 0 prvku pro celá čísla. Druhá deklarace deklaruje pole řetězců a inicializuje všechny sedm hodnot tohoto pole. Console.WriteLine Řada příkazů vytiskne všechny prvky weekDay pole. U jednorozměrných polí foreach příkaz zpracovává prvky v rostoucím pořadí indexů počínaje indexem 0 a končí indexem Length - 1.

Předání jednorozměrných polí jako argumentů

Do metody můžete předat inicializované jednorozměrné pole. V následujícím příkladu je pole řetězců inicializováno a předáno jako argument DisplayArray metodě pro řetězce. Metoda zobrazí prvky pole. ChangeArray Dále metoda obrátí prvky pole a pak ChangeArrayElements metoda upraví první tři prvky pole. Po vrácení každé metody metoda DisplayArray ukazuje, že předání pole podle hodnoty nebrání změnám prvků pole.

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

Multidimenzionální pole

Pole můžou mít více než jednu dimenzi. Například následující deklarace vytvářejí čtyři pole: dvě mají dvě dimenze, dvě mají tři dimenze. První dvě deklarace deklarují délku každé dimenze, ale neinicializují hodnoty pole. Druhé dvě deklarace používají inicializátor k nastavení hodnot každého prvku v multidimenzionálním poli.

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

U multidimenzionálních polí se prvky procházejí tak, že indexy pravé dimenze se nejprve zvýrazní, pak další levá dimenze atd. na index úplně vlevo. Následující příklad vytvoří výčet 2D i 3D pole:

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

V 2D poli si můžete levý index představit jako řádek a pravý index jako sloupec.

U multidimenzionálních polí ale pomocí vnořené smyčky pro získáte větší kontrolu nad pořadím zpracování prvků pole:

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
//

Předávání multidimenzionálních polí jako argumentů

Inicializované multidimenzionální pole předáte metodě stejným způsobem jako jednorozměrné pole. Následující kód ukazuje částečnou deklaraci metody tisku, která přijímá dvojrozměrné pole jako svůj argument. Můžete inicializovat a předat nové pole v jednom kroku, jak je znázorněno v následujícím příkladu. V následujícím příkladu je dvojrozměrné pole celých čísel inicializováno a předáno Print2DArray metodě. Metoda zobrazí prvky pole.

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
*/

Jagged arrays

Jagged array je matice, jejíž prvky jsou matice, pravděpodobně různých velikostí. Matici se někdy říká "matice polí". Jeho prvky jsou odkazové typy a jsou inicializovány na null. Následující příklady ukazují, jak deklarovat, inicializovat a přistupovat k agregovaným polím. První příklad je jaggedArraydeklarován v jednom příkazu. Každé obsažené pole se vytvoří v následných příkazech. Druhý příklad jaggedArray2 je deklarován a inicializován v jednom příkazu. Je možné kombinovat jagged a multidimenzionální pole. Posledním příkladem je jaggedArray3deklarace a inicializace jednorozměrné jagged pole, která obsahuje tři dvourozměrné maticové prvky různých velikostí.

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

Než je budete moct použít, je nutné inicializovat elementy pole. Každý z prvků je sám o sobě pole. K vyplnění prvků pole hodnotami je také možné použít inicializátory. Při použití inicializátorů nepotřebujete velikost pole.

Tento příklad vytvoří matici, jejíž prvky jsou samy pole. Každý z prvků pole má jinou velikost.

// 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
*/

Implicitně typovaná pole

Můžete vytvořit implicitně typ pole, ve kterém je typ instance pole odvozen z prvků zadaných v inicializátoru pole. Pravidla pro libovolnou implicitně typovanou proměnnou platí také pro implicitně typovaná pole. Další informace naleznete v tématu Implicitně typované místní proměnné.

Následující příklady ukazují, jak vytvořit implicitně typované pole:

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
*/

V předchozím příkladu si všimněte, že u implicitně zadaných polí se na levé straně inicializačního příkazu nepoužívají žádné hranaté závorky. Maticové matice jsou inicializovány new [] stejně jako jednorozměrná pole.

Při vytváření anonymního typu, který obsahuje pole, musí být pole implicitně zadáno v inicializátoru objektu typu. V následujícím příkladu contacts je implicitně typované pole anonymních typů, z nichž každý obsahuje pole s názvem PhoneNumbers. Klíčové var slovo se nepoužívá uvnitř inicializátorů objektů.

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