C Sharp Programlama Dili/Arayüzler

Ders 21. Arayüzler

İsterseniz şimdi geçen bölümün son konularını biraz hatırlayalım. Geçen bölümde sanal metot ve sanal sahte özellikleri görmüştük. Bu sayede bir nesnenin kendi türüyle değil, gizli türüyle işlem yapılmasını sağlamıştık. Geçen bölümde gördüğümüz diğer önemli şey ise özet metot ve özet sahte özelliklerdi. Özet metot ve özet sahte özellikler ana sınıf içinde bildiriliyordu, içerikleri yoktu ve bu sınıflardan türeyen sınıflar da bu metot ve sahte özellikleri içermek zorundaydı. Yani diğer bir deyişle ana sınıftaki özet üye elemanlar yavru sınıflara şunları diyordu: "Bizi içermek zorundasınız, ancak içeriğimizi kendiniz yazacaksınız". Yani özet üye elemanları kılavuza benzetebiliriz. Kılavuz bir işin nasıl yapılacağını ana hatlarıyla anlatır, ancak bu işi asıl yapan kılavuzu okuyan kişidir. Şimdi öyle bir sınıf düşünün ki sadece özet üye elemanlardan oluşsun. Yani bu sınıfın işlevsel olarak hiçbir faydası yok. Sadece kendinden türeyen sınıflara kılavuzluk yapıyor. İşte, arayüzlere sınıfların sadece özet üye eleman içerebilenleri diyebiliriz.

Arayüz bildirimi

Arayüzler interface anahtar sözcüğüyle bildirilir.
Bir arayüzde özellik, metot, indeksleyici, temsilci ve olay bildirilebilir. Temsilci ve olayları ileride göreceğiz.
Arayüz isimleri geleneksel olarak I harfi ile başlar, ancak zorunlu değildir.
Arayüz elemanlarını static olarak bildiremeyiz.
Arayüz elemanları içsel olarak zaten publictir. Tekrar bir erişim belirleyici kullanmak hatalıdır.
Arayüzler sahte olmayan özellik içeremez.
Arayüzlerde yapıcı ve yıkıcı metot olmaz.

Şimdi iki metodu, bir sahte özelliği ve bir indeksleyicisi olan bir arayüz yazalım:

 interface IArayuz
 {
    int Metot1();
    int Metot2();
    int sahteozellik
    {
       set;
       get;
    }
    int this[int indeks]
    {
       get;
    }
 }

Bu arayüzde parmak basmamız gereken önemli bir nokta var. Bu arayüzü kullanan sınıftaki indeksleyicinin sadece get bloğu olabilir veya hem get hem de set bloğu olabilir. Yani indesleyicilerdeki durum sahte özelliklerden biraz farklıdır. Arayüzü kullanan sınıftaki indeksleyici en az arayüzdeki set-get durumuna sahip olmalıdır.

Arayüzlerin uygulanması

Arayüzlerin uygulanması sınıf türetmeyle aynı şekilde yapılır. Örnek:

 class A:IArayuz
 {
    //IArayuz arayüzündeki bütün elemanları içermeli.
 }

Bir sınıf birden fazla arayüzü kullanabilir. (Bu sınıf türetmede yoktu). Örnek:

 class A:Arayuz1,Arayuz2
 {
    //Hem Arayuz1 hem de Arayuz2 arayüzündeki bütün elemanları içermeli.
 }

Tabii ki arayüzü kullanan sınıfta sadece arayüzdeki elemanlar bulunur diye bir kural yoktur.
Arayüzler de sınıf türetmeyle aynı şekilde birbirlerinden türetilebilir. Bu durumda yavru arayüz ana arayüzün taşıdığı bütün elemanları taşır.
Sınıflardan farklı olarak arayüzleri birden fazla arayüzden türetebiliriz. Örnek:

 interface Arayuz1
 {
    int Metot1();
 }
 interface Arayuz2
 {
    string Metot2();
 }
 interface Arayuz3:Arayuz1,Arayuz2
 {
    double Metot4();
 }

Burada Arayuz3'ü kullanan bir sınıf her üç metodu da içermelidir.

Tıpkı sınıflardaki gibi new anahtar sözcüğünü kullanarak isim gizleme yapabiliriz. Örnek:

 interface Arayuz1
 {
    int Metot1();
 }
 interface Arayuz2:Arayuz1
 {
    new int Metot1();
 }

Burada aklınıza şöyle bir sorunun gelmesi doğaldır: Arayuz2'yi kullanan bir sınıfta Metot1()'in bildirimi yapıldığında geçerli bir bildirim olur mu? Bunun cevabı hayırdır. Arayuz2'nin Arayuz1'e ait metodu gizlemesi sonucu değiştirmez. Bu sorunu halletmek için sınıfımızı şöyle yazabiliriz.

 class deneme:Arayuz2
 {
    int Arayuz1.Metot1()
    {
       ...
    }
    int Arayuz2.Metot1()
    {
       ...
    }
 }

Burada hem Arayuz1'in hem de Arayuz2'nin isteklerini yerine getirdik. Bu tür arayüz uygulamaya "açık arayüz uygulama" denir. Açık arayüz uygulamanın detayları birazdan verilecektir.

Arayüz nesneleri

Kulağa biraz itici gelse de bir arayüz türünden nesne oluşturulabilir. Arayüz nesneleriyle ilgili bilmeniz gereken en önemli şey şudur:
Tıpkı türetmedeki gibi bir arayüz nesnesine o arayüzü kullanan sınıf türünden nesne atanabilir. Bu durumda o arayüz nesnesinin gizli türü o sınıf olur ve o sınıfa ait üye elemana arayüz nesnesi üzerinden erişilebilir. Örnek:

 using System;
 interface arayuz
 {
    int Metot();
 }
 class A:arayuz
 {
    public int Metot()
    {return 0;}
    static void Main()
    {
       arayuz a;
       A s=new A();
       a=s;
       Console.WriteLine(a.Metot());
    }
 }

Gördüğünüz gibi arayüz nesneleri oluştururken new anahtar sözcüğünü kullanmıyoruz.
NOT: Herhangi bir arayüzdeki üye elemanlar sınıfa public, static değil, doğru geri dönüş tipinde ve doğru parametrelerle geçirilmelidir.

Açık arayüz uygulama

C# dilinde var olan arayüzleri uygulamanın bir yolu daha vardır. Buna açık arayüz uygulama denir. Bunun avantajları şunlardır:

Açık arayüz uygulama yöntemiyle sınıfa ait bazı üye elemanlara sınıf dışından erişim sınıf nesnelerine kapatılırken, aynı üye elemanlara sınıf dışından arayüz nesnesiyle erişim mümkün kılınabilir.
Bir sınıfa birden fazla arayüz uygulandığında eğer arayüzlerde aynı isimli üye elemanlar varsa isim çakışmasının önüne geçebiliriz. Örnek program:

 using System;
 interface arayuz
 {
    void Metot();
 }
 class sinif:arayuz
 {
    void arayuz.Metot()
    {
       Console.WriteLine("Deneme");
    }
 }
 class mainMetodu
 {
    static void Main()
    {
       sinif nesne=new sinif();
       ((arayuz)nesne).Metot();
    }
 }

Burada sinif türünden olan nesne arayuz türüne dönüştürüldü ve arayuz nesnesiyle Metot() metoduna erişildi. Direkt nesne üzerinden erişilemezdi. Aynı programı şöyle de yazabilirdik:

 using System;
 interface arayuz
 {
    void Metot();
 }
 class sinif:arayuz
 {
    void arayuz.Metot()
    {
       Console.WriteLine("Deneme");
    }
 }
 class mainMetodu
 {
    static void Main()
    {
       arayuz nesne=new sinif();
       nesne.Metot();
    }
 }

Açık arayüz uygulamada üye elemanlar public olarak belirtilemez. Dolayısıyla açık olarak uygulanan üye elemanlara o sınıf dışından erişilemez, sadece arayüz nesnesi üzerinden erişilebilir.

NOT: Yapılar da arayüz kullanabilir.

NOT: Sınıflar ve yapılar aynı anda hem bir sınıftan türeyebilirler hem de bir veya daha fazla arayüz kullanabilirler. Bu durumda sınıf ve arayüz(ler) virgüller ayrılır. Sınıf isminin ilk önce gelmesi gerekir.

Bu kitabın diğer sayfaları