Diziler
Dizilerde aynı tipten birden fazla değişken tutulabilir. Bir dizi, elemanlarının tipi kullanılarak tanımlanır.
int[] dizi=new int[]{1,2,3,4};
- Üç tip dizi tanımlanabilir: tek boyutlu diziler, çok boyutlu diziler, düzensiz diziler.
- Dizinin boyut sayısı ve her bir boyutun eleman sayısı dizi nesnesi oluşturulduğunda belirlenir. Bu noktadan sonra dizi nesnesinin hayatı boyunca bu değerler değiştirilemez.
- Dizi nesnesi oluşturulduğunda dizi elemanları nümerikse değerleri 0 olur, dizi elemanları referans tipinden ise değerleri null olur.
- Düzensiz diziler her bir elemanı dizi olan dizilerdir. Bu nedenle düzensiz dizi nesnesi oluşturulduğunda her bir elemanı null değer alır. Çünkü diziler referans tipidir.
- Dizinin ilk elemanının indeksi 0'dır, n elemanlı bir dizinin son elemanının indeksi n-1'dir.
- Bütün diziler System.Array sınıfının bir nesnesi kabul edilir. Bu yüzden dizi nesneleri üzerinden System.Array sınıfının üyelerine erişilebilir. Bu sınıf IEnumerable arayüzünü uygulamıştır. Dolayısıyla foreach döngüsünde dizi elemanları döndüren konumunda kullanılabilir.
Dizi Tanımlama
5 elemanlı ve her bir elemanının tipi int olan bir dizi şöyle tanımlanır:
int[] dizi=new int[5];
Bu durumda dizinin her bir elemanı int tipinin varsayılanına atanır. Varsayılan değerler nümerik tipler için 0, char için ' ' (boşluk), bool için false'tur.
Bir dizinin elemanlarına tanımlandığı satırda değer verilebilir:
int[] dizi=new int[]{1,2,3,4};
Bu durumda dizinin eleman sayısını belirtmeye gerek yoktur.
Bir diziye tanımlandığı satırda değer veriliyorsa aşağıdaki kısayol kullanılabilir.
int[] dizi={1,2,3,4};
Bir dizi referansı değer verilmeden oluşturulabilir. Ancak daha sonra diziye değer verilmek istendiğinde kısayol kullanılamaz.
int[] dizi;
dizi=new int[]{1,2,3,4};
Başka bir örnek:
int[] dizi1=new[]{1,2,3,4};
int[] dizi2;
dizi=new[]{5,6,7,8};
Gördüğünüz gibi en uzun yol ile en kısa yol arasında ara çözümler de var. Burada atamanın sağında tip tekrar belirtilmemiş, ancak new[] ibaresi var. Üstelik bu yöntemi diziye ilk değer verme aşamasında değil, dizi belirtebileceğimiz her yerde kullanabiliriz.
Dizi Elemanlarını Kullanma
Dizi elemanlarına erişme ve bu elemanları değiştirme için [] operatörü kullanılır. Örnek:
Console.WriteLine(dizi[0]); //1
dizi[0]=5;
Console.WriteLine(dizi[0]); //5
Değer Tipi ve Referans Tipi Dizileri
Tip[] dizi=new Tip[5];
Bu satırda "Tip" tipinin referans tipi veya değer tipi olmasına göre dizi dizisinin alacağı değer farklıdır. Eğer "Tip" değer tipiyse oluşan dizinin her bir elemanı "Tip" tipinden birer nesnedir. Eğer "Tip" referans tipiyse oluşan dizinin her bir elemanının değeri null'dur, yani "Tip" referans tipiyse nesne oluşturulmaz, sadece referans oluşturulur. Örnek:
using System;
class Sinif{}
struct Yapi
{
public int Alan;
}
class Ana
{
static void Main()
{
Yapi[] y = new Yapi[5];
Console.WriteLine(y[0].GetType());
Console.WriteLine(y[0].Alan);
Sinif[] s = new Sinif[5];
//Console.WriteLine(s[0].GetType());
}
}
Yukarıdaki son satır yorum olmaktan çıkartılırsa program çalışma zamanında "null reference exception" hatası verir.
Çok Boyutlu Diziler
Diziler birden fazla boyutlu olabilir. Örneğin aşağıda iki boyutlu bir dizi tanımlanmaktadır:
int[,] array = new int[4, 2];
Aşağıda 4x2x3 boyutlarında üç boyutlu bir dizi tanımlanmaktadır:
int[, ,] array1 = new int[4, 2, 3];
Aşağıda bir çok boyutlu diziye tanımlandığı satırda değer verilmiştir:
int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
Burada dizinin boyutları bilinçli olarak belirtilmemiştir. Ancak istenirse bilinçli olarak belirtilebilir:
int[,] array2Da = new int[4, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
İki üç boyutlu diziye tanımlandığı satırda değer verilmesi:
int[, ,] array3D = new int[,,] {
{
{ 1, 2, 3 }, { 4, 5, 6 }
},
{
{ 7, 8, 9 }, { 10, 11, 12 }
}
};
int[, ,] array3Da = new int[2, 2, 3] {
{
{ 1, 2, 3 }, { 4, 5, 6 }
},
{
{ 7, 8, 9 }, { 10, 11, 12 }
}
};
Eğer dizi elemanlarına tanımlandığı satırda değer verilirse aşağıdaki kısayol kullanılabilir:
int[,] array4 = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
Eğer önce dizi referansı tanımlanır, sonra başka bir satırda dizi elemanlarına değer atanacak olursa bu kısayol kullanılamaz. new operatörlü uzun yolun kulllanılması gerekir.
Çok boyutlu dizilerin elemanlarına aşağıdaki gibi ulaşılır:
int degisken1=array4[1,1]; //4
int degisken2=array3D[1,0,2]; //9
array4[1,1]=5;
Console.WriteLine(array4[1,1]);//5
Düzensiz Diziler
Her bir elemanı dizi olan dizilere düzensiz diziler denir. Dizinin her bir elemanı değişik boyut ve eleman sayısına sahip olabilir. Aşağıda üç tane int dizisi içeren bir dizi tanımlanmıştır:
int[][] jaggedArray = new int[3][];
Diziler bir referans tipi olduğu için dizinin her bir elemanının değeri şu an null'dur. Düzensiz dizinin elemanı olan diziler şöyle oluşturulabilir:
jaggedArray[0] = new int[5];
jaggedArray[1] = new int[4];
jaggedArray[2] = new int[2];
Düzensiz dizinin her bir elemanına eleman sayısını belirtmeden direkt değer de verilebilir:
jaggedArray[0] = new int[] { 1, 3, 5, 7, 9 };
jaggedArray[1] = new int[] { 0, 2, 4, 6 };
jaggedArray[2] = new int[] { 11, 22 };
Düzensiz dizilerin elemanlarına şu şekilde de tanımlandığı satırda değer verilebilir:
int[][] jaggedArray2 = new int[][]
{
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
};
Sadece düzensiz dizinin tanımlandığı satırda olmak üzere düzensiz dizilerin elemanlarına değer vermek için aşağıdaki kısayol da kullanılabilir:
int[][] jaggedArray3 =
{
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
};
Ancak burada içerideki normal diziler kısayolla oluşturulamaz. Çünkü içerideki diziler tanımlanmıyor, sadece oluşturuluyor.
Düzensiz dizilerin her bir elemanına şöyle erişilebilir:
jaggedArray3[0][1] = 77; //önceki değeri:3
jaggedArray3[2][1] = 88; //önceki değeri:22
Çok boyutlu dizilerle düzensiz diziler karıştırılabilir:
int[][,] jaggedArray4 = new int[3][,]
{
new int[,] { {1,3}, {5,7} },
new int[,] { {0,2}, {4,6}, {8,10} },
new int[,] { {11,22}, {99,88}, {0,9} }
};
Burada öncelikle her bir elemanı dizi olan üç elemanlı bir dizi oluşturulmuştur. Daha sonra her bir elemana iki boyutlu int dizileri atanmıştır. Bu örnekteki örneğin 99 elemanına şöyle erişilir:
int i=jaggedArray4[2][1,0];
foreach döngüsü
System.Array sınıfı IEnumerable arayüzünü uygular. Bu yüzden diziler üzerinde foreach döngüsüyle dolaşılabilir.
int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
foreach (int i in numbers)
{
System.Console.Write("{0} ", i);
}
foreach döngüsü çok boyutlu dizilerde de başarıyla kullanılabilir:
int[,] numbers2D = new int[3, 2] { { 9, 99 }, { 3, 33 }, { 5, 55 } };
foreach (int i in numbers2D)
{
System.Console.Write("{0} ", i);
}
// çıktı: 9 99 3 33 5 55
Düzensiz diziler hedeflendiği gibi foreach döngüsüyle kullanılamaz. Çünkü düzensiz diziler üzerinde foreach döngüsüyle dönülürse her bir iterasyonda yine bir dizi elde edilir.
Dizilerin Argüman Olarak Gönderilebilmesi
Diziler metotların parametrelerine argüman olarak gönderilebilir. Diziler bir referans tipi olduğu için dizi üzerinde metot içinde değişiklik yapılması esas diziyi etkileyecektir. Ancak metot içinde metot parametresi başka bir değere atanırsa bu durum esas diziyi etkilemez. Örnek:
class ArrayClass
{
static void PrintArray(int[] arr)
{
for (int i = 0; i < arr.Length; i++)
{
System.Console.Write(arr[i]+" ");
}
}
static void ChangeArray(int[] arr)
{
arr = new int[] { 0, 0, 0 };
}
static void ChangeArrayElements(int[] arr)
{
arr[0] = 10;
arr[1] = 11;
arr[2] = 12;
}
static void Main()
{
int[] dizi = { 1, 2, 3, 4, 5, 6, 7 };
PrintArray(dizi);
ChangeArray(dizi);
System.Console.WriteLine("ChangeArray uygulandı:");
PrintArray(dizi);
System.Console.WriteLine();
ChangeArrayElements(dizi);
System.Console.WriteLine("ChangeArrayElements uygulandı:");
PrintArray(dizi);
}
}
Yukarıdaki programdaki ChangeArray() metodu esas dizide değişiklik yapmamış, ancak ChangeArrayElements() metodu esas dizide değişiklik yapmıştır. Bir dizi bir metoda argüman olarak verilirken metot dizinin adresini parametre değişkenine kopyalar, metot bu parametre değişkeni üzerinde çalışır. Metot, bu değişkene başka bir dizi atarsa üzerinde çalıştığı adresi değiştirmiş olur, ancak metot bu değişkenin belirttiği adresi değiştirmeden bu dizi üzerinde değişiklik yaparsa değişiklik esas diziyi etkiler.
Metotlara tek boyutlu diziler yanında çok boyutlu diziler de argüman olarak verilebilir.
ref ve out anahtar sözcükleri
ref anahtar sözcüğü
Bir metoda bir dizi ref anahtar sözcüğüyle gönderilirse dizinin adresi parametre değişkenine kopyalanmaz, bunun yerine parametre değişkeninin gösterdiği adresle metoda argüman olarak gönderilen dizinin adresleri eşitlenir. Metot içinde parametre değişkeninin adresi değişirse bu durum esas dizinin de adresinin değişmesine neden olacaktır. Örnek:
class ArrayClass
{
static void PrintArray(int[] arr)
{
for (int i = 0; i < arr.Length; i++)
{
System.Console.Write(arr[i]+" ");
}
System.Console.WriteLine();
}
static void ChangeArray(ref int[] arr)
{
arr = new int[] { 0, 0, 0 };
}
static void Main()
{
int[] dizi = { 1, 2, 3, 4, 5, 6, 7 };
ChangeArray(ref dizi);
PrintArray(dizi);
}
}
Bu program ekrana 0 0 0 çıktısını verecektir. Bir parametrenin ref olarak belirtilmesi durumunda çağıran metodun çağrılan metoda mutlaka değişken göndermesi gerekir, sabit veya ifade gönderemez.
out anahtar sözcüğü
ref anahtar sözcüğünde olduğu gibi out anahtar sözcüğü ile gönderilen dizilerin de adresleri metot parametre değişkeninin gösterdiği adresle eşitlenir. out anahtar sözcüğünün ref anahtar sözcüğünden şöyle farkları vardır:
- out olarak gönderilen argümanlara çağırıcı metot içinde ilk değer atanması zorunlu değildir.
- out olarak alınan parametreler çağrılan metot tarafından kullanılmadan önce ilk değer atanması gerekir, direkt kullanılamaz.
Bilinçsiz Tipli Diziler
var anahtar sözcüğüyle bilinçsiz tipli diziler oluşturulabilir. Örnekler:
class ImplicitlyTypedArraySample
{
static void Main()
{
var a = new[] { 1, 10, 100, 1000 }; // int[]
var b = new[] { "hello", null, "world" }; // string[]
// tek boyutlu düzensiz dizi
var c = new[] { new[]{1,2,3,4}, new[]{5,6,7,8} };
}
}
Dizinin elemanlarının anonim nesneler olması durumunda dizi tanımının bilinçsiz tipli olması zorunludur. Örnek:
var contacts = new[]
{
new {
Name = " Eugene Zabokritski",
PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
},
new {
Name = " Hanying Feng",
PhoneNumbers = new[] { "650-555-0199" }
}
};