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;

Dizi bir başvuru türüdür, bu nedenle dizi null yapılabilir başvuru türü olabilir. Öğelerin türleri referans türleri olabilir, bu nedenle boş değer atanabilir referans türlerini tutmak için bir dizi tanımlanabilir. Aşağıdaki örnek bildirimler, dizinin veya öğelerin null atanabilirliğini bildirmek için kullanılan farklı söz dizimini gösterir:

type?[] arrayName; // non nullable array of nullable element types.
type[]? arrayName; // nullable array of non-nullable element types.
type?[]? arrayName; // nullable array of nullable element types.

Başlatılmamış öğeler bir dizide bu türün varsayılan değerine ayarlanır.

int[] numbers = new int[10]; // All values are 0
string[] messages = new string[10]; // All values are null.

Önemli

Yukarıdaki örnekte, türü string[]olsa da, null değer atanamayan dizelerden oluşan bir dizi olsa da, her öğe için varsayılan değer null'tır. Bir diziyi null olmayan değerlere başlatmanın en iyi yolu,koleksiyon ifadeleri kullanmaktır.

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.
• Düzensiz dizi, bir dizi dizisidir ve her üye dizi varsayılan değere null sahiptir.
• Dizilerde sıfırdan başlayarak dizinleme yapılır: n elemanlı bir dizi 0 ile n-1 arasında 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 IList ve IEnumerable uygular. Dizide yineleme yapmak için foreach deyimini kullanabilirsiniz. Tek boyutlu diziler de IList<T> ve IEnumerable<T> uygular.

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 olmayan türler dahil) değerlere null sahip. 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, Value özelliği bir istisna fırlatır.

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, dizileri başlatmak için { ve } kullanı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, array[0]'den array[4]'e kadar beş tamsayıdan oluşan başlatılmamış bir dizi bildirir. Dizinin öğeleri, öğe türünün varsayılan değerine, tamsayılar için , 0 olarak 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 ifade, weekDay dizisinin tüm öğelerinin çıktısını verir. Tek boyutlu diziler için, foreach deyimi, 0. dizin ile başlayıp Length - 1 dizininde biten öğeleri artan dizin sırasına göre işler.

Tek boyutlu dizileri bağımsız değişken olarak geçirme

Başlatılmış tek boyutlu bir diziyi bir metoda geçirebilirsiniz. Aşağıdaki örnekte, bir dize dizisi başlatılır ve bir DisplayArray yöntemine argüman olarak iletilir. 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 bir yöntem döndüğü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. İki dizinin iki boyutu vardır. İki dizinin üç 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 artacak şekilde sırayla gezilir, ardından bir sonraki sol boyut, bu şekilde en soldaki dizine doğru devam edilir. 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 bir for döngüsü kullanmak, dizi öğelerinin işlenme sırası üzerinde daha fazla kontrol 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 argüman olarak geçirmek

Başlatılmış çok boyutlu bir diziyi, tek boyutlu bir dizide olduğu gibi bir metoda 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 aktarılır. 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({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

Düzensiz dizi, öğeleri farklı boyutlarda olabilen diziler olan bir dizidir. Düzensiz bir dizi bazen "diziler dizisi" olarak adlandırılır. Öğeleri başvuru türleridir ve null ile 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 , jaggedArraytek bir deyimde bildirilir. İçerilen her dizi daha sonraki ifadelerde 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, jaggedArray3farklı 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 başlatıcıda belirtilen öğelerden türü örtük olarak belirlenen 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 Örtük Olarak Yazılan Yerel Değişkenler bölümüne bakın.

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 dikkat edin ki, örtük tür tanımlı dizilerde başlatma deyiminin sol tarafında köşeli ayraç kullanılmamaktadır. Ayrıca, pürüzlü diziler, tek boyutlu dizilerde olduğu gibi new [] kullanılarak tanımlanı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 PhoneNumbers adlı bir dizi içeren, örtük olarak yazılan anonim türlerden oluşan bir dizidir. 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" }
    }
};