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 nullsahiptir.
• Diziler sıfır dizinli: öğeleri olan n bir dizi öğesinden dizinine 0 n-1dizinlenir.
• 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 nullsahiptir. 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];

// 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 - 1sı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 nullbaş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 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, 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 ö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ı PhoneNumbersbir 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" }
    }
};