Delen via

Matrices

  • Artikel

U kunt meerdere variabelen van hetzelfde type opslaan in een matrixgegevensstructuur. U declareert een matrix door het type elementen op te geven. Als u wilt dat de matrix elementen van elk type opslaat, kunt u opgeven object als het type. In het geïntegreerde typesysteem van C# nemen alle typen, vooraf gedefinieerde en door de gebruiker gedefinieerde, referentietypen en waardetypen direct of indirect over van Object.

type[] arrayName;

Een matrix heeft de volgende eigenschappen:

  • Een matrix kan ééndimensionaal, multidimensionaal of onregelmatig zijn.
  • Het aantal dimensies wordt ingesteld wanneer een matrixvariabele wordt gedeclareerd. De lengte van elke dimensie wordt vastgesteld wanneer het matrixexemplaren wordt gemaakt. Deze waarden kunnen niet worden gewijzigd tijdens de levensduur van het exemplaar.
  • Een gelabelde matrix is een matrix van matrices en elke lidmatrix heeft de standaardwaarde .null
  • Matrices zijn nul geïndexeerd: een matrix met n elementen wordt geïndexeerd van 0 naar n-1.
  • Matrixelementen kunnen van elk type zijn, inclusief een matrixtype.
  • Matrixtypen zijn verwijzingstypen die zijn afgeleid van het abstracte basistype Array. Alle matrices implementeren IList en IEnumerable. U kunt de foreach-instructie gebruiken om een matrix te doorlopen. Single-dimensionale matrices implementeren IList<T> en IEnumerable<T>.

De elementen van een matrix kunnen worden geïnitialiseerd op bekende waarden wanneer de matrix wordt gemaakt. Vanaf C# 12 kunnen alle verzamelingstypen worden geïnitialiseerd met behulp van een verzamelingsexpressie. Elementen die niet zijn geïnitialiseerd, worden ingesteld op de standaardwaarde. De standaardwaarde is het 0-bits patroon. Alle verwijzingstypen (inclusief niet-nullable typen), hebben de waarden null. Alle waardetypen hebben de 0-bits patronen. Dat betekent dat de Nullable<T>.HasValue eigenschap is false en dat de Nullable<T>.Value eigenschap niet is gedefinieerd. In de .NET-implementatie genereert de Value eigenschap een uitzondering.

In het volgende voorbeeld worden enkelvoudige, multidimensionale en onregelmatige matrices gemaakt:

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

Belangrijk

Veel van de voorbeelden in dit artikel gebruiken verzamelingsexpressies (die vierkante haken gebruiken) om de matrices te initialiseren. Verzamelingsexpressies zijn voor het eerst geïntroduceerd in C# 12, die zijn geleverd met .NET 8. Als u nog geen upgrade naar C# 12 kunt uitvoeren, gebruikt { u deze en } initialiseert u de matrices.

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

Eendimensionale matrices

Een eendimensionale matrix is een reeks like-elementen. U opent een element via de bijbehorende index. De index is de rangordepositie in de reeks. Het eerste element in de matrix bevindt zich in de index 0. U maakt een enkeledimensionale matrix met behulp van de nieuwe operator die het type matrixelement en het aantal elementen opgeeft. In het volgende voorbeeld worden enkelvoudige matrices declareren en geïnitialiseerd:

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

De eerste declaratie declareert een niet-geïnitialiseerde matrix van vijf gehele getallen, van array[0] tot array[4]. De elementen van de matrix worden geïnitialiseerd tot de standaardwaarde van het elementtype voor 0 gehele getallen. De tweede declaratie declareert een matrix met tekenreeksen en initialiseert alle zeven waarden van die matrix. Een reeks Console.WriteLine instructies drukt alle elementen van de weekDay matrix af. Voor eendimensionale matrices verwerkt de foreach instructie elementen in toenemende indexvolgorde, beginnend met index 0 en eindigend met index Length - 1.

Eendimensionale matrices doorgeven als argumenten

U kunt een geïnitialiseerde eendimensionale matrix doorgeven aan een methode. In het volgende voorbeeld wordt een matrix met tekenreeksen geïnitialiseerd en als argument doorgegeven aan een DisplayArray methode voor tekenreeksen. Met de methode worden de elementen van de matrix weergegeven. Vervolgens worden met de ChangeArray methode de matrixelementen omgekeerd en vervolgens worden de ChangeArrayElements eerste drie elementen van de matrix gewijzigd. Nadat elke methode is geretourneerd, laat de DisplayArray methode zien dat het doorgeven van een matrix op waarde geen wijzigingen in de matrixelementen verhindert.

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

Multidimensionale matrices

Matrices kunnen meer dan één dimensie hebben. Met de volgende declaraties worden bijvoorbeeld vier matrices gemaakt: twee hebben twee dimensies, twee hebben drie dimensies. De eerste twee declaraties declareren de lengte van elke dimensie, maar initialiseren niet de waarden van de matrix. De tweede twee declaraties gebruiken een initialisatiefunctie om de waarden van elk element in de multidimensionale matrix in te stellen.

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

Voor multidimensionale matrices worden elementen doorkruist, zodat de indexen van de meest rechtse dimensie eerst worden verhoogd, vervolgens de volgende linkerdimensie, enzovoort, naar de meest linkse index. In het volgende voorbeeld worden zowel een 2D- als een 3D-matrix opgesomd:

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

In een 2D-matrix kunt u de linkerindex zien als de rij en de rechterindex als de kolom.

Met multidimensionale matrices biedt het gebruik van een geneste for-lus u echter meer controle over de volgorde waarin de matrixelementen moeten worden verwerkt:

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

Multidimensionale matrices doorgeven als argumenten

U geeft een geïnitialiseerde multidimensionale matrix door aan een methode op dezelfde manier als u een eendimensionale matrix doorgeeft. De volgende code toont een gedeeltelijke declaratie van een afdrukmethode die een tweedimensionale matrix accepteert als argument. U kunt in één stap een nieuwe matrix initialiseren en doorgeven, zoals wordt weergegeven in het volgende voorbeeld. In het volgende voorbeeld wordt een tweedimensionale matrix met gehele getallen geïnitialiseerd en doorgegeven aan de Print2DArray methode. Met de methode worden de elementen van de matrix weergegeven.

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

Gelabelde matrices

Een gelabelde matrix is een matrix waarvan de elementen matrices zijn, mogelijk van verschillende grootten. Een onregelmatige matrix wordt ook wel een 'matrix van matrices' genoemd. De elementen zijn referentietypen en worden geïnitialiseerd tot null. In de volgende voorbeelden ziet u hoe u gelabelde matrices declareert, initialiseert en opent. Het eerste voorbeeld, jaggedArraywordt gedeclareerd in één instructie. Elke ingesloten matrix wordt gemaakt in volgende instructies. Het tweede voorbeeld jaggedArray2 wordt gedeclareerd en geïnitialiseerd in één instructie. Het is mogelijk om onregelmatige en multidimensionale matrices te combineren. Het laatste voorbeeld, jaggedArray3is een declaratie en initialisatie van een enkeldimensionale gelabelde matrix die drie tweedimensionale matrixelementen van verschillende grootten bevat.

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

De elementen van een gelabelde matrix moeten worden geïnitialiseerd voordat u ze kunt gebruiken. Elk van de elementen is zelf een matrix. Het is ook mogelijk om initialisaties te gebruiken om de matrixelementen te vullen met waarden. Wanneer u initializers gebruikt, hebt u de matrixgrootte niet nodig.

In dit voorbeeld wordt een matrix gebouwd waarvan de elementen zelf matrices zijn. Elk van de matrixelementen heeft een andere grootte.

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

Impliciet getypte matrices

U kunt een impliciet getypte matrix maken waarin het type matrixexemplaren wordt afgeleid van de elementen die zijn opgegeven in de initialisatiefunctie van de matrix. De regels voor impliciet getypte variabelen zijn ook van toepassing op impliciet getypte matrices. Zie Impliciet getypte lokale variabelen voor meer informatie.

In de volgende voorbeelden ziet u hoe u een impliciet getypte matrix maakt:

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

In het vorige voorbeeld ziet u dat bij impliciet getypte matrices geen vierkante haken worden gebruikt aan de linkerkant van de initialisatie-instructie. Bovendien worden onregelmatige matrices geïnitialiseerd met behulp van new [] enkelvoudige matrices.

Wanneer u een anoniem type maakt dat een matrix bevat, moet de matrix impliciet worden getypt in de object-initialisatiefunctie van het type. In het volgende voorbeeld contacts is een impliciet getypte matrix van anonieme typen, die elk een matrix met de naam PhoneNumbersbevat. Het var trefwoord wordt niet gebruikt in de object-initialisatiefuncties.

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