Yapı olarak yine mutable olanı (NSMutableDictionary) daha kullanışlıdır. Çünkü NSDictionary tanımlandığı anda değerleri ile birlikte initalize edilmesi gerekir. Sonradan (runtime) değer verilemez. Şimdi örneklere bakalım:

NSDictionary

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        // anahtar/değer çifti ile init edilerek tanımlama
        // (ilk veri "değer", ikincisi ise "anahtar")
        NSDictionary * my_dict = [[NSDictionary alloc]initWithObjectsAndKeys:@"kalem", @"pencil", @"kitap", @"book", @"kalem", @"pen", nil];
        NSLog(@"%@", my_dict);
        // sonuc
        // book = kitap;
        // pencil = kalem;
        // pen = kalem; olacaktır.
    }
    return 0;
}

Görüldüğü gibi NSDictionary nesnesi daha initialize edilirken değerleri atanıyor. Ancak bu durum özellikle verileri çalışma zamanında (runtime) almak istediğimizde sorun olur. Bu nedenle NSMutableDictionary kullanmak zorundayız. Fakat NSMutableDictionary konusuna geçmeden önce NSDictionary sınıfının bazı metotlarına göz atalım:

objectForKey

Anahtarı verip değerini almak içindir.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        NSDictionary * my_dict = [[NSDictionary alloc]initWithObjectsAndKeys:@"kalem", @"pencil", @"kitap", @"book", @"kalem", @"pen", nil];

        // anahtarı verip değerini alıyoruz
        NSLog(@"%@", [my_dict objectForKey:@"book"]);
        sonuc "kitap" olacak
    }
    return 0;
}

allKeysForObject

Bir değer için birden fazla anahtar varsa onların tümünü almak içindir.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        NSDictionary * my_dict = [[NSDictionary alloc]initWithObjectsAndKeys:@"kalem", @"pencil", @"kitap", @"book", @"kalem", @"pen", nil];

        // değeri verip bu değeri barındıran
        // tüm anahtarları alıyoruz
        NSLog(@"%@", [my_dict allKeysForObject:@"kalem"]);
        // sonuc "pencil, pen" olacak
    }
    return 0;
}

allKeys, allValues

Tüm anahtarları ya da tüm değerleri almak içindir

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        NSDictionary * my_dict = [[NSDictionary alloc]initWithObjectsAndKeys:@"kalem", @"pencil", @"kitap", @"book", @"kalem", @"pen", nil];

        // tüm anahtarları alıyoruz
        NSLog(@"%@", [my_dict allKeys"]);
        // sonuc "pencil, pen, book" olacak

        // tüm değerleri alıyoruz
        NSLog(@"%@", [my_dict allValues"]);
        // sonuc "kalem, kitap, kalem" olacak
    }
    return 0;
}

NSDictionary sınıfının metotlarından bazılarını gördükten sonra artık NSMutableDictionary sınıfına geçebiliriz.

NSMutableDictionary

Tanımlama yöntemleri hemen hemen aynıdır ama değerleri baştan verilerek initialize edilme zorunluluğu yoktur ve çalışma zamanında anahtar/değer çifti (key/value pair) eklenebilir. Ayrıca yukarıda sözünü ettiğim NSDictionary sınıfına metotlar, bu sınıfta da vardır ve aynı biçimde kullanılmaktadır. O nedenle burada tekrar anlatmayacağım. Şimdi bu sınıfın yukarıda bahsedilmeyen diğer metotlarından bazılarını inceleyelim:

setObject, setValue

Her iki metot da NSMutableDictionary türünden nesnemize yeni bir anahtar/değer ikilisi eklememizi ya da var olan bir anahtarın değerini değiştirmemizi sağlar.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        NSMutableDictionary * my_dict = [[NSDictionary alloc]init];

        // yeni anahtar/değer ikilisi ekliyoruz
        [my_dict setObject:@"book" forKey:@"kitap"];
        [my_dict setValue:@"pencil" forKey:@"kalem"];
    }
    return 0;
}

removeObjectForKey, removeObjectsForKeys, removeAllObjects

removeObjectForKey, anahtar vererek eleman siler. removeObjectsForKeys ise kendisine verilen bir NSArray türündeki dizide belirtilen anahtarları NSMutableDictionary içinden bulur ve siler. removeAllObjects ise tüm elemanları siler.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        NSMutableDictionary * my_dict = [[NSMutableDictionary alloc]init];
        [my_dict setObject:@"kalem" forKey:@"pencil"];
        [my_dict setObject:@"kitap" forKey:@"book"];
        [my_dict setObject:@"semsiye" forKey:@"umbrella"];

        // anahtar vererek eleman siler
        [my_dict removeObjectForKey:@"umbrella"];

        NSLog(@"%@", my_dict);
        // sonuc "book = kitap; pencil = kalem;" olur

        // tüm elemanları siler
        [my_dict removeAllObjects];

        NSLog(@"%@", my_dict);

       /*******************************************/
       // removeObjectsForKeys
        NSMutableDictionary * my_dict2 = [[NSMutableDictionary alloc]init];
        [my_dict2 setObject:@"kalem" forKey:@"pencil"];
        [my_dict2 setObject:@"kitap" forKey:@"book"];
        [my_dict2 setObject:@"semsiye" forKey:@"umbrella"];

        NSLog(@"%@", my_dict2);
        // sonuc "book = kitap; pencil = kalem;" olur

        // silinecek anahtarlar dizisi
        NSArray * silinecekler = [[NSArray alloc]initWithObjects:@"pencil", @"book", nil];

        // yukarıdaki dizide belirtilen elemanları siler
        [my_dict2 removeObjectsForKeys:silinecekler];

        NSLog(@"%@", my_dict2);
    }
    return 0;
}

count

Bu metot nesnemizdeki toplam tekil anahtar sayısını verir. Yani aşağıdaki örnekte olduğu gibi birden fazla “umbrella” anahtarınız var ise onları 1 sayacaktır.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        NSMutableDictionary * my_dict = [[NSMutableDictionary alloc]init];
        [my_dict setObject:@"kalem" forKey:@"pencil"];
        [my_dict setObject:@"kitap" forKey:@"book"];
        [my_dict setObject:@"semsiye" forKey:@"umbrella"];
        [my_dict setObject:@"yagmurluk" forKey:@"umbrella"];

        // tüm değerler
        NSLog(@"eleman sayisi: %lu", [my_dict count]);
        // sonuc "3" döner
    }
    return 0;
}

Faydalı olması dileğiyle…

NSString:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        // basitce bir NSString nesnesine değer atama
        NSString * str;
        str = @"bahcede 1 tane kedi var.";
        NSLog(@"%@", str);

        NSString * str0 = @"bahcede 2 tane kedi var.";
        NSLog(@"%@", str0);

        // diğer bir yöntem
        NSString * str1 = [[NSString alloc]init];
        str1 = @"bahcede 3 tane kedi var.";
        NSLog(@"%@", str1);

        // diğer bir yöntem daha
        NSString * str2 = [[NSString alloc]initWithString:@"bahcede 4 tane kedi var"];
        NSLog(@"%@", str2);

        // farklı türde bir değişkenden gelen değeri alarak tanımlama
        int adet = 5;
        NSString * str3 = [[NSString alloc]initWithFormat:@"bahcede %i tane kedi var", adet];
        NSLog(@"%@", str3);
    }
    return 0;
}

Yukarıdaki tanımlama biçimlerinin tamamı geçerlidir. NSString bir nesne olduğu için tanımlamalarda NSString ifadesinden hemen sonra mutlaka asteriks (*) karakteri kullanılmalıdır. Şimdi NSString sınıfının çok kullanılan bazı metotlarına göz atalım:

stringByAppendingFormat:

Bu metot bir string verinin içine bir değişkenden gelen farklı türlerdeki veriyi string içindeki herhangi bir noktaya eklemekte kullanılır. Örnekte adet değişkeninden gelen değer str1 içine %i belirteciyle alınmaktadır. Tüm Dize Biçimi Belirteçleri (String Format Specifiers)‘nin listesini şurada bulabilirsiniz.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        int adet = 5;

        NSString * str1 = [[NSString alloc]init];
        str1 = [str1 stringByAppendingFormat:@"bahcede %i tane kedi var", adet];

        NSLog(@"%@", str1);
        // sonuç "bahcede 5 tane kedi var" olur.
    }
    return 0;
}

stringByAppendingString:

Bu metot bir string verinin başına ya da sonuna bir değişkenden gelen ya da sabit olarak tanımlanmış NSString türündeki verileri verileri eklemekte kullanılır.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        NSString * str1 = @"bahcede 5 tane ";
        str1 = [str1 stringByAppendingString:@"kedi var."];
        NSLog(@"%@", str1);
        // "bahcede 5 tane kedi var" olur.
    }
    return 0;
}

substringFromIndex:

Bu metot bir string dizesindeki belirtilen indeksten başlayarak (belirtilen indeks de dahil) sonuna kadar olan kısmını döndürür:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        NSString * str1 = @"bahcede 5 tane kedi var.";

        // 3. indeksten başlayarak almak için (3. de dahil)
        NSString * str2 = [str1 substringFromIndex:3];
        NSLog(@"%@", str2);

        // ya da NSLog içinde doğrudan metot çağrılabilir
        NSLog(@"%@", [str1 substringFromIndex:3]);

        //sonuc "cede 5 tane kedi var."
    }
    return 0;
}

substringToIndex:

Bu metot bir string dizesinde baştan itibaren belirtilen indekse kadar (belirtilen indeks hariç) olan kısmını döndürür:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        NSString * str1 = @"bahcede 5 tane kedi var.";

        // 12. indekse kadar (12. hariç)
        NSString * str2 = [str1 substringToIndex:12];
        NSLog(@"%@", str2);

        // ya da NSLog içinde doğrudan metot çağrılabilir
        NSLog(@"%@", [str1 substringToIndex:12]);

        //sonuc "bahcede 5 ta" olacaktır.
    }
    return 0;
}

substringWithRange:

Bu metot bir string dizesinde baştan itibaren belirtilen indeksten (belirtilen indeks dahil) belirtilen adet kadar olan kısmını döndürür. NSRange türünde bir parametre alır. Onu da NSMakeRange metoduyla substringWithRange metodumuza parametre olarak veriyoruz.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        NSString * str1 = @"bahcede 5 tane kedi var.";

        // 2. indeksten başla ve 2. dahil 10 karakter al
        NSString * str2 = [str1 substringWithRange:NSMakeRange(2, 10)];
        NSLog(@"%@", str2);

        // ya da NSLog içinde doğrudan metot çağrılabilir
        NSLog(@"%@", [str1 substringWithRange:NSMakeRange(2, 10)]);

        //sonuc "hcede 5 ta" olur.
    }
    return 0;
}

uppercaseString, lowercaseString, capitalizedString:

Bu metotlar kendisine verilen string dizesini tümü büyük harf, tümü küçük harf ya da sadece kelimelerin ilk harfleri büyük olacak biçimde döndürür:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        NSString * str1 = @"bAhcEDe 5 taNE kedi VAR.";

        NSLog(@"%@", [str1 uppercaseString]);
        // sonuc "BAHCEDE 5 TANE KEDI VAR."

        NSLog(@"%@", [str1 lowercaseString]);
        // sonuc "bahcede 5 tane kedi var."

        NSLog(@"%@", [str1 capitalizedString]);
        // sonuc "Bahcede 5 Tane Kedi Var."
    }
    return 0;
}

isEqualToString:

Bu metot iki string değerini karşılaştırarak aynı değere sahip olup olmadığını kontrol eder ve bool sonuç döndürür. Ayrıca bu metot büyük-küçük harfe duyarlıdır:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        NSString * str1 = @"bAhcEDe 5 taNE kedi VAR.";
        NSString * str2 = @"bAhcEDe 5 taNE kedi VAR.";
        NSLog(@"%i", [str1 isEqualToString:str2]);
        // sonuc "1" döner

        NSString * str3 = @"BAHCEDE 5 TANE KEDI VAR.";
        NSString * str4 = @"bahcede 5 tane kedi var.";
        NSLog(@"%i", [str3 isEqualToString:str4]);
        // sonuc "0" döner

        NSString * str5 = @"BAHCEDE 5 TANE KEDI VAR.";
        NSString * str6 = @"bahcede hic kedi yok.";
        NSLog(@"%i", [str5 isEqualToString:str6]);
        // sonuc "0" döner
    }
    return 0;
}

NSString dizesindeki rakamları dönüştürme:

Bu iş için intValue, floatValue, doubleValue gibi metotlar kullanılır. Örnekler:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {
        NSString * str1 = @"55";
        int sayi1 = [str1 intValue];
        NSLog(@"%i", sayi1);
        // sonuc "55" olur.

        NSString * str2 = @"55.21";
        float sayi2 = [str2 floatValue];
        NSLog(@"%f", sayi2);
        // sonuc "55.209999" olur.

        NSString * str3 = @"32547125746.25";
        double sayi3 = [str3 doubleValue];
        NSLog(@"%f", sayi3);
        // sonuc "32547125746.250000" olur.
    }
    return 0;
}

NSMutableString:

Tanımlama yöntemleri yine NSString’e benzer biçimdedir. Ek olarak NSString türünde olmayan metotları vardır.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        NSMutableString * str2 = [[NSMutableString alloc]initWithString:@"bahcede 7 tane kedi var."];
        NSLog(@"%@", str2);

        int adet = 8;
        NSMutableString * str3 = [[NSMutableString alloc]initWithFormat:@"bahcede %i tane kedi var.", adet];
        NSLog(@"%@", str3);
    }
    return 0;
}

NSMutableString sınıfına ait metotlardan bazıları:

setString:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        NSMutableString * str = [[NSMutableString alloc]init];

        [str setString:@"bahcede 6 tane kedi var."];
        NSLog(@"%@", str);
        // sonuc "bahcede 6 tane kedi var."
    }
    return 0;
}

appendString:

NSString’deki stringByAppendingString ile aynı görevi görür:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        NSMutableString * str2 = [[NSMutableString alloc]init];
        [str2 setString:@"bahcede 4 "];
        [str2 appendString:@"tane kedi var."];
        NSLog(@"%@", str2);
        // sonuc "bahcede 4 tane kedi var."
    }
    return 0;
}

appendFormat:

NSString’deki stringByAppendingFormat ile aynı görevi görür:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        NSMutableString * str1 = [[NSMutableString alloc]init];
        int adet = 9;
        [str1 appendFormat:@"bahcede %i tane kedi var.", adet];
        NSLog(@"%@", str1);
        // sonuc "bahcede 9 tane kedi var."
    }
    return 0;
}

replaceCharactersInRange:

NSString’de olmayan bu metot belli bir aralıktaki karakterleri bulup belirlenen karakterlerle değiştirmek içindir:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        // 0. indeksten başlayarak (0 da dahil) 7 karakteri
        // seç ve değiştir
        NSMutableString * str3 = [[NSMutableString alloc]init];
        [str3 setString:@"bahcede 10 tane kedi var"];
        [str3 replaceCharactersInRange:NSMakeRange(0, 7) withString:@"sokakta"];
        NSLog(@"%@", str3);
        // sonuc "sokakta 10 tane kedi var."
    }
    return 0;
}

Bunlara ek olarak NSString’de olan uppercaseString, lowercaseString, capitalizedString, isEqualToString, substringWithRange, substringToIndex, substringFromIndex metotları ve kullanımı burada da aynıdır. O nedenle örnek vermeye gerek duymadım.

Elbette bu sınıfların metotları bu kadarla sınırlı değil. Ben sadece en çok kullanılanları anlatmaya çalıştım.

Faydalı olması dileğiyle…

NSArray Örneği:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        // initWithObjects ile tanımlarken içerik ekliyoruz.
        NSArray * gunler = [[NSArray alloc] initWithObjects: @"pazartesi", @"sali", @"carsamba", @"persembe", nil];

        // NSArray türündeki diziye içerik ekleme
        gunler = [gunler arrayByAddingObject:@"cuma"];
        gunler = [gunler arrayByAddingObject:@"cumartesi"];
        gunler = [gunler arrayByAddingObject:@"pazar"];

        NSLog(@"%@", gunler);

        // ya da döngüyle içeriği okuyabiliriz
        for (NSString * gun in gunler) {
            NSLog(@"%@", gun);
        }

        // indeksi verilen elemanın değerini almak
        NSLog(@"%@", [gunler objectAtIndex:1]);
        // "sali" döner

        // değeri verilen elemanın indeksini almak
        NSLog(@"%lu", [gunler indexOfObject:@"carsamba"]);
        // "2" döner.

        // dizinin eleman sayısını almak
        NSLog(@"%lu", [gunler count]);
        // "7" döner.
    }
    return 0;
}

Dizinin tanımının sonundaki nil ifadesi dizinin son indeksinin bulunduğu konumu işaret eder ve initWithObjects ya da arrayWithObjects metotları ile oluşturulurken gereklidir. En sondaki @”%lu” ifadesi indexOfObject metodu NSUIntenger (unsigned long) türünde değer döndürdüğü içindir.

NSMutableArray Örneği:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{

    @autoreleasepool {

        // initWithObjects ile tanımlarken içerik ekliyoruz.
        NSMutableArray * aylar = [[NSMutableArray alloc] initWithObjects: @"ocak", @"subat", @"mart", @"nisan", nil];

        // diziye eleman ekleme
        [aylar addObject:@"mayis"];
        [aylar addObject:@"haziran"];
        [aylar addObject:@"temmuz"];
        [aylar addObject:@"agustos"];
        [aylar addObject:@"deneme"];
        [aylar addObject:@"eylul"];
        [aylar addObject:@"ekim"];
        [aylar addObject:@"kasim"];
        [aylar addObject:@"aralik"];

        NSLog(@"%@", aylar);

        // dizideki bir elemanın indeksiyle içeriğini değiştirme
        // "deneme" yi "yanilma" olarak değiştiriyoruz
        [aylar replaceObjectAtIndex:8 withObject:@"yanilma"];

        NSLog(@"%@", aylar);

        /*****************************************************/

        // dizideki bir elemanın değeriyle (object) içeriğini değiştirme
        // önce "yanilma" nın ideksini alıyoruz
        NSUInteger yanilmanin_indeksi = [aylar indexOfObject:@"yanilma"];

        // "yanilma" yı "degistirilmis" olarak değiştiriyoruz
        [aylar replaceObjectAtIndex:yanilmanin_indeksi withObject:@"degistirilmis"];

        NSLog(@"%@", aylar);

        /*****************************************************/

        // dizideki bir indekse eleman ekleme (insert)

        [aylar insertObject:@"araya eklenmis" atIndex:8];

        NSLog(@"%@", aylar);

        /*****************************************************/

        // dizideki bir elemanı silme

        [aylar removeObject:@"araya eklenmis"];
        [aylar removeObjectAtIndex:8]; // "degistirilmis" silinecek

        NSLog(@"%@", aylar);

        /*****************************************************/
        // dizinin eleman sayısını almak
        NSLog(@"%lu", [aylar count]);
        // "12" döner.
    }
    return 0;
}

Görüldüğü gibi NSMutableArray yapısı bize daha fazla hareket imkanı sağlıyor. O nedenle bu yapı Objective-C içindeki en ideal dizi yapısı. Elbette yapının tüm imkanları bu kadar değil. Burada sadece en temel olanlarından söz ettim.

Faydalı olması dileğiyle…

.my-class {
    color:#ff0000; /* Hex değer */
    color:red; /* renk adı */
    color:rgb(255, 0, 0);
}

Ancak bazen ASP.NET sayfalarımızda kod tarafında bu renk değerlerinin System.Drawing.Color türüne, ya da System.Drawing.Color türündeki bir rengin HTML ya da CSS içinde kullanmak üzere CSS renk adı, RGB ya da Hex biçimine ihtiyaç duyarız. İşte böyle durumlarda aşağıdaki System.Drawing namespace’i altındaki Color ve ColorTranslater sınıflarına ait metotlar işimizi oldukça kolaylaştıracaktır. Ancak projenize System.Drawing namespace’ini eklemeyi sakın unutmayın!

// ARGB değerleri verilmiş olan rengi HTML hex renk değerine dönüştürme
ColorTranslator.ToHtml(Color.FromArgb(255, 15, 65, 0));
// #ff0f41 döner

// RGB değerleri verilmiş olan rengi HTML hex renk değerine dönüştürme
ColorTranslator.ToHtml(Color.FromArgb(0, 85, 36));
// #005524 döner

// "System.Drawing.Color" türündeki rengi HTML hex renk değerine dönüştürme
String.Format("#{0:X2}{1:X2}{2:X2}", Color.Blue.R, Color.Blue.G, Color.Blue.B);
// #0000ff döner

// "#FF0000" şeklindeki Hex renk değerini "System.Drawing.Color" türüne dönüştürme.
ColorTranslator.FromHtml("#00ff00");
// "System.Drawing.Color.FromArgb(255, 0, 255, 0)" döner

// Ör: "Blue" şeklindeki HTML renk ismini "System.Drawing.Color" türüne dönüştürme.
ColorTranslator.FromHtml("Maroon");
// "System.Drawing.Color.Maroon" döner

Faydalı olması dileğiyle…

for döngüsü:

C türevi olan tüm programlama dillerinde en çok kullanılan döngü türüdür. Örnek:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{

    @autoreleasepool {

        // for (baslangic degeri; kosu; artma miktari)
        // i++ ifadesindeki ++, i'nin değerini döngünün her tekrarında 1 arttırır.
        for (int i = 0; i < 10; i++) { 

            // döngünün her tekrarında aşağıdaki kod bloğu çalışacak
            // %i ifadesi ile kaçıncı turda olduğunu da yazdırıyoruz
            NSLog(@"Dongunun %i. iterasyonu", i);
            // ekrana 10 kez yukarıdaki ifade yazılır.
        }
    }
    return 0;
}

Özellikle dizilerin elemanlarını for yardımıyla okuyabilir, değiştirebilir hatta silebiliriz. Dizileri ayrı bir yazımda anlatmayı düşündüğüm için bu yazıda sadece dizi elemanlarının değerlerini okuma örneğini vereceğim:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{

    @autoreleasepool {

        // 5 elemanlı bir dizi tanımladık
        int sayilar[5] = { 23, 85, 16, 47, 2 };

        for (int i = 0; i < 5; i++) {

            // ilk %i ifadesi ile döngünün kaçıncı turda olduğunu
            // 2. %i ifadesi ile dizinin i'inci elemanının değerini alıyoruz
            // NSLog içindeki "i, sayilar[i]" ifadesi sırasıyla

            NSLog(@"sayilar[%i] = %i", i, sayilar[i]);
            // ekrana dizinin tüm elemanlarının değeri yazdırılacak.
        }
    }
    return 0;
}

foreach döngüsü:

Bir diğer döngü türü ise foreach yapısıdır. Bu yapı daha çok dizilerdeki elemanların içeriğini okumak için kullanılır. Ancak bir dizinin elemanlarının içeriğini döngü ile değiştirmek istiyorsanız bunu for ile yapmak zorundasınız. Çünkü foreach yapısı her iterasyonda size dizinin o anki elemanını değil sadece o elemanın değerini verir. Bu yapı Objective-C'de diğer C türevi dillerin aksine foreach ile değil, yine for ile başlar.

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{

    @autoreleasepool {

        // NSArray sınıfıyla bir dizi tanımlama
        NSArray * sayilar = [[NSArray alloc] initWithObjects:@"23", @"85", @"16", @"47", @"2", nil];

        // diziye sonradan bir eleman daha ekliyoruz
        sayilar = [sayilar arrayByAddingObject:@"33"];

        // NSArray sınıfından dönen elemanlar "id" türündedir.
        for (id sayi in sayilar) {
            NSLog(@"%@", sayi);
            // ekrana dizinin tüm elemanlarının değeri sırayla yazdırılacak.
        }
    }
    return 0;
}

while döngüsü:

while döngüsü, belirtilen koşul sağlandığı sürece devam eden bir döngüdür. Örnek olarak aşağıdaki döngüde kullanıcıdan sürekli bir sayı girmesini istiyoruz. Ta ki '0' değerini girinceye kadar. Sonrasında da girdiği tüm değerlerin toplamını ekrana yazdırıyoruz:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{

    @autoreleasepool {

        int girilen_sayi, toplam;

        // kullanıcıdan bir sayı girmesini istiyoruz
        NSLog(@"Bir sayi giriniz:");

        // girilecek değer int türünde olduğundan
        // %i belirtiyoruz ve "girilen_sayi" değişkenine atıyoruz
        scanf("%i", &girilen_sayi);

        // sayı 0 değilse döngü içindeki kodlar çalışsın
        while (girilen_sayi != 0) {
            // her seferinde girilen sayı ile
            // önceki sayıların toplamını alıyoruz
            toplam += girilen_sayi;

            // yine bir sayı istiyoruz
            NSLog(@"Bir sayi giriniz:");
            scanf("%i", &girilen_sayi);

        }

        // insert code here...
        NSLog(@"Toplam: %i", toplam);

    }
    return 0;
}

Örnekteki while döngüsü içindeki toplam += girilen_sayi ifadesindeki +=, kendisinden önce gelen değere kendisinden sonra gelen değeri eklemeyi sağlıyor. Aynı ifade toplam = toplam + girilen_sayi biçiminde de yazılabilirdi. Ancak yukarıdaki yazım biçimi daha pratiktir. Hatta daha performanslı çalıştığını da duymuştum.

do while döngüsü:

Aslında do while yapısının while'dan tek bir farkı var. O da belirtilen koşul sağlansa da sağlanmasa da döngü baştan bir kez çalışır ve ondan sonraki iterasyonlarda koşulun sağlanıp sağlanmadığı kontrol edilir. Az önceki örneği do while kullanarak aşağıdaki biçimde de yazabiliriz.

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {

        int girilen_sayi, toplam;

        do {
            toplam += girilen_sayi;
            NSLog(@"Bir sayi giriniz:");
            scanf("%i", &girilen_sayi);
        } while (girilen_sayi != 0);

        NSLog(@"Toplam: %i", toplam);
    }
    return 0;
}

döngüde "continue" ve "break" kullanımı:

Yukarıda sözünü ettiğimiz tüm döngü yapıları içinde gerektiğinde continue ve break ifadeleri ile herhangi bir şart gerçekleştiğinde döngüden çıkmasını ya da devam etmesini sağlayabiliriz.

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{

    @autoreleasepool {

        for (int i = 0; i < 5; i++) {

            // i'nin değeri 2 olduğunda continue ifadesiyle
            // NSLog çalışmadan döngünün bir sonraki çevrimine geçecek
            if (i == 2) {
                continue;
            }

            NSLog(@"%i", i);
            // sonuç olarak ekranda 0 1 3 4 yazacak. 2 yok
            // çünkü 2 olduğunda continue ile
            // döngüyü bir sonraki çevrime geçirdik.
        }
    }
    return 0;
}

Görüldüğü gibi i'nin değeri 2 olduğunda continue ile döngü içindeki diğer satırlar çalışmadan döngüyü bir sonraki iterasyona geçiriyoruz. Bu nedenle de 2 hariç diğer tüm değerler ekrana yazdırılıyor. break ifadesi de yine aynı mantıkla çalışır ama bu ifade döngüyü sonlandırıp program akışını döngünün sonrasındaki satırlara yönlendirir:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{

    @autoreleasepool {

        for (int i = 0; i < 5; i++) {

            // i'nin değeri 2 olduğunda break ifadesiyle
            // döngü sonlandırılıp döngü dışına çıkılacak.
            if (i == 3) {
                break;
            }

            NSLog(@"%i", i);
            // sonuç olarak ekranda 0 1 2 yazacak.
            // çünkü i = 3 olduğunda break ile
            // döngüyü sonlandırıp program akışını
            // döngü dışına çıkarıyoruz.
        }
    }
    return 0;
}

Faydalı olması dileğiyle...

if – else – else if:

En çok kullanılan koşullu ifade türüdür. Aşağıdaki örnekte üç durumu da (if, else if, else) bir arada kullandım:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {
        int sayi1 = 10;
        int sayi2 = 15;

        // sayi1 sayi2'den buyuk ise
        if (sayi1 > sayi2) {
            NSLog(@"sayi1 sayi2'den buyuktur.");
        }

        // sayi1 sayi2'den kucuk ise
        else if (sayi1 < sayi2) {
            NSLog(@"sayi1 sayi2'den kucuktur.");
        }

        // sayi1 ve sayi2 esit ise.
        else {
            NSLog(@"sayi1 ve sayi2 eşittir.");
        }
    }
    return 0;
}

Yukarıdaki örnekte önce sayi1'in sayi2'den büyük olup olmadığı kontrol ediliyor. Eğer bu şart doğrulanırsa -ki örneğimizde doğrulanıyor- if ifadesinden sonra gelen küme parantezleri içindeki kodlar çalışıyor. Yani ekrana "sayi1 sayi2'den buyuktur." yazılıyor. Bu şart doğrulanamasaydı bir sonraki if bloğuna, yani else if ile başlayan kod bloğuna geçecekti. Birden fazla koşulu arka arkaya sorgulamak için ilk if ifademizden sonra gelen tüm ifadeler else if ile devam etmelidir. Sadece else kullandığımızda ise derleyiciye, o noktaya kadar sorgulanan koşullardan hiçbiri gerçekleşmez ise bu else bloğundaki kodlar çalışsın demiş oluruz. Yine örneğimize dönecek olursak eğer sayi1 ve sayi2 birbirine eşit olsaydı else bloğumuz çalışacaktı. Çünkü bu iki sayıdan biri diğerinden büyük değil ise geriye sadece eşit olma ihtimalleri kalmış demektir.

Koşullu ifadeler aşağıdaki gibi iç içe de kullanılabilir. Örneğimizi değiştiriyoruz ayrıca her değişkene de eşit değer atıyoruz:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {
        int sayi1 = 27;
        int sayi2 = 27;

        // sayi1 sayi2'den buyuk ise
        if (sayi1 > sayi2) {
            NSLog(@"sayi1 sayi2'den buyuktur.");
        }

        // sayi1 sayi2'den kucuk ise
        else if (sayi1 < sayi2) {
            NSLog(@"sayi1 sayi2'den kucuktur.");
        }

        // sayi1 ve sayi2 esit ise.
        else {
            NSLog(@"sayi1 ve sayi2 eşittir.");

            // sayinin ikiye bolumunden kalan 0 ise
            if (sayi1 % 2 == 0) {
                NSLog(@"%i çift sayidir", sayi1);
            }

            // sayinin ikiye bolumunden kalan 0 değil ise
            else {
                NSLog(@"%i tek sayidir", sayi1);
            }
        }

    }
    return 0;
}

Bu örnekte de sayi1 ve sayi2 eşit olduğu için else bloğu çalışacak ve o blokta da yeni bir if - else ile bu sayının tek mi, yoksa çift mi olduğu sorgulanıp sonuç ekrana yazdırılacaktır.

Örneğimiz içindeki sayi1 % 2 == 0 ifadesinde % operatörü matematiksel işlemlerde soldaki sayının sağındaki sayıya bölümünden kalan değeri verir. Burada bir sayının 2'ye bölümünden kalan 0 ise anlarız ki o çift sayıdır, değilse tek sayıdır.

Ayrıca bir if bloğunda birden fazla koşulu aynı anda sorgulayabiliriz. Bu durumda bizim aşağıdaki iki operatörden birine ya da koşula göre her ikisine birden ihtiyacımız olacaktır:
&& : "ve" operatörü
|| : "veya" operatörü

Örnek kullanımını görelim:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {
        int sayi1 = 27;
        int sayi2 = 15;

        // VE (&&) örneği (koşulun her ikisi de sağlanırsa if bloğu çalışır)
        // sayi1 sayi2'den buyuk ise ve(&&) sayi1 çift sayi ise
        if (sayi1 > sayi2 && sayi1 % 2 == 0) {
            NSLog(@"her iki kosul da saglandi");
        }

        // koşullardan herhangi biri ya da her ikisi de sağlanmazsa
        else {
            NSLog(@"iki kosul ayni anda saglanmadi");
        }

        // VEYA (||) örneği (iki koşuldan herhangi biri sağlanırsa if bloğu çalışır )
        // sayi1 sayi2'den kucuk ise veya(||) sayi1 çift sayi ise
        if (sayi1 < sayi2 || sayi1 % 2 == 0) {
            NSLog(@"iki kosuldan en az biri saglandi");
        }

        // koşulların her ikisi de sağlanmazsa
        else {
            NSLog(@"iki kosuldan hiç biri saglanmadi");
        }

    }
    return 0;
}

switch - case:

Diğer bir koşullu ifade türü de switch - case yapısıdır. Bu koşullu ifade türü de tıpkı if - else - else if mantığına benzer biçimde çalışmaktadır:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {
        int girilen_sayi;

        NSLog(@"Lutfen bir sayi giriniz:");
        scanf("%i", &girilen_sayi);

        switch (girilen_sayi % 2) {
            // girilen sayının 2'ye bölümünden kalan 0 ise
            case 0:
                NSLog(@"%i cift sayidir.", girilen_sayi);
                break; // bu kaldırılırsa çift sayı girilse bile alttaki case de sorgulanır.

            // girilen sayının 2'ye bölümünden kalan 0 değil ise
            case !0:
                NSLog(@"%i tek sayidir.", girilen_sayi);
                break;

            default:
                // yukarıdaki sonuçlardan hiç biri gerçekleşmezse
                // buraya yazacağınız kodlar çalışacaktır
                break;
        }
    }
    return 0;
}

switch ifadesinden hemen sonra parantez içindeki koşuldan dönen sonuç case ifadesi ile sorgulanıyor ve sonuç doğru ise hemen altındaki satırlar çalışıyor. Değil ise sonraki satırlar kontrol ediliyor. Eğer hiç bir case bulunamaz ise default ifadesinin altındaki kodlar çalıştırılıyor. break; ifadesi sonuç yakalandığında switch'ten çıkması içindir. Eğer break yazılmazsa sonuç yakalanmış olsa bile bir sonraki case de sorgulanır ve hem ilk yakaladığı case, hem de -eğer yakalarsa- diğer case(ler) de çalıştırılır.

Yukarıdaki örnekte case 0: altındaki break ifadesini kaldırıp, kodu çalıştırdığınızda ve bir çift sayı girdiğinizde, hem case 0: hem de case !0: 'ın çalıştığını görebilirsiniz.

conditional operatörü:

Bir koşuldan dönecek olan sonucun sonunda sadece iki işlemden birini yapmak istediğinizde bu operatörü kullanabilirsiniz. Kullanımı pek yaygın olmamakla birlikte benim çok sık ve severek kullandığım bir operatördür. Söz dizimi koşul ? "true" ise yapılacaklar : "false" ise yapılacaklar şeklindedir:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {
        int girilen_sayi;

        NSLog(@"Lutfen bir sayi giriniz:");
        scanf("%i", &girilen_sayi);

        girilen_sayi > 10 ? NSLog(@"%i, 10'dan buyuktur.", girilen_sayi) : NSLog(@"%i, 10'dan kucuktur.", girilen_sayi);
    }
    return 0;
}

Faydalı olması dileğiyle...

Aşağıdaki örnekte üç adet int türünde değişkenimiz var ve bu değişkenlerin ortalamasını alıyoruz. Ancak ortalaması alınmak istenen değerlerin türü integer olduğu için sonuç ondalıklı bir sayı olsa bile, int türü ondalıklı sayıları barındıramadığından sonuca yansıyacak olan noktadan sonraki haneleri de yok sayacaktır. Ancak bu değerleri bölmeden önce float’a dönüştürecek (casting) olursak sorun çözülecektir. İşte basit bir örnek:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {

        int s1 = 11, s2 = 10, s3 = 17;
        // sayıların toplamını parantez içine aldık ve
        // casting operatörü ile float'a dönüştürüyoruz.
        // sonuç: 38 / 3 = 12.66666666666667 olacaktır.
        NSLog(@"%f", (float)(s1 + s2 + s3) / 3);

        // eğer noktadan sonra sadece 2 hane görmek
        // istersek %.2f ifadesi ile yapabiliriz.
        // sonuç 12.66 olacaktır.
        NSLog(@"%.2f", (float)(s1 + s2 + s3) / 3);
    }
    return 0;
}

Ancak type casting yaparken çok dikkat edilmesi gereken bir nokta var. Özellikle float, double, int türleri birbirine dönüştürülürken mesela, bir double türü kendisinden çok daha küçük değer alabilen int türüne dönüştürülmek istendiğinde veri kaybı yaşanabilir ama bu durumda derleyici asla sizi uyarmaz. Çünkü yukarıda da bahsettiğim gibi bu tür dönüşümler explicit conversion, yani bilinçli tür dönüşümü olduğundan bir anlamda derleyici sizin bunun farkında olduğunuzu var sayar ve oluşacak veri kaybını dikkate almadan ve dönüşümü yapar.

Bunun için de bir örnek yapalım. Mesela bir signed int değişkenin alabileceği maksimum değer aralığı (32 bit bir uygulama için) −2147483648 ile 2147483647 arasıdır. Bir integer değişkene 2147483647′den daha büyük bir değere sahip bir double değişkeni casting yaparak atamaya çalıştığımızda bakalım neler oluyor:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {

        double s1 = 7463847417.25478951;
        int s2 = (int)s1;

        NSLog(@"%i", s2);
        // sonuç -2147483648 olacaktır.
        // ancak derleme ve çalışma sırasında
        // hata verilmeyecektir.
    }
    return 0;
}

Görüldüğü gibi sonuç -2147483648 dönüyor. Dikkat ettiyseniz bir int türünün alabileceği en düşük değeri döndürdü. Eğer double değişkenin değeri aşağıda örnekteki gibi −2147483648 ile 2147483647 arasında olsa idi tür dönüşümü esnasında veri kaybı oluşmayacaktı:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {

        double s1 = 254789517;
        int s2 = (int)s1;

        NSLog(@"%i", s2);
        // sonuç 254789517 olacaktır.
        // çünkü bu değer bir int türünün
        // tutabileceği aralıktadır.
    }
    return 0;
}

s1‘in değeri bir int türünün alabileceği aralığı aşmadığından dönüşüm sırasında veri kaybı olmadı ve sonuç 254789517 döndü.

Son olarak çok sık kullanma ihtiyacı duyacağımızı düşündüğüm bir dönüştürme biçimi de bir string veriyi (NSString) int tipine dönüştürmektir. Bunun için aşağıdaki kod bloğunda gördüğünüz NSString sınıfının intValue metodunu kullanmanız yeterli:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
    @autoreleasepool {

        NSString * str = @"254789517";
        int s2 = [str intValue];

        NSLog(@"%i", s2);
    }
    return 0;
}

Faydalı olması dileğiyle…

Objective-C veri türleri C ve türevi olan tüm dillerdeki (C, C++, C#) türler ile aynıdır. Sadece bu dile özel olarak “id” türü var ki ilerleyen satırlarda kısaca değineceğiz.

int veri türü:

Tam sayı (integer) veri tipidir. 32 bit bir uygulamada işaretsiz (unsigned – negatif değer almayan) int türünün maksimum aralığı 0 ile 4294967295 arasında olup 64 bit sistemlerde bu aralık 0 ile 18,446,744,073,709,551,615 arasında olacaktır. 32 bit uygulamalar için işaretli (signed – negatif değer alabilen) int değişkenler −2,147,483,648 ile +2,147,483,647 arasında değer (4 bytes) alabilir. Ancak bu aralık 64 bit uygulamalarda −9,223,372,036,854,775,808 ile +9,223,372,036,854,775,807 (8 bytes) olur. Tanımlama ve değer atama biçimleri aşağıdaki gibidir:

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        int a = 10;

        // ilk tanımlamadan sonra bir değer atanmaz ise
        // 'int' tipindeki değişkenin değeri varsayılan olarak '0' atanır.
        int b;
        b = 20;

        int c, d, e;
        c = 1;
        d = 2;
        e = 3;

        int f = 15, g = 20;

        // ya da hexadecimal (16'lı sayı sistemi) değer de atanabilir
        int hex_sample = 0xFFA2;
        NSLog(@"%i", hex_sample);
        // ekran çıktısı 65442 olacaktır.
    }
    return 0;
}

float veri türü:

Noktalı (ondalık) sayı tipidir. Tanımlama ve değer atama biçimleri yine int‘de olduğu gibidir. Ancak noktalı, ya da noktasız sayılar alabilir. Bellekte 4 byte (32 bit) yer kaplar:

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        float a = 10.21;

        // ilk tanımlamadan sonra bir değer atanmaz ise
        // 'float' tipindeki değişkenin değeri varsayılan olarak '0.000000' atanır.
        float b;
        b = 25;

        float c, d, e;
        c = 1.47;
        d = 26.8f;
        e = 3;

        float my_float = 15.896547, g = 20.63f;

        // aşağıdaki ifadedeki .2f 'my_float' değişkeninden gelen değerde
        // noktadan sonraki ilk 2 hanesini almasını sağlar.
        NSLog(@"%.2f", my_float);
        // Ekran çıktısı 15.89 olacaktır.

        // bir değerin 10 üzeri 'x' kuvvetini de alabiliriz.
        float fx = 54.78e4; // 54.78'in 10 üzeri 4 kuvvetini döndürür.
        NSLog(@"%f", fx);
        // Ekran çıktısı 547800.000000 olacaktır.
    }
    return 0;
}

double veri türü:

Float veri tipinin tutabileceği değerden daha büyük değerleri tutmak için kullanılır. Float veri tipine değer atanırken değerin sonuna ‘f’ ifadesi geitirilmediği sürece bu değer bellekte double olarak tutulur. Bellekte 8 byte (64 bit) yer kaplar. float’ın yaklaşık 2 katı büyüklüğündeki değerleri saklayabilir.

double my_double_var = 2547896514;
double _var = 0.524122652132234093890324318;

char veri türü:

Harf, rakam, noktalama işareti veya boşluk karakteri gibi tek bir karakter saklamak için kullanılır. Bellekte 1 byte (8 bit) yer kaplar.

char chr_letter = 'b';
char chr_digit = '6';
char char_punctuation_mark = ';';

char veri türünde bazı özel karakterler/kaçış karakterleri (special characters/escape characters) vardır. Bu karakterler ters eğik çizgi “\” ile başlar ve derleyici tarafından karakter olarak değil, yapılması gereken bir işlem olarak algılanırlar. Bu özel karakterlerden bazılarının listesi ve işlevleri aşağıdadır:

\n – Yeni satır
\r – Satır başı
\t – Yatay sekme
\v – Dikey sekme
\\ – Ters eğik çizgi
\” – Çift tırnak (bir string veri içinde çift tırnak işareti bu şekilde kullanılmak zorundadır)

Örnekler:

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        NSLog(@"\nbu ilk satır\nbu da 2. satır ve bu satırda ters eğik çizgi (\\) kullandım.");
        // çıktısı aşağıdaki gibi olur:
        /*
         bu ilk satır
         bu da 2. satır ve bu satırda ters eğik çizgi (\) kullandım.
         */

        NSLog(@"\rilk kelime.\t\t2 kere tab yapıldıktan sonrası. ve bu satırda çift tırnak (\") kullandım.");
        // çıktısı aşağıdaki gibi olur:
        // ilk kelime.		2 kere tab yapıldıktan sonrası. ve bu satırda çift tırnak (") kullandım. (aradaki boşluğa dikkat)
    }
    return 0;
}

bool veri türü:

“0″ veya “1″, “true” veya “false”, “YES” veya “NO” değerlerinden birini alabilen bir türdür. Genellikle bir koşuldan dönen sonucu tutmak için kullanılır. Aşağıdaki biçimlerde tanımlanabilir:

int main (int argc, const char * argv[])
{
    @autoreleasepool {

        bool b1 = NO;
        Boolean b2 = 1;
        _Bool b3 = true;
        BOOL b4 = 0;

        NSLog(@"%i, %i, %i, %i", b1, b2, b3, b4);
        // ekran çıktısı 0, 1, 1, 0 olur.
    }
    return 0;
}

id veri türü:

Tipi ne olursa olsun, herhangi bir nesnenin referansını tutmak için kullanılabilecek genel amaçlı (generic) bir veri türüdür.

Objective-C veri türü niteleyicileri:

long:

Bir veri türünün değer aralığını genişletmek için kullanılır. int ve double türleri için kullanılabilir.

long int large_int;
long double large_double;

long long:

Bir long veri türünü “extra” long yapmak için kullanılır.

long long int extra_large_int;

short:

Bir int veri türünü 32 bit’den 16 bit’e düşürerek alabileceği değer aralığını −32,768 ile +32,767 arasında sınırlar.

short int small_int;

signed & unsigned:

int veri tipi tanımlandığında varsayılan olarak işaretli (signed) ‘dir. Dolayısıyla negatif değer de alabilir. Ancak unsigned olarak tanımlandığında artık negatif değer alamaz ve değer aralığı −2,147,483,648 ile +2,147,483,647 iken, 0 ile +4,294,967,295 arasında olur ve sadece pozitif değer alabilir hale gelir.

unsigned int uns_int;
// niteleyiciler bu örnekte olduğu gibi
// kombine olarak da kullanılabilirler.
unsigned short int uns_small_int = 10;

Ayrıca bir int ile unsigned, signed, short ve long kullanımında int ifadesini kullanmadan da tanımlama yapılabilir. Aşağıdaki tanımlama biçimleri geçerlidir:

unsigned val1;
signed val2;
short val3;
long val4;

Aşağıda veri türlerini tablo halinde görebilirsiniz.

Aşağıdaki kod örneğinde de görüldüğü gibi bir DetailsView kontrolünün DataBound olayında önce DetailsView kontrolünün modu sorgulanıp (CurrentMode) arkasından erişmek istediğimiz kontrole ID’si ile DetailsView sınıfının FindControl metoduyla erişebiliriz. Elbette aradığımız kontrolün tipine cast etmeyi unutmadan…

protected void DetailsView1_DataBound(object sender, EventArgs e)
{
    // Düzenleme (Edit) modunda iken erişim
    if (DetailsView1.CurrentMode == DetailsViewMode.Edit)
    {
        // YourControlType: DropDwonList, ListBox, TextBox vb.
        var control = (YourControlType)DetailsView1.FindControl("YourControlID");
    }

    // Okuma (ReadOnly) modunda iken erişim
    else if (DetailsView1.CurrentMode == DetailsViewMode.ReadOnly)
    {
        var control = (YourControlType)DetailsView1.FindControl("YourControlID");
    }

    // Yeni veri girme (Insert) modunda iken erişim
    else if (DetailsView1.CurrentMode == DetailsViewMode.Insert)
    {
        var control = (YourControlType)DetailsView1.FindControl("YourControlID");
    }
}