Matriser
Du kan lagra flera variabler av samma typ i en matrisdatastruktur. Du deklarerar en matris genom att ange typen av dess element. Om du vill att matrisen ska lagra element av vilken typ som helst kan du ange object som dess typ. I C#-systemets enhetliga typ ärver alla typer, fördefinierade och användardefinierade, referenstyper och värdetyper, direkt eller indirekt från Object.
type[] arrayName;
En matris har följande egenskaper:
- En matris kan vara endimensionell, flerdimensionell eller ojämn.
- Antalet dimensioner anges när en matrisvariabel deklareras. Längden på varje dimension upprättas när matrisinstansen skapas. Dessa värden kan inte ändras under instansens livslängd.
- En ojämn matris är en matris med matriser och varje medlemsmatris har standardvärdet
null. - Matriser är noll indexerade: en matris med
nelement indexeras från0tilln-1. - Matriselement kan vara av vilken typ som helst, inklusive en matristyp.
- Matristyper är referenstyper som härleds från den abstrakta bastypen Array. Alla matriser implementerar IList och IEnumerable. Du kan använda foreach-instruktionen för att iterera via en matris. Endimensionella matriser implementerar IList<T> också och IEnumerable<T>.
Elementen i en matris kan initieras till kända värden när matrisen skapas. Från och med C# 12 kan alla samlingstyper initieras med ett samlingsuttryck. Element som inte initieras är inställda på standardvärdet. Standardvärdet är 0-bitarsmönstret. Alla referenstyper (inklusive icke-nullbara typer) har värdena null. Alla värdetyper har 0-bitarsmönster. Det innebär att egenskapen Nullable<T>.HasValue är false och att egenskapen Nullable<T>.Value är odefinierad. I .NET-implementeringen Value utlöser egenskapen ett undantag.
I följande exempel skapas endimensionella, flerdimensionella och ojämna matriser:
// 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];
Endimensionella matriser
En endimensionell matris är en sekvens med liknande element. Du kommer åt ett element via dess index. Indexet är dess ordningsföljdsposition i sekvensen. Det första elementet i matrisen är vid index 0. Du skapar en endimensionell matris med den nya operatorn som anger matriselementtypen och antalet element. I följande exempel deklareras och initieras endimensionella matriser:
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
*/
Den första deklarationen deklarerar en ennitialiserad matris med fem heltal, från array[0] till array[4]. Elementen i matrisen initieras till standardvärdet för elementtypen för 0 heltal. Den andra deklarationen deklarerar en matris med strängar och initierar alla sju värdena i matrisen. En serie Console.WriteLine instruktioner skriver ut alla element i matrisen weekDay . För endimensionella matriser bearbetar -instruktionen foreach element i ökande indexordning, med början i index 0 och slutar med index Length - 1.
Skicka endimensionella matriser som argument
Du kan skicka en initierad endimensionell matris till en metod. I följande exempel initieras en matris med strängar och skickas som ett argument till en DisplayArray metod för strängar. Metoden visar elementen i matrisen. ChangeArray Sedan omvänder metoden matriselementen ChangeArrayElements och sedan ändrar metoden de tre första elementen i matrisen. När varje metod har returnerats DisplayArray visar metoden att överföring av en matris efter värde inte förhindrar ändringar i matriselementen.
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
Flerdimensionella matriser
Matriser kan ha mer än en dimension. Följande deklarationer skapar till exempel fyra matriser: två har två dimensioner, två har tre dimensioner. De två första deklarationerna deklarerar längden på varje dimension, men initierar inte matrisens värden. De andra två deklarationerna använder en initialiserare för att ange värdena för varje element i den flerdimensionella matrisen.
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
För flerdimensionella matriser passerar elementen så att indexen för den högra dimensionen ökas först, sedan nästa vänstra dimension och så vidare till det vänstra indexet. I följande exempel räknas både en 2D- och 3D-matris upp:
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
I en 2D-matris kan du se det vänstra indexet som raden och det högra indexet som kolumn.
Men med flerdimensionella matriser ger en kapslad för -loop mer kontroll över i vilken ordning matriselementen ska bearbetas:
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
//
Skicka flerdimensionella matriser som argument
Du skickar en initierad flerdimensionell matris till en metod på samma sätt som du skickar en endimensionell matris. Följande kod visar en partiell deklaration av en utskriftsmetod som accepterar en tvådimensionell matris som argument. Du kan initiera och skicka en ny matris i ett steg, vilket visas i följande exempel. I följande exempel initieras och skickas en tvådimensionell matris med heltal till Print2DArray metoden. Metoden visar elementen i matrisen.
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
*/
Ojämna matriser
En ojämn matris är en matris vars element är matriser, eventuellt av olika storlekar. En ojämn matris kallas ibland för en "matris med matriser". Dess element är referenstyper och initieras till null. I följande exempel visas hur du deklarerar, initierar och får åtkomst till ojämna matriser. Det första exemplet, jaggedArray, deklareras i en -instruktion. Varje innesluten matris skapas i efterföljande instruktioner. Det andra exemplet jaggedArray2 deklareras och initieras i en -instruktion. Det går att blanda ojämna och flerdimensionella matriser. Det sista exemplet jaggedArray3, , är en deklaration och initiering av en endimensionell taggig matris som innehåller tre tvådimensionella matriselement av olika storlekar.
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);
En ojämn matriss element måste initieras innan du kan använda dem. Vart och ett av elementen är i sig en matris. Det går också att använda initialiserare för att fylla matriselementen med värden. När du använder initierare behöver du inte matrisstorleken.
I det här exemplet skapas en matris vars element själva är matriser. Vart och ett av matriselementen har olika storlek.
// 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 inskrivna matriser
Du kan skapa en implicit typinskriven matris där typen av matrisinstansen härleds från elementen som anges i matrisinitieraren. Reglerna för en implicit typvariabel gäller även för implicit inskrivna matriser. Mer information finns i Implicit inskrivna lokala variabler.
I följande exempel visas hur du skapar en implicit typad matris:
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
*/
I föregående exempel bör du observera att med implicit skrivna matriser används inga hakparenteser till vänster om initieringsinitieringsinstrukationen. Dessutom initieras ojämna matriser med hjälp new [] av precis som endimensionella matriser.
När du skapar en anonym typ som innehåller en matris måste matrisen implicit skrivas i typens objektinitierare. I följande exempel contacts är en implicit typ av matris med anonyma typer, som var och en innehåller en matris med namnet PhoneNumbers. Nyckelordet var används inte i objektinitierarna.
var contacts = new[]
{
new
{
Name = "Eugene Zabokritski",
PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
},
new
{
Name = "Hanying Feng",
PhoneNumbers = new[] { "650-555-0199" }
}
};
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för