Diziler
Dizi veri yapısında aynı türde birden çok değişken depolayabilirsiniz. Öğelerinin türünü belirterek bir dizi bildirirsiniz. Dizinin herhangi bir türdeki öğeleri depolamasını istiyorsanız, türü olarak belirtebilirsiniz object
. C# birleştirilmiş tür sisteminde, önceden tanımlanmış ve kullanıcı tanımlı tüm türler, başvuru türleri ve değer türleri, doğrudan veya dolaylı olarak öğesinden Objectdevralır.
type[] arrayName;
Bir dizi aşağıdaki özelliklere sahiptir:
- Bir dizi tek boyutlu, çok boyutlu veya pürüzlü olabilir.
- Bir dizi değişkeni bildirildiğinde boyut sayısı ayarlanır. Her boyutun uzunluğu, dizi örneği oluşturulduğunda oluşturulur. Bu değerler, örneğin ömrü boyunca değiştirilemez.
- Pürüzlü dizi bir dizi dizisidir ve her üye dizi varsayılan değerine
null
sahiptir. - Diziler sıfır dizinli: öğeleri olan
n
bir dizi öğesinden dizinine0
n-1
dizinlenir. - Dizi öğeleri, dizi türü de dahil olmak üzere herhangi bir türde olabilir.
- Dizi türleri, soyut temel türünden türetilen başvuru türleridir Array. Tüm diziler ve IEnumerableuygularIList. Dizide yineleme yapmak için foreach deyimini kullanabilirsiniz. Tek boyutlu diziler de ve IEnumerable<T>uygularIList<T>.
Dizi oluşturulduğunda bir dizinin öğeleri bilinen değerlere başlatılabilir. C# 12 ile başlayarak, koleksiyon türlerinin tümü bir Koleksiyon ifadesi kullanılarak başlatılabilir. Başlatılmamış öğeler varsayılan değere ayarlanır. Varsayılan değer 0 bit desenidir. Tüm başvuru türleri (null atanamayan türler dahil) değerlerine null
sahiptir. Tüm değer türlerinin 0 bit desenleri vardır. Bu, özelliğin Nullable<T>.HasValue olduğu false
ve özelliğin Nullable<T>.Value tanımsız olduğu anlamına gelir. .NET uygulamasında özelliği Value
bir özel durum oluşturur.
Aşağıdaki örnek tek boyutlu, çok boyutlu ve pürüzlü diziler oluşturur:
// 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];
Önemli
Bu makaledeki örneklerin çoğu dizileri başlatmak için koleksiyon ifadelerini (köşeli ayraç kullanan) kullanır. Koleksiyon ifadeleri ilk olarak .NET 8 ile birlikte gelen C# 12'de tanıtıldı. Henüz C# 12'ye yükseltemiyorsanız ve kullanarak {
}
dizileri başlatın.
// Collection expressions:
int[] array = [1, 2, 3, 4, 5, 6];
// Alternative syntax:
int[] array2 = {1, 2, 3, 4, 5, 6};
Tek boyutlu diziler
Tek boyutlu dizi , benzer öğeler dizisidir. Bir öğeye dizini aracılığıyla erişin. Dizin, dizideki sıralı konumudur. Dizideki ilk öğe dizinindedir 0
. Dizi öğesi türünü ve öğe sayısını belirten yeni işlecini kullanarak tek boyutlu bir dizi oluşturursunuz. Aşağıdaki örnek tek boyutlu dizileri bildirir ve başlatır:
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
*/
İlk bildirim, 'den array[0]
array[4]
öğesine beş tamsayıdan oluşan başlatılmamış bir dizi bildirir. Dizinin öğeleri, 0
tamsayılar için öğe türünün varsayılan değerine başlatılır. İkinci bildirim bir dize dizisi bildirir ve bu dizinin yedi değerinin tümünü başlatır. Bir dizi Console.WriteLine
deyim, dizinin tüm öğelerini weekDay
yazdırır. Tek boyutlu diziler için deyimi, foreach
dizin 0 ile başlayıp dizin ile biten öğeleri artan dizin Length - 1
sırasına göre işler.
Tek boyutlu dizileri bağımsız değişken olarak geçirme
Başlatılan tek boyutlu bir diziyi bir yönteme geçirebilirsiniz. Aşağıdaki örnekte, bir dize dizisi başlatılır ve dizeler için bir DisplayArray
yönteme bağımsız değişken olarak geçirilir. yöntemi dizinin öğelerini görüntüler. Ardından, ChangeArray
yöntemi dizi öğelerini tersine çevirir ve ardından ChangeArrayElements
yöntemi dizinin ilk üç öğesini değiştirir. Her yöntem döndürdüğünde DisplayArray
yöntemi, bir diziyi değere göre geçirmenin dizi öğelerinde değişiklik yapılmasını engellemediğini gösterir.
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
Çok boyutlu diziler
Diziler birden fazla boyuta sahip olabilir. Örneğin, aşağıdaki bildirimler dört dizi oluşturur: ikisinin iki boyutu, ikisinin üç boyutu vardır. İlk iki bildirim her boyutun uzunluğunu bildirir, ancak dizinin değerlerini başlatmaz. İkinci iki bildirim, çok boyutlu dizideki her öğenin değerlerini ayarlamak için bir başlatıcı kullanır.
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
Çok boyutlu diziler için, öğeler en sağdaki boyutun dizinleri önce artırılır, sonra bir sonraki sol boyut vb. en soldaki dizine geçirilir. Aşağıdaki örnekte hem 2B hem de 3B dizi numaralandırılır:
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
2B dizide sol dizini satır, sağ dizini ise sütun olarak düşünebilirsiniz.
Ancak, çok boyutlu dizilerde iç içe geçmiş bir for döngüsü kullanmak, dizi öğelerinin işlenme sırası üzerinde daha fazla denetim sağlar:
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
//
Çok boyutlu dizileri bağımsız değişken olarak geçirme
Başlatılan çok boyutlu bir diziyi tek boyutlu bir dizi ile aynı şekilde bir yönteme geçirirsiniz. Aşağıdaki kod, bağımsız değişkeni olarak iki boyutlu bir diziyi kabul eden bir yazdırma yönteminin kısmi bildirimini gösterir. Aşağıdaki örnekte gösterildiği gibi, bir adımda yeni bir dizi başlatabilir ve geçirebilirsiniz. Aşağıdaki örnekte, iki boyutlu bir tamsayı dizisi başlatılır ve yöntemine Print2DArray
geçirilir. yöntemi dizinin öğelerini görüntüler.
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
*/
Pürüzlü diziler
Pürüzlü dizi, öğeleri büyük olasılıkla farklı boyutlarda diziler olan bir dizidir. Pürüzlü bir dizi bazen "dizi dizisi" olarak adlandırılır. Öğeleri başvuru türleridir ve olarak null
başlatılır. Aşağıdaki örneklerde, pürüzlü dizileri bildirme, başlatma ve bunlara erişme işlemleri gösterilmektedir. İlk örnek olan , jaggedArray
tek bir deyimde bildirilir. İçerilen her dizi sonraki deyimlerde oluşturulur. İkinci örnek, jaggedArray2
tek bir deyimde bildirilir ve başlatılır. Tırtıklı ve çok boyutlu dizileri karıştırmak mümkündür. Son örnek, jaggedArray3
farklı boyutlarda üç iki boyutlu dizi öğesi içeren tek boyutlu pürüzlü bir dizinin bildirimi ve başlatılmasıdır.
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);
Bir pürüzlü dizinin öğelerini kullanabilmeniz için önce başlatılması gerekir. Öğelerin her biri bir dizidir. Dizi öğelerini değerlerle doldurmak için başlatıcıları kullanmak da mümkündür. Başlatıcıları kullandığınızda, dizi boyutu gerekmez.
Bu örnek, öğeleri kendi dizileri olan bir dizi oluşturur. Dizi öğelerinin her biri farklı bir boyuta sahiptir.
// 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
*/
Örtük olarak yazılan diziler
Dizi örneği türünün dizi başlatıcıda belirtilen öğelerden çıkarıldığı örtük olarak yazılan bir dizi oluşturabilirsiniz. Örtük olarak yazılan herhangi bir değişkenin kuralları, örtük olarak yazılan diziler için de geçerlidir. Daha fazla bilgi için bkz . Örtük Olarak Yazılan Yerel Değişkenler.
Aşağıdaki örneklerde örtük olarak yazılan bir dizinin nasıl oluşturulacağı gösterilmektedir:
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
*/
Önceki örnekte, örtük olarak yazılan dizilerde başlatma deyiminin sol tarafında köşeli ayraç kullanılmadığını görebilirsiniz. Ayrıca, pürüzlü diziler aynı tek boyutlu diziler gibi kullanılarak new []
başlatılır.
Dizi içeren anonim bir tür oluşturduğunuzda, dizinin türün nesne başlatıcısında örtük olarak yazılması gerekir. Aşağıdaki örnekte, contacts
her biri adlı PhoneNumbers
bir dizi içeren örtük olarak yazılan anonim tür dizisidir. Anahtar var
sözcük, nesne başlatıcılarının içinde kullanılmaz.
var contacts = new[]
{
new
{
Name = "Eugene Zabokritski",
PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
},
new
{
Name = "Hanying Feng",
PhoneNumbers = new[] { "650-555-0199" }
}
};