Arayüz (Interface) Referansları (c#)

Arayüzler ile referans oluşturulabilir. Bir arayüz referansı tek başına bir anlam ifade etmez. Ancak arayüz
referanslarına kendisini uygulayan herhangi bir sınıf nesnesinin referansı atanabilir. Bu durumda arayüz
referansı ile arayüzde bulunan metot ya da özellikler hangi sınıf referansı tutuluyorsa o sınıf türünden bir
nesne için çağırılabilir.
Bu özelliğine örnek vermek gerekirse aşağıda ArayuzRef arayüzünü uygulayan iki sınıfın bildirimini görüyoruz.
Main() metodu içinde ise ArayuzRef referansına bu iki sınıfın nesne referanslarının nasıl aktarıldığını ve bu
referans üzerinden sınıflardaki metotların nasıl çağrıldığını görüyoruz.

using system;

interface ArayuzRef
{
  void metot1();
}

class Sinif1 : ArayuzRef
{
  puplic void metot1(){
  Console.WriteLine("Ben Sinif1'in metoduyum");
  }
}

class Sinif2 : ArayuzRef
{
  puplic void metot1(){
  Console.WriteLine("Ben Sinif2'nin metoduyum");
}

puplic class MainMetodu
{
  puplic static void Main()
  {
    ArayuzRef a;

Sinif1 sinif1 = new Sinif1();
Sinif2 sinif2 = new Sinif2();

a = sinif1;
a.metot1();

a = sinif2;
a.metot1();
   }
}

Programı derleyip çalıştırdığımızda ekrana

Ben Sinif1'in metoduyum
Ben Sinif2'nin metoduyum

yazacaktır. Arayüzlerdeki referans aktarma işlemi ile kalıtımda gördüğümüz temel sınıf referansına türeyen sınıf referansı aktarma işlemi ile aynıdır.

Arayüzlerin (Interface) Uygulanması (c#)

 Şimdi bir sınıfın belirlediğimiz bir arayüzün nasıl uygulandığını inceleyeceğiz.
Arayüzlerin uygulanması, sınıfların türetilmesi ile aynı şekilde yapılır. Arayüz uygulamada, arayüzler türetmedeki temel sınıf yerine geçer. Buna göre IArayüz'ü uygulayan Sayılar sınıfı aşağıdaki gibi bildirilir.

class Sayılar : Iarayuz
{
  //uygulanacak elemanlar
}

Sayılar sınıfı bu şekilde IArayuz'den türetildiğinde IArayuz'deki bütün üye elemanları uygulanmalıdır.

Buna göre Sayılar sınıfı IArayuz'ü ile aşağıdaki gibi bildirilebilir.

interface IArayuz
{
 int BirSonraki();
 void Sıfırla();

 int Deger
 {
  get;
  set;
 }

 int this [this indeks]
 {
 get;
 }
}

class Sayılar : IArayuz
{
 puplic int BirSonraki()
 {
   //metot gövdesi
 }

puplic void Sıfırla()
{
  //metot gövdesi
}

puplic int Deger
{
get
{
  //get bloğu
}

set
{
 //set bloğu
}
}

puplic int this[this indeks]
{
get
{
  //get bloğu
}

set
{
 //set bloğu
}
}
}

 Sınıflar arasında çok türetme olmamasına rağmen sınıflar birden fazla arayüzüde uygulayabilir. Uygulanacak
arayüzler virgül ile belirtilir. Örneğin IDisposable ve System.Collecitons isim alanında bulunan IEnumarable
yüzünü uygulayan sayılar sınıfı aşağıdaki gibi bildirilebilir.

using System;
using System.collections;

class Deneme : IDisposable, IEnumerable
{
  //Sınıf elemanları
}

Bir arayüzdeki elemanlar içsel olarak puplic olduğu için arayüzü uygulayan sınıfın arayüzdeki elemanları puplic
olarak bildirilmemelidir.

Bir arayüzü uygulayan sınıfın, sadece arayüzdeki elemanlara sahip olabileceği anlamına gelmez. Aynen türetmede
olduğu gibi arayüzdeki elemanların dışında istenildiği kadar yeni eleman eklenebilir.

Sınıflar birbirlerinden nasıl türetilebiliyorsa Arayüzler de birbirlerinden türetilebilir. Temel arayüzdeki bütün
elemanlar türeyen arayüze aktarılır. Böylece istediğimiz kadar eski arayüzü kullanarak daha geniş arayüzleri
oluşturabiliriz. Aşağıda iki arayüzün türetilmesine ilişkin bir örnek verilmiştir.

interface TemelArayuz
{
 void Metot1();
}

interface TureyenArayuz : TemelArayuz
{
  void Metot2();
}

Arayüzden yeni bir Arayüz türetildiğinde dikkat edilmesi gereken hususlar:

Bu kullanım ile TemelArayuz'ü uygulayan bir sınıf sadece Metot1'i uygulamalı iken TureyenArayuz'ü uygulayan bir
sınıf hem Metot1() hem de Metot2()'yi uygulamalıdır. Aksi halde derleme hatası alınır. Sınıflardan farklı olarak
arayüzleri birden fazla arayüz ile türetebiliriz. Örneğin aşağıdaki Arayuz3 bildirimi tamamen geçerlidir.

interface Arayuz1
{
  void Metot1();
}

interface Arayuz2
{
  void Metot2();
}

interface Arayuz3: Arayuz1, Arayuz1
{  void Metot3();
}

Arayüzleri türetirken new anahtar sözcüğü kullanılarak temel arayüzdeki bir eleman gizlenebilir. Bu şekilde
türeyen arayüzde temel arayüzdeki bir elemanla aynı isimli eleman bildirilebilir.

interface Arayuz1
{
  void Metot1();
}
interface Arayuz2 : Arayuz1
{
 new void metot1();
}

Peki bu durumda sadece Arayuz2'yi uyguluyan bir sınıfta Metot1() metodu uygululandığında geçerli bir bildirim olur mu?
 Hayır, çünkü Arayüz1'deki Metot1() metodu gizlenmiş olsa da kalıtım yolu ile Arayuz2'ye aktarılmıştır. Bu yüzden Arayuz2'yi uygulayan bir sınıf hem Arayuz1.Metot1() hem de Arayuz2.metot1() metodunu uygulamak zorundandır. Bunun için Arayuz_adı.Metot_adı ile hangi arayüzdeki metodu uyguladığımızı bildirmeliyiz. Örneğin;

class Deneme: Arayuz2
{
  void Arayuz1.Metot1();
  {
  }

  void Arayuz2.Metot1();
  {
  }
}

Deneme sınıfından bir nesne üzerinden Metot1() metoduna erişmemiz mümkün değildir, çünkü

deneme d= new deneme();
d.Metot1();

deyimiyle hangi arayüze ilişkin metodun çağrıldığı belirsizdir. Bu yüzden yukarıdaki gibi bir kullanım hatalıdır.

O halde Arayuz1.Metot1() ve Arayuz2.Metot1() metotları sadece Deneme sınıfında aşağıdaki gibi tam yolu
belirtilerek kullanılabilir.

void Arayuz2.Metot1()
{
   Arayuz1.Metot1();
}

Arayüzler (Interface) (c#)

Özet metotlar ile bir özet metodun bulunduğu sınıftan türeyen bir sınıfın mutlaka bu özet metodu devre dışı bırakıp kendine göre uygulaması gerekirdi. Burada amaç aslında bir sınıfın neye benzediğini tespit etmekti. Özet metotlar sayesinde biliyoruz ki bir önceki temel sınıftan türeyen tüm sınıflarda özet metot uygulanmıştır. Bu da tek bir arayüzle birçok iş yapabileceğimiz anlamına gelir. Yani özet sınıfının bir kısım elemanları kendisinden türeyecek sınıflara arayüz niteliği taşımaktadır. Ayrı bir veri türü olan Interface ise tamamen diğer sınıflar için arayüz görevini taşır. Arayüzlerin bütün metotları ve özelliklerinin özet olarak bildirilmiş sınıflardan çok fazla farkı yoktur. Dolayısıyla arayüzlerdeki metotların ve özelliklerin gövdesi yazılamaz. Kısaca arayüzler, kendisini uygulayan sınıfların kesin olarak içerceği özellikleri ve metotları belirler.

 Arayüzler kişisel uygulamalarda pek fazla kullanılmaz ancak özellikle birkaç firmanın ya da programcının üzerinde çalıştığı projelerde ortak bir zemin oluşturabilmek için arayüzlerden faydalanılır.

Arayüz bildirimi:

Arayüzler, interface anahtar sözcüğü kullanılarak bildirilir. Bir arayüzde özellik, indeksleyici, metot, temsilci ve olay bildirimi yapılabilir. Arayüz isimleri geleneksel olarak I harfi ile başlar.

Arayüz bildirimi ile ilgili çeşitli kısıtlamalar vardır.

*Arayüzdeki elemanları statik olarak bildiremeyiz.
*Arayüzdeki eleman bildirimleri içsel olarak puplic oldukları için ayrıca bir elemanı erişim belirleyici ile bildirmek yanlıştır.
*Arayüzler herhangi bir üye değişken içeremez.
*Arayüzlerde yapıcı ve yıkıcı metotlar tanımlanamaz ya da bildirilemez.

Aşağıda iki metot, bir özellik ve bir indeksleyici bildirimi içeren arayüz tasarlayalım.

interface IArayuz
{
  int BirSonraki();
  void Sıfırla();
 
  int Deger
  {
   get;
   set;
  }
 
  int this[int indeks]
  {
  get;
  }
}

Bu arayüzü uygulayan bir sınıfta Arayüzde bulunan bütün elemanların uygulanması gerekir. Deger özelliğinin hem get hem de set blokları olmasına karşın indeksleyicinin sadece get bloğu vardır. Buna rağmen bu arayüzü uygulayacak sınıfta bildirilen indeksleyicinin hem get hem de set bloğu ya da sadece get bloğu olabilir, fakat sadece set bloğu olamaz.

Arayüzlerdeki hatalı kullanımları inceleyelim.

*Asağıdaki Arayüz bildiriminde metot puplic erişim belirleyicisi ile bildirildiği için geçersizdir.

  interface IArayuz
  {
    puplic void Metot();
  }


*Aşağıdaki Arayüz bildiriminde statik metot bildirimi yapıldığı için geçersizdir.

  interface IArayuz
  {
    static void Metot();
  }

 
*Aşağıdaki arayüz bildiriminde ise üye değişkenin bildirilmesi arayüzü geçersiz kılmıştır.

  interface IArayuz
  {
    int a;

    void Metot();

int Ozellik
{
get;
}
  }