using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace ConsoleApplication22
{
class Program
{
static void Main(string[] args)
{
//ArrayList sepet=new ArrayList(); //object türünden bir kolleksiyon
List<Urun> sepet = new List<Urun>(); //Urun turunde generic bir collection olan List i kullandık.
Urun kalem = new Urun();
Urun silgi = new Urun();
Urun defter = new Urun();
Urun kitap = new Urun();
kalem.Ad = "çıtçıt"; kalem.Fiyat = 12.55M; kalem.adet = 5;
silgi.Ad = "kokulu"; silgi.Fiyat = 15.2M; silgi.adet = 10;
defter.Ad= "çizgili"; defter.Fiyat = 9.54M;
kitap.Ad = "Roman"; kitap.Fiyat = 25.99M;
sepet.Add(kalem); sepet.Add(silgi); sepet.Add(defter); sepet.Add(kitap);
Console.WriteLine("Urun Adı:\tUrun Fiyat:\tUrun Adet:\t Kdvli Fiyat\tUrunSeriNo:\t\t");
Console.WriteLine("--------\t--------\t-------\t\t------\t\t-----\t\t");
foreach (Urun item in sepet)
{
//Urun urunum = (Urun)item;//List türünde kolleksiyon kulladığımız için Unboxing işlemine gerek kalmadı.
Console.WriteLine("{0}\t\t {1}\t {2}\t {3}\t {4}\t", item.Ad, item.Fiyat, item.adet, item.KdvHesapla().ToString(), item.SeriNo);
}
}
interface IUrun
{
string Ad { get; set; }
decimal Fiyat { get; set; }
decimal KdvHesapla();
}
class Urun : IUrun
{
Guid seriNo;
public Guid SeriNo
{
get { return seriNo; }//kimsenin değiştirmesin diye sadece okunur özellik yaptık.
}
public Urun()
{
seriNo = Guid.NewGuid();
}
string _ad;
public int adet = 1;
public string Ad
{
get
{
return _ad;
}
set
{
_ad = value;
}
}
decimal _fiyat;
public decimal Fiyat
{
get
{
return _fiyat;
}
set
{
_fiyat = value;
}
}
public decimal KdvHesapla()
{
return _fiyat * 1.18M*adet;
}
}
enum Renkler
{
Mavi,Kırmızı,Yeşil,Siyah,Gri,Turuncu,Mor,Beyaz
}
}
}
Ben bazı arabirim özelliklerini yine tekrar etmek istiyorum.
1) Arabirimler bir classa standart getirirler.
2) Arabirimlerde sadece üyeler tanımlanır, açıklayıcı kod yazılmaz.
3) Arabirimler üyeleri(method, özellik, indexleyici, ve olay) doğası gereği publictirler.
4) Bir sınıf birde fazla arabirimden kalıtım alabilir..
5) açık ve kapalı şekilde implement edilebilir.
Senaryomuza göre canli sınıfı yapalım, bu sınıfı güncelhayatdan bir örnek vereceğimiz için, tıpkı melekler gibi soyut(absract) sınıf olsun ve new deyimi ile nesnesini oluşturma imkanı olmasın.. Yas özelliği yazalım ve yasamayaDevamEt() yöntemi yapalım.. ve canli sınıfı yaşamaya devam etsin..:)
abstract class Canli
{
public int yas { get; set; }
void yasamayaDevamEt()
{
Console.WriteLine("Dünya çok güzel");
}
}
Daha sonra IUcar ve IGazer isimli iki tane arabirim yazalım. Burada dikkat edeceğimiz konu Uc() yöntemi her iki arabirimde tanımlanmış. Sizler daha önceki yazımda belirtiğim gibi açık ve kapalı olarak interface implement edebilirisiniz.
interface IUcar
{
void Uc();
int kanatSayisi { get; set; }
}
interface IGezer
{
void Uc();
void Gez();
int Hiz { get; set; }
}
c# yorumlayıcısına(compiler) yazacağımız ve kullanacağımız Uc yonteminin hangi Arabirimin yöntemi olduğunu anlatmamız gerekir. Bizler boyle bir durumda kaplaı şekilde belirtmek yerine ;
public void Uc()
{
Console.WriteLine("kanatla ucuyorum");
}
Bu arabirimin(explicitly) yontemini açık bir şekilde belirtmemiz gerekir.
void IUcar.Uc()
{
Console.WriteLine("kanatla ucuyorum");
}
diğer arabirim için
void IGezerr.Uc()
{
Console.WriteLine("Jet motorla ucuyorum");
}
artık Insan sınıfımızın kalıtım aldığı arabirimin üyelerinin zorunlu olarak implement edelim ve gerekli kodları yazalım.
class Insan : Canli, IUcar,IGezer
{
void IUcar.Uc()
{
Console.WriteLine("kanatla ucuyorum");
}
void IGezer.Uc()
{
Console.WriteLine("Jet motorla ucuyorum");
}
int _kanatsayisi;
public int kanatSayisi
{
get
{
return _kanatsayisi;
}
set
{
_kanatsayisi=value;
}
}
public void Gez()
{
Console.WriteLine("Dünya da ne yerler varmış ve gezmekle bitmiyor");
}
int _hiz;
public int Hiz
{
get
{
return _hiz;
}
set
{
_hiz=value;
}
}
}
Burada _hiz ve _kanatsayisi diye iki özel bir alan kullandım.
Şimdi gelelim bunları kullanacak kod yazmaya. burada Insan sınıfının bir örneği(nesnesi) olan ercepin kanatsayisi özelliği hem okunur hemde yazılabilir bir özelliktir. ercep. yazarak ben bu üyeleri erişebilirim. Fakat Uc() yöntemi için derleyiciye ben hangi Uc() yöntemini kullanacağımı anlatmam gerekir. Burada cast işlemi(kesme) imdadımıza yetişiyor. Ben sizin öğrenmeniz için Uc() yontemini iki farklı yazım metoduyla yazdım.
class Program
{
static void Main(string[] args)
{
Insan ercep = new Insan();
// ercep.Uc(); //bu şekilde kullanamayız.
ercep.kanatSayisi = 2;//property set yapılıyor.
IUcar iucar = (IUcar)ercep; // cast-kesme işlemi
Console.WriteLine(iucar.kanatSayisi + " kanat ile ucarım");
iucar.Uc();
((IGezer)ercep).Uc();//jet motor
ercep.Hiz = 30;
ercep.yas = 5;
}
}
Bir yazımızda görüşmek üzere, sevgili öğrecilerim..
Sizin seçtiğiniz maskot resminizi koyuyorumm..
arabirimler1.rar (23,05 kb)
ARABİRİM(INTERFACE)
Bir sınıfdan kalıtım almak çok avantajlıdır. Nevarki c# sadece bir sınıfdan kalıtım alabilir. C++ dinde ise birde fazla birden fazla sınıfdan kalıtım alanabilniyordu. Birden fazla sınıftan kalıtım alınabilir, ama bu kodu yonetmek sıkıntı yaratabilir. Bu yüzden c# da bir sınıfdan kaltım alabilir, fakat bunun yanında birden fazla arabirimden kalıtım alma özelliği geldi. Boylece arabirimler doğmuş oldu. Aslında arabirimdenler üzerinde yazaılacak ve anlatılacak o kadar çok şey varki, bunu yeri geldiğinde anlatmak daha güzel olacak. Arabirimler, "I" (Interface) harfi ile baslaması zorunlu olmasada makbuldür. Bizim kod okunurluğu açısından bu önemlidir.
Yazım Şekli
Interface IArabirimAdi
{
//arabirim üyeleri(interface members)
}
Arabirim üyeleri Methods(Method), Properties(Özellik), Indexers(indexleyici) ,Events(Olay) olabilir ve arabirimler kod içermez, sadece tanımlama(Declare) içerirler.
Örnek 1.
interface IAyak
{
int Sayisi { get; set; } //özellik(properties)
void Yurur(); //method
}
Örnek 2.
interface IRecord
{
int Id { get; set; }
string Name{ get; set; }
bool Load();
bool Save();
bool Delete();
}
Bu interface baktığımızda, zaten içinde kod olmayan bir sınıf yazmanın anlamsız olduğunu düşünürüz. Ama biraz daha derin düşünürsek, programı birden fazla kişi yada grup yazıyor olsun. Diğer sınıfları yazacak kişilere, sınıflarının bu arayüzü uygulamasını istiyoruz. Böylece onların yazacakları sınıfta Id, Name gibi propertylerin ve load, save gibi metodların olacağından emin oluyoruz. Bir anlamda classlara bir standart getirmiş oluyoruz.
İnterface iki şekilde implement(uygulanır) edilebiliir. Kapalı ve Açık(explicitly). Aşağıdaki örnekde Kitap sınıfı kapalı, Defter sınıfı açık bir şekilde implement edilmiştir. Açık bir şekilde belirtmenin avantajı aynı isimli üyeye sahibi iki arabirim olabilir. Bu iki arabirimden kalıtım alan bir sınıfda çakışma meydana geleceği için açık bir şekilde implemet etmek gerekir. Aşağıdaki örnekte Yazdir() yöntemi her iki arabirimde vardır. Defter sınıfında Yazdir() yöntemleri çakışmasın diye açık bir şekilde implement edilmiştir. Açık bir şeklde yazmak için interface isimi.Üye adı şeklinde yazılır. void IBelge.Yazdir() gibidir.
class Program
{
static void Main(string[] args)
{
}
}
interface IBelge
{
void Yazdir();
}
interface Inot
{
string sahibi();
void Yazdir();
}
class Kitap :IBelge
{
public void Yazdir()
{
//kod yazılacak
}
}
class Defter : IBelge,Inot
{
void IBelge.Yazdir()
{
//belge yazma kodları
//açık bir impelement yapılmış.
}
string Inot.sahibi()
{
//açık bir impelement yapılmış.
return "";
}
void Inot.Yazdir()
{
//açık bir impelement yapılmış.
}
}
Biz Editörü kullnarak bir bir arabirimi implement edebiliriz. Açık ve kapalı.
Aşağıda açık bir şekilde implement ediliyor.
Arabirim uygulanan bir sınıfda, arabirim üyeleri olması zorunludur. Aksi bir durumumde prohe derlenmez.
3 parağram yani yarım sayfa boş bırak
Açık arabirim kullanmanın avantajları
Bir arabirimi açık bir şekilde uygulamak gereksiz gibi görülebilir fakat daha temi, bakımı daha kolay ve önceden tahmin edilebilir(garanti altına alındığı için) daha çok kod yazmanıza yardımcı olan pek çok avantajı vardır.
Arabirim adını açık olarak belirmeden bir yöntem uygulayabilirsiniz fakat bu, uygulamanın davranış biçimlerinde bazı farklılıklar gösterebilir. Öreneğin açıkça arabirim uygulamasını kullanarak tanımlanmış bir yöntem sanal olarak bildirilemez, ancak arabirim adını ihmal etmek bu davranışı izin verir.
Aynı anda dönüş türünde ve parametrelerde yöntemler içeren birden fazla arabirim mümkündür. Bir sınıf, ortak declare edilmiş yöntemlerle birden fazla arabirim uygularsa, yöntem uygulamarı arasındaji belirsizliği gidermek için açık olarak uygulamasını kulalanabilirsiniz. Açık olarak arabirim uygulaması, bir sınıfdaki, bir sınıfdaki yöntemin hangi arabirime ait olduğunu tanımlar. Ayrıca her arabirim için yöntemler ortak olarak erişilebilir fakat sadece arabirimin kendisi üzerinden erişilebilir.
Açık Şekilde.