6. BÖLÜM : DİZİ DEĞİŞKENLER(*)

C#’da dizi değişken tanımlama işlemi 2 aşamada yapılmaktadır. İlk aşamada aşağıda yapıldığı gibi dizi değişkenin tipi seçilip tanımlanmaktadır. Tanımlanan değişkenin dizi değişken olduğunu işaret etmek için tip adından sonra köşeli parantezlere([]) yer verilir. 

    int[] Ogrenci; 

Bu satır sayesinde sayısal bilgileri saklayabileceğiniz “Ogrenci” adında bir dizi değişken tanımlanır. Bu dizi değişkenin eleman sayısı henüz belli değildir. Dizi değişkenin eleman sayısı new anahtar kelimesinden sonra işaret edilmektedir. 

    int[] Ogrenci; 
    Ogrenci = new int[10]; 

Burada yapıldığı gibi dizi değişkeni 2 satır yerine tek satırda tanımlayabilirsiniz. Bu 2 satırın işlevini aşağıda verilen satır tek başına yerine getirir. Bu dizi değişken int tipinde olduğu için elemanlara ilk değer olarak 0 aktarılır. 

    int[] Ogrenci = new int[10]; 

Bu şekilde tanımlanan değişkenlere dizi değişken adı verilmektedir. Çünkü tanımlanan bu 10 değişken için bellekte yan yana yer ayrılmaktadır. C# ve .NET uyumlu programlama dillerinde dizi değişken tanımlamak demek bir bakıma System adlı namespace’teki Array sınıfının örneğini almak demektir. 

Array sınıfı abstract bir sınıf olduğu için new anahtar kelimesi ile örneği alınamaz. Daha sonra abstract sınıfların normal sınıflara olan farkları ve işlevleri hakkında bilgi verilecektir. Array sınıfı IList arayüzünü uygulamış olsa bile Add,() Remove() ve Insert() gibi metotlara sahip değildir. Bu kitabın ileriki sayfalarında IList arayüzü hakkında bilgi verilecektir. 

Dizi değişkenlere bilgi aktarmak veya dizi değişkenin içeriğini başka amaçlarla kullanmak için bu 10 değişkenden hangisi kullanılmak isteniyorsa o değişkenin dizi içindeki sıra numarası değişken adına köşeli parantez içinde eklenmelidir. Örneğin tanımlanan bu 10 değişkenden ilkine bilgi aktarmak için aşağıdaki gibi bir satır yazılabilir. 

    int[] Ogrenci = new int[10]; 
    Ogrenci[0] = 65; 

Bundan çıkarılması gereken sonuç şudur: Verilen örnekte olduğu gibi benzer işlevleri olan ve aynı tipteki birden fazla değişkeni ayrı ayrı tanımlamak yerine bu değişkenleri bir seferde dizi değişken olarak tanımlamanız önerilir. Dizi değişkenin ilk elemanın sıra numarası 0 olduğu için yukarıdaki tanımlamaya göre aşağıda işaret edilen satır hataya neden olur. 

    int[] Ogrenci = new int[10]; 
    Ogrenci[10] = 70;  // hata meydana gelir 

Dizi değişkenin elemanlarına farklı tipteki bilgileri aktarmak istiyorsanız değişkenin tipini object olarak seçmelisiniz. char tipindeki dizi değişkenler hakkında bilgi sahibi olmanız için aşağıda verilen kodu hazırladık. 

    char[] T = new char[4];     
    T[0] ='A'; 
    T[1] ='n'; 
    T[2] ='k'; 
    T[3] ='a'; 
    string Kus = Convert.ToString(T[0])+ Convert.ToString(T[1])+ 
        Convert.ToString(T[2]) + Convert.ToString(T[3]); 

Bu işlemin tersini yani string değişkenin içeriğini char tipindeki dizi değişkene aktarabilirsiniz. Bu işlemin nasıl yapıldığını aşağıda görebilirsiniz. string bilginin uzunluğunu öğrenip ondan sonra char tipindeki dizi değişkeni boyutlandırabilirsiniz. 

    string str = "Fenerbahçe"; 
    char[] kar = new char[10] ; 
    for (int i = 0; i < 10; i++) 
     { 
       kar[i] = str[i]; 
     } 

String değişkenin içeriğini char tipindeki dizi değişkene aktarırken String sınıfının ToCharArray() metodundan yararlanabilirsiniz. Bu metot string bilgileri char tipindeki diziye aktarmadan önce dizi değişkeni boyutlandırmaktadır. 

    string str = "Fenerbahçe"; 
    char[] kar = str.ToCharArray(); 
    int uzunluk = kar.Length;  
    for (int i = 0; i < uzunluk; i++) 
     { 
       textBox1.Text += kar[i].ToString(); 
     } 

SetValue Metodu 

Dizi değişkenlere bilgi aktarılırken Array sınıfının SetValue() metodu kullanılabilinir. Bu metot dizi değişkene aktarılmak istenen bilgiyi ve elemanın sıra numarasını parametre olarak almaktadır. Bu metodun nasıl kullanıldığını aşağıda görebilirsiniz. 

    string[] ilk_5 = new string[2}; 
    ilk_5.SetValue("Kerem",0); 
    ilk_5.SetValue("İbrahim",1); 

String değişkenin içeriğini bir byte dizisine aktarırken Encoding.UTF8 sınıfının GetBytes() metodundan yararlanabilirsiniz. GetBytes() metodu parametre olarak aldığı String bilginin içeriğine bağlı olarak byte dizisini boyutlamaktadır. Aşağıda verilen kod işletildiğinde ilk TextBox’a “A”, ikinci TextBox’a ise A’nın ASCII kodu olan 65 yazılır. 

string Str = "Ankara";
Byte[] Dizi = Encoding.UTF8.GetBytes(Str);
textBox1.Text = Convert.ToString((Char)Dizi[0]);
textBox2.Text = Convert.ToString((Byte)Dizi[0]); 

CreateIntance() Metodu İle Dizi Değişken Tanımlamak 

Dizi değişken tanımlarken Array sınıfının CreateInstance() metodunu kullanabilirsiniz. 4 elemanlı string tipinde dizi değişken tanımlamak istiyorsanız bu metodunu aşağıdaki gibi kullanabilirsiniz. İlk satır ile tek, ikinci satır ile 2 boyutlu dizi değişken tanımlanır. 

Array Dizi = Array.CreateInstance(typeof(string), 4);
Array Dizi = Array.CreateInstance(typeof(string), 5, 5); 

Şimdi bu dizi değişkenin elemanlarına bilgi aktarıp içeriklerini bir ListBox’a aktaracağız. Bu amaçla forma bir ListBox yerleştirip aşağıda verilen kodu hazırladık. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   Array Dizi = Array.CreateInstance(typeof(string), 3); 
   Dizi.SetValue("Fenerbahçe", 0); 
   Dizi.SetValue("Beşiktaş", 1); 
   Dizi.SetValue("Galatasaray", 2); 
   foreach (string takim in Dizi) 
     listBox1.Items.Add(takim);   
 } 

Yukarıda CreateInstance() metodu ile dizi değişken tanımlamayı bir adımda gerçekleştirdik. İsterseniz bu işlemi aşağıda yapıldığı gibi 2 adımda gerçekleştirebilirsiniz. CreateInstance() metodu ile hazırlanan dizi değişkenden okuma yapılırken Array sınıfının GetValue() metodu kullanılmaktadır. Çok sayıda sürümü bulunan GetValue() metodu dizilerden okuduğu bilgiyi Object tipinde geriye göndermektedir. 

System.Array Dizi;
Dizi = System.Array.CreateInstance(typeof(string), 3);
Dizi.SetValue("Beşiktaş", 0);
Dizi.SetValue("Galatasaray", 1);
Dizi.SetValue("Fenerbahçe", 2);
for (int i=0; i < Dizi.Length; i++) 
  listBox1.Items.Add(Dizi.GetValue(i)); 

Dizi Değişkenlerin Eleman Sayısını Çalışma Anında Belirlemek 

Dizi değişkenin eleman sayısını çalışma anında belirlemek istiyorsanız değişken tanımlama işlemini 2 aşamada yapmalısınız. Aşağıda verilen kodda önce Ogrenci adında int tipinde bir dizi değişken tanımladık. Bu satırlar bir metoda yazılıp işletildiğinde dizi değişkenin eleman sayısı TextBox’ın mevcut içeriğine göre belirlenir. 

int[] Ogrenci;
int Sayi = Convert.ToInt32(textBox1.Text);
Ogrenci = new int[Sayi]; 

Programın ileri aşamalarında new anahtar kelimesini tekrar kullanıp dizi değişkenin eleman sayısını değiştirebilirsiniz. Ancak bu durumda dizi değişkenin elemanlarının mevcut içeriği silinir. Aşağıda verilen kodda eleman sayısını çalışma anında belirledikten sonra ilk elemana bilgi aktardık. Daha sonra bu dizi değişkeni yeniden boyutlandırdık. 

int Sayi = Convert.ToInt32(textBox1.Text);
int[] Ogrenci = new int[Sayi];
Ogrenci[0]= 10;
MessageBox.Show(Convert.ToString(Ogrenci[0])); // sonuç 10 olur.
Sayi = Convert.ToInt32(textBox2.Text);
Ogrenci = new int[Sayi];
MessageBox.Show(Convert.ToString(Ogrenci[0]));  // sonuç 0 olur. 

Dizi değişkenin eleman sayısı new anahtar kelimesi ile değiştirildiğinde elemanların içerikleri silineceği için bu örnekte Show() metodunun 2. kullanımında 0 mesajı alınır. Çünkü int tipindeki değişkenlerin başlangıç içerikleri sıfırdır. 

Diğer yandan Array sınıfının Resize() metodundan yararlanarak mevcut dizi değişkenlerin eleman sayısını değiştirebilirsiniz. Bu metot eleman sayısı değiştirilmek istenen dizi değişkenin referansını ve yeni eleman sayısını parametre olarak almaktadır. Resize() metodunun nasıl kullanıldığını aşağıda görebilirsiniz. 

private void Form1_Load(object sender, EventArgs e) 
  { 
    string[] iller = new string[2]; 
    iller[0] = "Adana"; 
    iller[1] = "Ankara"; 
    Array.Resize(ref iller, 3); 
    iller[2] = "Antalya"; 
    listBox1.Items.Add(iller[0]);  
    listBox1.Items.Add(iller[1]); 
    listBox1.Items.Add(iller[2]); 
  } 

Bu kodda önce 2 elemanlı bir dizi değişken tanımladık. Devamında bu 2 elemana bilgi aktarıp Resize() metodu ile bu dizi değişkenin eleman sayısını 3 yaptık. Ardından sonradan diziye eklenen elemana bilgi aktardık. Asıl vurgulamak istediğimiz nokta ise şudur: Resize() metodu ile eleman sayısı arttırılan dizi değişkenin mevcut elemanların içerikleri korunur. 

Dizi Değişkenlere İlk Değer Atamak 

Dizi değişkenleri tanımlarken normal değişkenlerde yapıldığı gibi ilk değer ataması yapılabilir. Bu işlemin nasıl yapıldığını aşağıda görebilirsiniz. Bu dizi değişkenin 4 elemana sahip olacağı işaret edildiği için parantezlerin arasında 4 bilgi yazılmalıdır. 

string[] Gunler = new string[] 
         {"Pazar", "Pazartesi", "Salı", "Çarşamba"}; 

İlk değer ataması yapılarak tanımlanan dizi değişkenlerin eleman sayısı belirtilmeyebilir. Çünkü dizi değişkenin eleman sayısı ilk değerlerin sayısına göre belirlenir. İlk değer atama işleminin nasıl yapıldığını aşağıda görebilirsiniz. 

string[] Gunler = new string[4]   
        { "Pazar", "Pazartesi", "Salı", "Çarşamba" };
listBox1.Items.Add(Gunler[0]);
listBox1.Items.Add(Gunler[1]);
listBox1.Items.Add(Gunler[2]);
listBox1.Items.Add(Gunler[3]); 

Bu kodda “Gunler” adında bir dizi değişken tanımladık ve tanımlama satırında parantezlerin arasına 4 günün adını yazdık. Parantezlerin arasına 4 bilgi yazıldığı için dizi değişken 4 elemana sahip olur. İlk değer ataması yapılarak tanımlanan dizi değişkenin elemanlarına sonradan başka bilgi aktarabilirsiniz. 

Kontrol Dizisi Hazırlamak 

Yukarıdaki sayfalarda dizi değişkenleri tanımlarken int ve string gibi veri tiplerinden yararlandık. Hazırlamak istediğiniz dizi değişkende TextBox, Button, ListBox gibi nesneleri saklayabilirsiniz. Aşağıda verilen satır işletildiğinde 3 adet button nesnesi saklayabilecek bir dizi değişken tanımlanmış olur. 

Button[] Dugme = new Button[3];  

Şimdi kod yazarak 3 adet Button nesnesi hazırlayıp bu değişkene aktaracağız. Konunun kolay anlaşılması için döngü kurmayıp aynı işlemi 3 kez tekrarladık. 

Button[] Dugme = new Button[3];
Dugme[0] = new Button();
Dugme[1] = new Button();
Dugme[2] = new Button(); 

Bu şekilde hazırlayıp Button tipindeki dizi değişkene aktardığınız nesnelerin genişlik ve yükseklik gibi özelliklerini ayarlayıp forma yerleştirebilirsiniz. Formların üzerine yerleştirilen nesneler Controls koleksiyonunda tutulmaktadır. “Dugme” adını verdiğimiz dizi değişkenin elemanlarının bazı özelliklerini ayarladıktan sonra Add metodu ile bu koleksiyona ekledik. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   Button[] Dugme = new Button[3]; 
   for (int i = 0; i < 3; i++) 
    { 
      Dugme[i] = new Button();  
      this.Controls.Add(Dugme[i]); 
      Dugme[i].Left = 25; 
      Dugme[i].Top = 25 + (i * 30); 
      Dugme[i].Width = 75; 
      Dugme[i].Text = "Düğme" + Convert.ToString(i + 1);  
    } 
  }

var Deyimi İle Dizi Değişken Tanımlamak 

Daha sonra değinileceği üzere değişken tanımlama işleminden söz edilirken C# 3.0’dan itibaren değişkenlerin tiplerinin değişkene aktarılan ilk değere göre belirlenebilmektedir. Var anahtar kelimesinden yararlanılarak yapılan bu işlem dizi değişkenler için de geçerlidir. Aşağıdaki gibi bir dizi değişken tanımlanırsa bu değişkenin int tipinde olduğuna hükmedilir. 

var yillar = new[] {2005, 2006, 2007, 2008};
this.Text = yillar[1].ToString();   

var anahtar kelimesinin kullanıldığı bu kod sayesinde 4 elemanlı ve int tipinde bir dizi değişken tanımlanmış olunur. Var deyimi ile yapılan bu dizi değişken tanımlama satırında ilk değer olarak daha küçük sayısal değerleri kullanılmış olunsaydı dizi değişkenin tipi yine Int32 olarak seçilirdi. var anahtar kelimesi ile aşağıdaki gibi dizi değişken tanımlamanız halinde tipinin string olduğuna karar verilir. 

var mevsimler = new[] {"ilkbahar", "yaz", "sonbahar","kış"}; 

Çok Boyutlu Dizi Değişkenler 

Çok boyutlu dizi değişken denildiği zaman genellikle 2 veya 3 boyutlu dizi değişkenler anlaşılmaktadır. 2 boyutlu dizi değişkenleri Excel ve Access tablolarına benzetmek mümkündür. Aşağıda verilen iki satır ile 2 boyutlu ve 6 elemanlı dizi değişken tanımlanır. 

int[,] Tablo;
Tablo = new int[2,3]; 

Bu şekilde tanımlanan dizi değişkeni 2 satır ve 3 sütuna sahip bir tablo gibi düşünebilirsiniz. Tablonun 1. satırındaki 1. ve 2. sütununa aşağıdaki gibi bilgi aktarabilirsiniz. 

int[,] Tablo;
Tablo = new int[2, 3];
Tablo[0, 0] = 10;
Tablo[0,1] = 15; 

Tek boyutlu dizi değişkenlerde olduğu gibi çok boyutlu dizi değişkenleri tanımlarken ilk değer ataması yapabilirsiniz. Aşağıda verilen satır sayesinde 2 satır ve 3 sütuna sahip 2 boyutlu bir dizi değişken tanımlanır ve elemanlara ilk değer ataması yapılır. 

string[,] Tablo ={{"Kerem","Kaya", "Alper"},{"İbrahim", "Kerem", "Tutku"}}; 

Dizi değişkenlerin kaç boyutlu olduğu öğrenilmek istendiği zaman Rank() metodu kullanılmaktadır. Bu metodun nasıl kullanıldığını aşağıda görebilirsiniz. 

string[,] Tablo;
Tablo = new string[4,5];
int boyut = Tablo.Rank; // boyut 2 olur. 

Dizi Değişkenlerin İçeriklerini Silmek ve Kopyalamak 

Yukarıda belirtildiği gibi new anahtar kelimesi ile sonradan dizi değişkenlerin eleman sayısı değişikliği yapıldığında elemanların içerikleri silinmektedir. Dizi değişkenlerin içeriklerini silmek için Clear() metodunu kullanabilirsiniz. Array sınıfının Clear() metodu 3 parametreye sahiptir. İlk parametrede elemanları sıfırlanacak dizi değişken belirtilmektedir. 

Array.Clear(Dizi Değişken, Başlangıç, Eleman Sayı) 

2. parametrede içeriği silinecek ilk eleman belirtilmektedir. Başka bir deyişle, içerik silme işleminin başlayacağı eleman işaret edilmektedir. 3. parametrede ise içeriği silinecek eleman sayısı verilmektedir. Clear() metodunun nasıl kullanıldığını aşağıda görebilirsiniz. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   string[] iller = { "Ankara", "Konya", "İzmir", "Bursa" }; 
   Array.Clear(iller, 1, 1); 
   MessageBox.Show(iller[1]);   
 } 

Bu metotta önce “iller” adında 4 elemana sahip bir dizi değişken tanımlanmaktadır. Ardından Array sınıfının Clear() metodu ile 2. elemandan başlamak üzere 1 elemanın içeriği silinmektedir. Bu metot işletildiğinde içeriği silinen eleman MessageBox sınıfının Show() metoduna parametre olarak verildiği için ekrana boş mesaj getirilir. 

Clear() metodu ile içeriği silinen eleman sayısal bilgiye sahipse 0 içeriğe sahip olur. Clear() metodu ile içeriği silinen string elemanların içeriğine boşluk ve bool tipindeki elemanlara ise false aktarılmaktadır. Bu nedenle aşağıda verilen satırlar bir metoda yazılıp işletilirse dizi değişkenin ilgili elemanlarına 0 aktarılır. 

int[] Dizi = new int[3];
Dizi[0] = 45;
Dizi[1] = 42;
Dizi[2] = 40;
Array.Clear(Dizi, 0, 3); 

Bir dizi değişkenin elemanlarının içeriklerini başka bir dizi değişkene aktarmak istiyorsanız Array sınıfının Copy() metodunu kullanabilirsiniz. Copy() metodu, kopyalamaya kaynaklık edecek dizi değişkeni 1. parametre olarak almaktadır. 

Copy(Kaynak Dizi, Hedef Dizi, Sayi) 

Kopyalama sırasında hedef durumunda olan dizi değişken Copy() metoduna 2. parametre olarak verilmeli ve içeriği kopyalanacak elemanların sayısı 3 parametrede belirtilmelidir. Bu metodun nasıl kullanıldığını anlatmak için aşağıda verilen kodu hazırladık. 

string[] ilk_5 = new string[5];
string[] kenar = new string[5];
ilk_5[0] = "Kerem";
ilk_5[1] = "İbrahim";
ilk_5[2] = "Hidayet";
ilk_5[3] = "Mehmet";
ilk_5[4] = "Mirsat";
Array.Copy(ilk_5, kenar, 3);
for (int X=0; X<3; X++) 
  listBox1.Items.Add(kenar[X]);  

Bu kodda önce aynı tip ve sayıda elemana sahip 2 dizi değişken tanımladık. Ardından ilk dizi değişkenin elemanlarına bilgi aktarıp ilk 3 elemanın içeriğini 2. dizi değişkenin aynı sıradaki elemanlarına kopyaladık. 

Yukarı verilen Copy() metodu kullanımında kaynak dizinin ilk elemanından başlamak üzere belirtilen sayıda elemanın içeriği hedef diziye kopyalandı. Kaynak diziden hedef dizi değişkene yapılacak kopyalamanın ilk elemandan itibaren yapılmasını istemiyorsanız kopyalamanın hangi elemandan itibaren yapılacağını belirtmeniz gerekir. Kaynak dizi değişkenin 2. ve 3. elemanlarını hedef dizi değişkenin aynı sıra numarasına sahip elemanlarına kopyalamak istiyorsanız Copy() metodunu aşağıdaki gibi kullanmalısınız. 

string[] ilk_5 = new string[5];
string[] kenar = new string[5];
ilk_5[0] = "Kerem";
ilk_5[1] = "İbrahim";
ilk_5[2] = "Hidayet";
ilk_5[3] = "Mehmet";
ilk_5[4] = "Mirsat";
kenar[0] = "Ender";
kenar[1] = "Tutku";
kenar[2] = "Haluk";
kenar[3] = "Kerem";
kenar[4] = "Kaya";
Array.Copy(ilk_5,1, kenar, 1, 2);
for (int X=0; X<5; X++) 
  listBox1.Items.Add(kenar[X]);  

Bu örnekte kaynak dizinin 2. elemanından başlamak üzere 2 elemanı hedef dizinin 2. ve 3. elemanlarına aktarılır. Başka bir deyişle hedef dizideki Tutku’nun yerine İbrahim, Haluk’un yerine ise Hidayet yazılır. 

Array sınıfının dizi değişkenler arası kopyalama yaparken kullanılan Copy() metodundan başka bir de CopyTo() metodu bulunmaktadır. Bu metot aşağıdaki gibi kullanıldığında kaynak dizinin içeriği hedef diziye ilk elemandan itibaren kopyalanır. 

ilk_5.CopyTo(kenar, 0); 

Length Özelliği İle Eleman Sayısını Öğrenmek 

Dizi değişkenlerin eleman sayısını öğrenirken Array sınıfının Length özelliğinden yararlanabilirsiniz. Bu özellik dizi değişkenin eleman sayısını içermektedir. Length özelliğinin nasıl kullanıldığını aşağıda görebilirsiniz. 

string[] Takimlar={"Bursaspor", "Trabzon", "Adanaspor"};
int X= Takimlar.Length; // X 3 olur 

“Takimlar” adını verilen dizi değişkenin eleman sayısını ilk değer atamasına göre belirledik. Bu dizi değişkeni aşağıdaki gibi tanımlamış olsaydık Length özelliği 10 değerini içerirdi. 

string[] Takimlar;
Takimlar = new string[10];
int X = Takimlar.Length; 

Length özelliği ile eleman sayısı öğrenilmek istenen dizi değişken çok boyutlu ise geriye dizi değişkenin toplam eleman sayısı gönderilir. Aşağıda tanımlanan dizi değişken 3*3=9 elemana sahip olduğu için Length özelliği 9 değerini içerir. 

string[,] Takimlar;
Takimlar = new string[3,3];
int X = Takimlar.Length; // X 9 olur. 

Bazen dizi değişkenin toplam eleman sayısı yerine istenilen boyutun eleman sayısı öğrenilmek istenir. Bu gibi durumlarda Length özelliği yerine Array sınıfının GetLength() metodu kullanılabilinir. Aşağıda verilen satırlar sayesinde 3 boyutlu dizi değişkenin 2. boyutunun eleman sayısı öğrenilir. 

    string[,,] Takimlar; 
    Takimlar = new string[3,4,3]; 
    int X = Takimlar.GetLength(1); // X 4 olur. 

Şimdi dizi değişkenlerin kullanılmasına örnek olması için formdaki TextBox’a küçük harflerle yazılan karaktersel bilgileri büyük harfe çevireceğiz. TextBox’lara küçük harflerle yazılan karaktersel bilgileri kolayca büyük harfe çevirmek mümkün olmakla birlikte buradaki amacımız dizi değişkenlerin nasıl kullanıldığına örnek vermektir. Aşağıda verilen kodda TextBox’a yazılan bilginin uzunluğuna göre char tipinde dizi değişken tanımladık. Ardından TextBox’ın içeriğinin her karakterini bu dizi değişkene aktardık. 

    int uzunluk = textBox1.Text.Length; 
    char[] Dizi = new char[uzunluk]; 
    for (int i = 0; i < uzunluk; i++) 
       Dizi[i] = textBox1.Text[i]; 

Bu şekilde TextBox’ın içeriğinin her karakterini char tipindeki dizi değişkene aktardıktan sonra dizi değişkenin her elemanın içeriğinin alfabetik karakter olup olmadığını araştırmak gerekecek. Elemanın içerdiği karakterin Ascii kodu 96’dan büyük ve 123’ten küçükçe dizi değişkenin ilgili elemanın Ascii kodundan 32 çıkaracağız. Bu kodun Türkçeye özgü küçük harfleri büyük harfe çeviremeyeceğini tahmin etmiş olmalısınız. 

    private void Form1_Click(object sender, EventArgs e) 
     { 
       int uzunluk = textBox1.Text.Length; 
       char[] Dizi = new char[uzunluk]; 
       for (int i = 0; i < uzunluk; i++) 
           Dizi[i] = textBox1.Text[i];   
       for (int i=0; i<uzunluk; i++) 
        { 
          int harf = (byte)Dizi[i]; 
          if (harf > 96 && harf < 123) 
             Dizi[i] = (char)(harf - 32); 
         } 
         for (int i = 0; i < uzunluk; i++) 
          textBox2.Text += Dizi[i]; 
      } 

Dizi Değişkenleri Sıralamak 

Dizi değişkenlerin içeriklerini sıralamak için kendiniz kod yazabilir veya Sort() metodundan yararlanabilirsiniz. Sort() metodu sıralanacak dizi değişkeni parametre olarak almaktadır. 

    Array.Sort(Dizi Değişken) 

Sort() metodu kendisine parametre olarak verilen dizi değişkenin elemanlarını küçükten büyüğe sıralar. Sort() ile dizi değişkenlerin nasıl sıralandığını anlatmak için ‘Gunler’ adında bir dizi değişken tanımlayıp haftanın günlerini bu dizi değişkene aktardık. 

    string[]Gunler = new string[7]; 
    Gunler[0] = "Pazar"; 
    Gunler[1] = "Pazartesi"; 
    Gunler[2] = "Salı"; 
    Gunler[3] = "Çarşamba"; 
    Gunler[4] = "Perşembe"; 
    Gunler[5] = "Cuma"; 
    Gunler[6] = "Cumartesi"; 
    Array.Sort(Gunler); 
    for (int X=0; X<7; X++) 
       listBox1.Items.Add(Gunler[X]); 

Dizi Değişkenleri Tersine Çevirmek 

Dizi değişkenin ilk elemanının son eleman, son elemanın ise ilk eleman olmak üzere yeniden düzenlemek istiyorsanız Array sınıfının Reverse() metodundan yararlanabilirsiniz. 

    Array.Reverse(Dizi Değişken) 

Reverse() metodu olmasaydı aşağıda verilen kod sayesinde bu işlemi yaparak dizi değişkenin elemanlarının sıra numarasını tersine çevirebilirdiniz. Bu kodda önce 2 dizi değişken tanımladık. Sonra ilk dizi değişkene haftanın günlerini aktardık. Ardından for döngüsü için ilk değişkenin son elemanını 2. değişkenin ilk elemanına aktardık. 

         string[] Gunler = new string[4; 
         string[] Temp = new string[4]; 
         int Boyut = Gunler.Length; 
         Gunler[0] = "Pazar"; 
         Gunler[1] = "Pazartesi"; 
         Gunler[2] = "Salı"; 
         Gunler[3] = "Çarşamba"; 
         for (int i=0; i < 4; i++) 
            Temp[i] = Gunler[Boyut-(i+1)]; 
         Gunler = Temp; 

Dizi Değişkenlerde Arama Yapmak – BinarySearch Metodu 

Dizi değişkenlerde arama yapılırken Array sınıfının BinarySearch() metodundan yararlanılmaktadır. BinarySearch metodunun aşırı yüklenmiş 4 sürümü bulunmaktadır. En basit sürümü 2 parametreye sahiptir. BinarySearch metodu ile dizi değişkenlerde arama yapabilmek için dizi değişkenin daha önceden Sort() metodu ile sıralanması gerekir. 

    Array.BinarySearch(Dizi Değişken, Aranacak Bilgi) 

Bu metot kendisine 2. parametre olarak verilen bilgiyi dizi değişkende arar. Aranan bilgi bulunamazsa geriye sıfırdan küçük bir değer gönderilir. Aranan bilgi dizide varsa bulunan elemanın dizi içindeki sıra numarası geriye gönderilir. BinarySearch() metodu ile nasıl arama yapıldığını anlatmak için projenin formunu aşağıdaki gibi düzenledik.



Formun Load olayını temsil eden metoda yazılacak satırlar sayesinde tanımlanan dizi değişkenin elemanları ListBox’a aktarılacaktır. Dizi değişkenin formdaki bütün metotlarda kullanılabilmesi için tanımlama satırını metodun dışına aldık. 

    string[] Basket; 
    privatevoid Form1_Load(object sender, EventArgs e) 
     { 
       Basket = new string[7]; 
       Basket[0] = "Kaya Peker"; 
       Basket[1] = "Kerem Tunçeri"; 
       Basket[2] = "İbrahim Kutluay"; 
       Basket[3] = "Mirsat Türkcan"; 
       Basket[4] = "Harun Erdenay"; 
       Basket[5] = "Hidayet Türkoğlu"; 
       for (int i = 0; i < Basket.Length; i++) 
          listBox1.Items.Add(Basket[i]);   
     } 

Kullanıcı dizi değişkende aramak istediği oyuncunun adını “Aranan” başlıklı TextBox’a yazıp “Arama Yap” düğmesini tıklayacak. Bu düğme tıklandığında BinarySearch ile arama yapmak için aşağıda verilen kodu yazdık. 

    private void Arama_Yap_Click(object sender, EventArgs e) 
     { 
       Array.Sort(Basket); 
       int Sonuc = Array.BinarySearch(Basket, textBox1.Text); 
       if (Sonuc <= -1) 
         textBox2.Text = "Bulunamadı"; 
       else 
         textBox2.Text = Basket[Sonuc]; 
      } 

BinarySearch metodu ile dizi değişkenlerde arama yapabilmek için dizi değişkenin daha önceden Sort() metodu ile sıralanması gerekir. Çalışma anında ilk TextBox’a bilgi yazılıp “Arama Yap” düğmesi tıklanırsa aşağıdaki gibi bir sonuç alınır.



BinarySearch() metodu ancak sıralanmış dizilerde arama yapabilmektedir. Dolayısıyla dizi değişkende aynı içeriğe sahip birden fazla eleman varsa bu elemanlar arka arkaya sıralanacaktır. Şimdi dizi değişkendeki aynı içeriğe sahip elemanları ListBox’a aktaracağım. Pratik değeri olmayan bu örneği vermemdeki amaç konu üzerinde düşünmenizi sağlamaktır. 

    string[] Dizi = new string[5]; 
    Dizi[0]="Hasan"; 
    Dizi[1]="Veli"; 
    Dizi[2]="Ali"; 
    Dizi[3]="Mehmet"; 
    Dizi[4]="Veli "; 
    Array.Sort(Dizi); 
    int ilk = Array.BinarySearch(Dizi, "Veli"); 
    if (ilk >= -1) 
        for (int i = ilk; i < 5; i++) 
    if (Dizi[i] == Dizi[ilk]) 
        listBox1.Items.Add(Dizi[i].ToString()); 

IndexOf Metodu İle Arama Yapmak 

Dizi değişkenlerde arama yaparken BinarySearch yerine IndexOf metodunu kullanabilirsiniz. Bu metot ile aramaya konu edilen dizi değişkenin sıralı olması şart değildir. Bu metot ile nasıl arama yapıldığını anlatmak için aşağıdaki kodu yazdık. IndexOf metodu geriye aranan elemanın sırasını göndermektedir. Aranan eleman dizide yoksa geriye -1 gönderilir. 

    string[] ilk_5 = new string[5]; 
    ilk_5[0] = "Kerem"; 
    ilk_5[1] = "İbrahim"; 
    ilk_5[2] = "Hidayet"; 
    ilk_5[3] = "Mehmet";
    ilk_5[4] = "Mirsat"; 
    string aranan = textBox1.Text; 
    int sira_no = Array.IndexOf(ilk_5, aranan); 
    if (sira_no > 0) 
        MessageBox.Show("Aranan eleman mevcut"); 

Dizi değişkende içeriği aynı olan birden fazla eleman varsa aynı içeriğe sahip son elemanın sıra numarasını öğrenirken LastIndexOf metodunu kullanabilirsiniz. Bu metodun nasıl kullanıldığını anlatmak için aşağıdaki gibi bir form hazırladık.



Kullanıcı çalışma anında aramak istediği bilgi veya elemanı ilk TextBox’a girip “Ara” düğmesini tıkladığında elemanın dizideki ilk ve son yeri öğrenilip ekrana getirilecek. Bu amaçla hazırladığımız kodu aşağıda verdik. 

    private void ara_Click(object sender, EventArgs e) 
     { 
       int aranan, ilk_sira, son_sira; 
       int[] dizi = new int[5]; 
       dizi[0] = 15; 
       dizi[1] = 20; 
       dizi[2] = 40; 
       dizi[3] = 30; 
       dizi[4] = 20; 
       aranan = Int32.Parse(textBox1.Text);
       ilk_sira = Array.IndexOf(dizi, aranan); 
       if (ilk_sira < 0) 
         MessageBox.Show("Aranan eleman mevcut değil"); 
       else 
         textBox2.Text = ilk_sira.ToString(); 
         son_sira = Array.LastIndexOf(dizi, aranan); 
         if (ilk_sira > 0 && ilk_sira != son_sira) 
           textBox3.Text = son_sira.ToString();   
      } 

Pratik değeri olmayan bu örnekte önce 5 elemanlı int tipinde bir dizi değişken hazırlayıp elemanlarına bilgi aktardık. Ardından kullanıcının ilk TextBox’a girmiş olduğu elemanı IndexOf metodu ile arayıp bu elemanın sıra numarasını 2. TextBox’a yazdık. Ardından aynı elemanı dizide bir kez de LastIndexOf metodu ile aradık. 

Dizi Değişkenin İçeriğini Birleştirmek – Join() Metodu 

Tanımlayıp elemanlarına bilgi aktarmış olduğunuz dizi değişkenin bütün elemanlarının içeriğini String sınıfının Join() metodundan yararlanarak String değişkende toplamak mümkündür. Join() metodu 2 parametreye sahiptir. 

    String.Join(Ayırıcı Karakter, Dizi Değişken) 

Dizi değişkenin elemanlarımı birbirinden ayırmak amacıyla kullanılan 1. parametrede birden fazla karakter kullanılabilinir. Join() metodu geriye dizi değişkenin bütün elemanlarının birleştirilmiş halini göndermektedir. 

    string[] Basket = new string[5]; 
    Basket[0] = "Kaya"; 
    Basket[1] = "Kerem"; 
    Basket[2] = "İbrahim"; 
    Basket[3] = "Harun"; 
    Basket[4] = "Mirsat"; 
    string sonuc = String.Join(", ", Basket); 
    MessageBox.Show(sonuc); 

Bu şekilde düzenlenen metot işletilince “Basket” adı verilen dizi değişkenin bütün elemanları “sonuc” adlı string değişkene aktarılır. Elemanları birbirinden ayırmak için virgül(,) ile birlikte boşluk karakterini kullandık. 

UpperBound Metodu İle Dizi Değişken Hakkında Bilgi Edinmek 

Dizi değişkenlerin en son elemanı veya elaman sayısının bir eksiğini öğrenmek istiyorsanız GetUpperBound() metodundan yararlanabilirsiniz. Bu metot 1 parametreye sahiptir. 

    Dizi Değişken.GetUpperBound(Boyut); 

GetUpperBound() metodundan önce adı yazılan dizi değişken 1 boyutlu ise parametre olarak 0 verilmelidir. Bu metot hakkında bilgi vermek için aşağıda verilen kodu yazdık. 

    string[] Basket; 
    Basket = new string[5]; 
    int sonuc = Basket.GetUpperBound(0); // sonuc 4 olur. 

Dizi değişken birden fazla boyuta sahip olsaydı ve dizi değişkenin 2. boyutunun eleman sayısını öğrenmek istemiş olsaydık bu metodu aşağıdaki gibi kullanırdık. 

    string[,] Basket; 
    Basket = new string[4,5]; 
    int sonuc = Basket.GetUpperBound(1); // sonuc 4 olur.