Önceki Yazılar

• Nhibernate-1
• Nhibernate-2
• Nhibernate-3
• Nhibernate-4

Object references an unsaved transient instance – save the transient instance before flushing: Domain.Kurum hatası:
Aslında hata kendini çok güzel anlatıyor.”Bir nesneyi kaydediyorsun ama onun içinde transient-veritabanında karşılığı olmayan-bir nesne var onun da tipi ‘Kurum’dur.Önce onu kaydet”.
Bu hatayı veren kodumuz şu şekilde:

IKY_UYE uye = new IKY_UYE();
uye.Ad="recep";
uye.Insert();

Uye sınıfında Kurum sınıfına bağlı “Kurumu” adında bir özellik var. Doğrusu şu şekilde olmalıydı.

Kurum krm=KurumDao.GetById(2);
IKY_UYE uye = new IKY_UYE();
uye.Kurumu=krm;
uye.Ad="recep";
uye.Insert();

Class Lazy,List Lazy
Mapping dosyalarını inclediğinizde hem sınıflar için hemd e listeler için bir lazy özelliği geçiyor.

  <class name="SanalOkul.Domain.Okul,SanalOkul.Domain" table="OKUL" lazy="true">
    <bag name="Siniflar" lazy="true" cascade="save-update" inverse="true" >
       <key column="OKULID" />
       <one-to-many class="SanalOkul.Domain.Sinif,SanalOkul.Domain"  />
     </bag></class>

Listeler üzerinde lazy kavramına Nhibernate-2 yazısında değinmiştik.Kısaca tekrar edelim.Öncelikle Lazy özelliğinin varsayılan değeri “true” dur.Yani biz lazy özelliğini xml dosyamızda yazmazsak değerleri otomatik olarak true set edilecektir.Listelerde genel olarak bu özelliği “lazy=true” şeklinde kullanıyoruz.Böylece ihityacımız olduğunda listeyi doldurmuş oluyoruz.Bu şekilde performans düşüşünü engellemiş oluyoruz.Bazı durumalrda bu özelliği “lazy=false” olarak da kullanmak durumunda kalabiliriz.
Şimdi class üzerindeki lazy üzerine yoğunlaşalım.Sınıf üzerindeki lazy özelliği,liste üzerindeki lazy özelliğinden bağımsızdır.Biribirlerini etkilemezler.Sınıf içerisinde “lazy=true” ifadesini kullandığımızda o sınıfı özellik(property) olarak kullanan sınıf o özelliğe erişmek istediğinde devreye girer.bunu bir örnek üzerinde inceleyelim:
=>lazy false:

 <class name="SanalOkul.Domain.Okul,SanalOkul.Domain" table="OKUL" <strong>lazy="false"</strong>

Şöyle bir kodumuz olsun.Sayfa ilk açıldığında bir öğrenciyi bulup Asp.Net Session’a atalım.Başka bir buton eventi altında bu öğrencinin okulunun adına erişelim.

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            Ogrenci ogr = new Ogrenci();
            ogr=OgrenciDao.GetById(75);
            Session["ogr"] = ogr;
        }
    }

   protected void Button1_Click(object sender, EventArgs e)
    {
        Ogrenci ogr = (Ogrenci)Session["ogr"];
        string strOkulAdi = ogr.Okulu.OkulAdi;
    }

Kodu çalıştırıp butona tıkladığımızda 4.satıra gelindiğinde ogr nesnesinin lazy’si false olan Okulu alanına erişerek okul adını okuyabileceğiz.
İkinci duruma geçelim:
=>lazy true:

 <class name="SanalOkul.Domain.Okul,SanalOkul.Domain" table="OKUL" <strong>lazy="true"</strong>

Mapping dosyasını yukarıdaki gibi değiştirelim.Kodumuzu tekrar çalıştırıp butona tıkladığımızda 4.satırda hata alacağız:”Could not initialize proxy-the owning session was closed“
Peki bu hatayı alacağımızı bildiğimiz halde neden “lazy=true” kullanıyoruz?Performansı en üstte tutabilmek için.Dikkat edin burda “lazy=false” ifadesi Ogrenci sınıfında değil Okul sınıfında.Hatayı aldığımız yer de ogr.Okulu.OkulAdi;…

Öyleyse bu hatadan nasıl kurtulabiliriz?
Buton click eventinin altındaki kodu şu şekilde değiştiriyoruz.

   protected void Button1_Click(object sender, EventArgs e)
    {
        Ogrenci ogr = (Ogrenci)Session["ogr"];
        OgrendiDao.Refresh(ogr);
        string strOkulAdi = ogr.Okulu.OkulAdi;
    }

4.satırda aslında Session.Refresh(ogr); yapıyoruz.Böylece bir önceki eventte(PageLoad) yer alan Nhibernate session’ı içinde kalan ogr nesnesini tekrar çekiyoruz.Ayrıntlı bilgi için Nhibernate-2 yazısını incelemenizi tavsiye ederim.

A different object with the same identifier value was already associated with the session: 1, of class Kurum
Bu hata da aynı Nhibernate session’ı içinde aynı id’yi taşıyan birden fazla nesne var demektir.falz olan nesneler session’dan uzaklaştırılmalıdır.Bunu da Session.Evict(okl) şeklinde sağlıyoruz.

Composite-Id
Nhibernate, nesneleri primary keyler üzerinden işler.Primary key alanı olmayan tablolar nhibernate için uygun değildir.Id özelliği,tek alandan oluşabileceği gibi birden çok alanı içinde barındıran composite-id şeklinde de olabilir.Fakat composite-id mantığı kötü tasarımın ürünüdür.

  <class name="Kurum,CrmDomain"  table="Kurum">
    <composite-id name="ID" class="Kurum_ID,CrmDomain">
      <key-property name="K_TUR" column="K_TUR" />
      <key-property name="K_KOD" column="K_KOD" />
      <key-property name="K_SEHIR" column="T_SEHIR" />
    </composite-id>
<property name="K_ADRES" column="K_ADRES" />
    <many-to-one name="SEHIR" class="CrmDomain.Sehir,CrmDomain"  update=" false" insert="false"  >
      <column name="K_SEHIR" />
    </many-to-one>
  </class>

Yukarıda görüldüğü gibi Kurum sınıfının id özelliği üç alandan oluşuyor(K_TUR,K_KOD,K_SEHIR).Alt tarafta da o kurumun bağlı olduğu şehir ilişkisi belirtilmiş.Bu ilişki de Kurum sınıfının id’sini oluşturan alanlardan K_SEHIR üzerinden kurulmuş.Bu tür kullanım gayet doğal bir kullanım gibi gözükse de çok tercih edilmemesi gerektiğini düşünüyorum.Zira bu durumların yönetimi zordur.Önce kullanımı inceleyelim sonra da alternatif çözüme bakalım.
Nhibernate içinde, composite-id kullanabilmek için composite-id olarak oluşturduğumuz sınıfın “Equals” ve “GetHashCode” virtual metodlarını override etmesi gerekir.

 public class KURUM_ID
    {
        private string _K_TUR;
        public virtual string K_TUR
        {
            get { return _K_TUR; }
            set { _K_TUR= value; }
        }
        private Nullable<long> _K_KOD;
        public virtual Nullable<long> K_KOD
        {
            get { return _K_KOD; }
            set { _K_KOD= value; }
        }
        private Nullable<long> _K_SEHIR;
        public virtual Nullable<long> K_SEHIR
        {
            get { return _K_SEHIR; }
            set { _K_SEHIR = value; }
        }
        public override bool Equals(object other)
        {
            if ((this == other))
                return true;
            if ((other == null))
                return false;
            if (!(other is KURUM_ID))
                return false;
            KURUM_ID castOther = (KURUM_ID)other;
            return ((this.K_TUR == castOther.K_TUR) && (this.K_KOD == castOther.K_KOD) && (this.K_SEHIR == castOther.K_SEHIR) );
        }
        public override int GetHashCode()
        {
            int result = 17;
            result = 37 * result + this.K_TUR.ToString().Length;
            result = 37 * result + this.K_KOD.ToString().Length;
            result = 37 * result + this.K_SEHIR.ToString().Length;
            return result;
        }
    }

Şimdi de kod yazalım.

    KURUM kurum=new KURUM();
    KURUM_ID id=new KURUM_ID();
    id.K_TUR=2;
    id.K_KOD=2645264;
    id.K_SEHIR=34;
    kurum.Id=id;
    kurum.Sehir=SEHIRDAO.GetById(26);
    KURUMDAO.insert(kurum);

Tekrar mapping dosyamıza dönelim

    <many-to-one name="SEHIR" class="CrmDomain.Sehir,CrmDomain"  update=" false" insert="false" >
      <column name="K_SEHIR" />
    </many-to-one>

update=”false” insert=”false” ifadesine dikkat edelim.Bu ifade bu sınıf için bir insert ya da update cümlesi oluşturulduğunda ilişkide geçen bu alanı(K_SEHIR) alanını sql cümlesi içinde kullanma anlamına gelir. Çünkü bu alan,asıl sınıfın composite-id alanlarından biri olduğu için insert,update cümlesinde zaten geçiyor.insert=”false” update=”false” ifadesini kullanmadığımızda K_SEHIR alanı sql cümlesinde tekrar geçecek ve “duplicate column” hatası alacağız.
Peki ne zaman insert=”true” update=”true” kullanırız? Many-to-one ilişkimizi ana sınıf üzerinde id olmayan sıradan alanlar üzerinden kurduğumuzda -örneğin K_ADRES- bu ifadeyi insert=”true” update=”true” şeklinde kullanırız.Böylece ilişki içerisinde geçen K_ADRES alanını da insert cümlesine katmış oluruz.

Alternatif çözümümüz, composite-id kullanmamaktır.K_TUR,K_KOD,K_SEHIR alanlarının üçünü birden id yapmak yerine üç alanı karşılayan K_ID adında yeni bir alan oluşturulur geri kalan bu üç alan kendi içlerinde UNIQUE yapılır.

Böylece ilişkileri de hep id alanı üzerinden kurarak,yönetilebilir bir koda kavuşmuş olacağız.

Nesneye yönelik programlamanın temel mantığı, çalışan kodu yönetilebilir,anlamlı en küçük birimlere ayrımaya dayanır.Böylece modüler yapı sağlanmış olacak,yeni ihtiyaçlar ışığında değişmesi gerekecek ve bu değişimden etkilenecek birimler asgari seviyede tutulacaktır.
Konuyu bir örnek üzerinde inceleyelim:
Bir Haber ajansının güncel haberleri abonelerine gönderen şöyle bir kod parçası olsun.

static void Main(string[] args)
        {
            HaberYoneticisi haberYoneticisi =new  HaberYoneticisi();
            haberYoneticisi.HaberleriAbonelereGec();
        }

   public  class HaberYoneticisi
    {
        public void HaberleriAbonelereGec()
        {
            IList guncelHaberler=Haber.GetAll();
            foreach (Haber haber in guncelHaberler)
            {
                IList aboneListesi = haber.AboneListesi;
                foreach (Abone abone in aboneListesi)
                {
                    Mail mail=new Mail();
                    mail.From = "XXX AJANS";
                    mail.To = abone.mail;
                    mail.Subject = haber.Icerik;
                    mail.Server = "exchange";
                    mail.Port = 25;
                    mail.Send();
                }
            }
        }
    }

• Güncel haberlerin abonelerini bulma
• Bulunan abonelere mail atma

Burada yer alan iki iş, biribirine sıkı bir şekilde bağlı olsa örneğin “Aboneleri bul”,”Abonelerin puanını bir artır” gibi başka yerde tekrarlanmayacak iki iş olsa,bunları ayırmak her birine sınıf yazmak OverEngineering diye tabir edilen gereksiz kompleksliğe yol açar.Fakat burda geçen “…’a mail atma” işinin, başka bir çok sınıf içinde geçtiğini varsayalım*.(Abonelere,yöneticilere,diğer ajanslara mail atma)Bu durumda her sınıf içinde aynı işi yapan kodlar gereksiz kod tekrarına yol açar.Ek olarak mail atan sınıflarda “System.Net.Mail” gibi sistem sınıflarına gereksiz yere referans vermiş oluruz.İp yumaklarının biribirine karışmasına benzer bu durumdan aşağıdaki çözümle kurtulabiliriz.
————————————–
*Dikkat edin “ileride geçebilir” demiyorum. “İleride geçer” diye şimdiden sınıfları ayırıp,gruplama yapmıyoruz.Bu bizim Heuristic(deneme-yanılma) yöntemle kod yazma felsefemize uymuyor.İleride, ihtiyaç olduğunda gerekli refactoring işlemleriyle ayrıştırma yapılabilir.
————————————–
Çözüm:İkinci işin(mail atma) kod bloğunu ayrı bir sınıfa alıyoruz.O sınıfı, ilk sınıfımız içerisinde (use-a yada has-a ilişkisi) kullanıyoruz.Ya da bu kısmı bir arayüz(interface) içine alıp(is-a ilişkisi) sınıflarımızı bu arayüzü uygular hale getiriyoruz.Biz bu örnekte “use-a” ilişkisini tercih edelim.

Kodumuzun yeni durumuna bakalım:

 public  class HaberYoneticisi
    {
        public void HaberleriAbonelereGec()
        {
            IList<Haber> guncelHaberler=Haber.GetAll();
            foreach (Haber haber in guncelHaberler)
            {
                IList<Abone> aboneListesi = haber.AboneListesi;
                foreach (Abone abone in aboneListesi)
                {
                   MailSender.Send(abone, haber);
                }
            }
        }
    }
    public static class MailSender
    {
        public static void Send(Abone abone,Haber haber)
        {
            Mail mail = new Mail();
            mail.From = "XXX AJANS";
            mail.To = abone.mail;
            mail.Server = "exchange";
            mail.Subject = haber.Icerik;
            mail.Port = 25;
            mail.Send();
        }
    }

Bu kadar büyüklükte bir dokümantasyonun bırakın anlaşılmasını beklemek, okunması bile çok zordur.Neredeyse kod satırından çok doküman yazılıyor.Eski metedolojilere göre zaten geçerli olan “koddan çok açıklama satırı” mantığıdır.Günümüzde bile bu tür görüşleri savunanlar var.Saygı duyuyoruz.

Bugün daha çok yazılımın ürün hali ile ilgili dokümantasyondan bahsetmek istiyorum.
Bir iş uygulam yazılımı yaptığınızı düşünelim.Uygulamayı devreye alıyorsunuz.Kullanıcılara uygulama için eğitim vermeniz gerekli.Ama önce kalite standartları gereği kullanıcı klavuzu yazmanız gerektiği hatırlatılıyor.Fontlar,şablonlar,imlâ kuralları…. Doküman yazmak kod yazmaktan çok daha zor hale geliyor… Yazılımcının en büyük hazinesi zamandır.Doküman yazmak kolay bir işlem olsa da çok fazla zamana mâl olur(Aynı şekilde sayfa üzerinde html ile uğraşmak vs..).Bir şekilde dokümanı yazmayı bitirdiğinizi varsayalım.Eğitim için insanları toplayıp iki saatte yazılımın işlevlerini anlatmaya çalışıyorsunuz.Ne kadar faydalı olduğu şüpheli.Doküman yazmak için çok değerli iki saatinizi harcıyorsunuz.Eğitim vermek için tüm şirketin çok değerli iki saatini harcıyorsunuz.
Bu tür eski moda dokümantasyon ve eğitim teknikleri yerine, kaydedilmiş eğitim videolarını tercih etmemiz gerektiğini düşünüyorum(Bknz. Camtasia). Yazılım her işlevini anlatan ufak ufak videolar kaydedip bütün kullanıcıların erişebileceği ortak bir noktaya koyun.Böylece kullanıcılar,programda takıldıkları yerde bu videroları izleyip sorularına cevap bulabilecekler.Artık her takıldıkları yerde sizi aramayacaklar.”Call center” olmaktan kurtulacaksınız.

Bu yöntemle elde edeceğimiz kazanımlarımızı özetleyelim:

• Kullanıcıların hiç bir zaman okumayacağı klavuzlar hazırlamak için çektiğiniz eziyetten kurtulacaksınız.
• Doküman yazmak ve eğitim vermek için, sizin ve kullanıcılarınızın zamanını harcamamış olacaksınız.
• Kullanıcılar tarafından sürekli rahatsız edilmeyeceksiniz.

• Test Driven Development-1
• Test Driven Development-2

Para örneğimize kaldığımız yerden devam ediyoruz.Para nesnelerini karşılaştıran testlerimize başlayalım.

• Farklı birimlerde aynı miktarlar karşılaştırıldığında testimiz false döndürmeli
• Aynı birimlerde farklı miktarlar karşılaştırıldığında testimiz false döndürmeli
• Aynı birimlerde aynı miktarlar karşılaştırıldığında testimiz true döndürmeli

[Test]
public void AyniBirimler_Farkli_Miktarlar_Equals_Return_false()
{
     ParaBase ytl = ParaBase.CreatePara(8,"YTL");
     ParaBase yeniYtl = ParaBase.CreatePara(13, "YTL");
     Assert.AreEqual(false,ytl.AyniMi(yeniYtl));
}
[Test]
public void AyniBirimler_Ayni_Miktarlar_Equals_Return_true()
{
     ParaBase ytl = ParaBase.CreatePara(8, "YTL");
     ParaBase yeniYtl = ParaBase.CreatePara(8, "YTL");
     Assert.AreEqual(true, ytl.AyniMi(yeniYtl));
}
[Test]
public void FarkliBirimler_Ayni_Miktarlar_Equals_Return_false()
{
     ParaBase ytl = ParaBase.CreatePara(8, "YTL");
     ParaBase dolar = ParaBase.CreatePara(8, "USD");
     Assert.AreEqual(false, ytl.AyniMi(dolar));
}

Resharper bize AyniMi metodunun olmadığını söylüyor.Öyleyse AYniMİ metodunu yazıyoruz:

public bool AyniMi(ParaBase kiyasPara)
{
     return (Miktar == kiyasPara.Miktar);
}

Metodun bu haliyle Farkli_Miktarlar_Equals_Return_false, Ayni_Miktarlar_Equals_Return_true testleri başarılı olacak ama FarkliBirimler_Ayni_Miktarlar_Equals_Return_false testi başarasız olacak zira sadece miktar alanına bakıyoruz.Bu durumda 8 USD=8 YTL işlemi doğruymuş gibi gözükecek.
Metodumuza birim karşılaştırması da ekliyoruz

public bool AyniMi(ParaBase kiyasPara)
{
     return (Miktar == kiyasPara.Miktar) && (Birim==kiyasPara.Birim);
}

Şimdi farklı para birimleri arasında dönüştürme testlerimize başlayalım.
1 USD=2YTL kabul edelim.(Bu durumun tersini arzu ederdik)

[Test]
public void YTL_USD_DonusumMetodu()
{
     ParaBase ytl = ParaBase.CreatePara(8, "YTL");
     ParaBase dolar=ParaDonusturucu.Donustur(ytl, "USD");
     Assert.AreEqual(dolar.Miktar,4);
}

Tabi testi bu haliyle geçemiyoruz.Önce ParaDonusturucu sınıfımızı oluşturuyoruz.

public class ParaDonusturucu
{
    public static ParaBase Donustur(ParaBase DonusturulecekPara, string DonusecekBirim)
    {
       retun null;
    }
}

Parabirimleri arasında dönüşüm yapabilmek çaprazkur bilgilerini bilmemiz gerekiyor.
Donustur metodunun içerisini şöyle değiştirelim:

public class ParaDonusturucu
{
     public static ParaBase Donustur(ParaBase DonusturulecekPara, string DonusecekBirim)
     {
       double caprazKur = CaprazKurlar.KurDegeri(DonusturulecekPara.Birim, DonusecekBirim);
       double yeniMiktar = DonusturulecekPara.Miktar*caprazKur;
       return ParaBase.CreatePara(yeniMiktar, DonusecekBirim);
     }
}

CaprazKurlar adında static bir sınıfımız olsun.İçinde KurDegeri adında bir metod, verilen parametlere göre çarprazkur bilgisini döndürsün.Örneğin (1 USD,YTL) için 2 değeri dönsün.

USD YTL 2
YTL USD 0,5
Şeklinde verileri tutabileceğimiz sınıflarımız olsun.Ve bu sınıflar da aynı özelliklere sahip olacağı için soyut bir sınıf yazıyoruz.

public abstract class CaprazKurBase
{
     public abstract string KaynakBirim { get; }
     public abstract string HedefBirim { get; }
     public abstract double CaprazKurDegeri { get; }
}

Yeni kur sınıflarımızı da bu sınıftan türeterek oluşturuyoruz.

public class USD_YTL_CaprazKur:CaprazKurBase
{
     public override string KaynakBirim
     {
       get { return "USD"; }
     }
     public override string HedefBirim
     {
       get { return "YTL"; }
     }
     public override double CaprazKurDegeri
     {
       get { return 2.0; }
     }
}
public class YTL_USD_CaprazKur : CaprazKurBase
{
     public override string KaynakBirim
     {
        get { return "YTL"; }
     }
     public override string HedefBirim
     {
       get { return "USD"; }
     }
     public override double CaprazKurDegeri
     {
       get { return 0.5; }
     }
}

Şimdi CarprazlarKurlar sınıfı ve o sınıfın KurDegeri metodunu doldurabiliriz.

public static class CaprazKurlar
{
     static List<CaprazKurBase> CaprazKurListesi=new List<CaprazKurBase>{new USD_YTL_CaprazKur(),new YTL_USD_CaprazKur()};
    public static double KurDegeri(string kaynakBirim, string hedefBirim)
    {
       foreach (CaprazKurBase kur in CaprazKurListesi)
       {
         if((kur.HedefBirim==hedefBirim) &&(kur.KaynakBirim==kaynakBirim))
            {
              return kur.CaprazKurDegeri;
            }
        }
        return 0;
   }
}

Şimdi YTL_USD_DonusumMetodu testini çalıştırdığımızda testi geçtiğimi göreceğiz.
YTL->USD dönüşümünü yaptık.Şimdi USD->YTL dönüşümü test edelim.

[Test]
public void USD_YTL_DonusumMetodu()
{
     ParaBase dolar = ParaBase.CreatePara(8, "USD");
     ParaBase ytl = ParaDonusturucu.Donustur(dolar, "YTL");
     Assert.AreEqual(ytl.Miktar, 16);
}

8doları 16ytl’ye çevirebildik.

Farkettiyseniz birimler string olarak tanımlı.Artık bu stringlerden kurtulup bir enum tip oluşturmanın vakti geldi.Çift tırnak içine yazılarak tanımlanan değişkenlerin hatalı tanımlanma olasılığı yüksektir.Örneğin CreatePara(8,”UAD”)… ‘S’ yerine ‘A’ karakterine bastım.Derleyici çift tırnak içindeki ifadelerin size ait olduğunu düşünür ve içinde kontrol yapmaz.Bunun yerine enum değişkenler kullansak ve hatalı yazsak derleyici bizi uyaracak.

Birim adında bir enum oluşturalım.

public enum Birim
{
    YTL=0,
    USD=1,
    EUR=2
}

Kodumuzdaki tüm “YTL” ifadelerini, Birim.YTL; tüm “USD” ifadelerini, Birim.USD yapalım Ve testlerimizi tekrar çalıştıralım.(Dönüşümlerden sonra sorun çıkacak mı?)
Evet değişikliklerden sonra testlermizin hepsi yeşil….
Kodumuzun son haline bakalım.

[TestFixture]
public class Tests
{
    [Test]
    public void Dolar_YapiciMetodIleDuzgunOlusturulmus_Mu()
    {
       ParaBase dlr = ParaBase.CreatePara(8, Birim.USD);
       Assert.AreEqual(dlr.Miktar, 8);
    }
    [Test]
    public void YTL_YapiciMetodIleDuzgunOlusturulmus_Mu()
    {
       ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
       Assert.AreEqual(ytl.Miktar, 8);
     }
     [Test]
     public void YTL_ParaEkleme()
     {
        ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
        ytl.Ekle(5);
        Assert.AreEqual(ytl.Miktar, 13);
     }
     [Test]
     public void YTL_Farkli_Miktarlar_Equals_Return_false()
     {
        ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
        ParaBase yeniYtl = ParaBase.CreatePara(13, Birim.YTL);
        Assert.AreEqual(false,ytl.AyniMi(yeniYtl));
     }
     [Test]
     public void YTL_Ayni_Miktarlar_Equals_Return_true()
     {
        ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
        ParaBase yeniYtl = ParaBase.CreatePara(8, Birim.YTL);
        Assert.AreEqual(true, ytl.AyniMi(yeniYtl));
     }
     [Test]
     public void FarkliBirimler_Ayni_Miktarlar_Equals_Return_false()
     {
        ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
        ParaBase dolar = ParaBase.CreatePara(8, Birim.USD);
        Assert.AreEqual(false, ytl.AyniMi(dolar));
     }
     [Test]
     public void YTL_ParaTemelSinifiEkleMetodu()
     {
        ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
        Assert.AreEqual(ytl.Miktar, 8);
     }
     [Test]
     public void YTL_ParaTemelSinifiCikarMetodu()
     {
        ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
        ytl.Cikar(3);
        Assert.AreEqual(ytl.Miktar, 5);
      }
      [Test]
      [ExpectedException(typeof(YetersizMiktarException))]
      public void YTL_ParaTemelSinifiCikarMetodu_MiktarSifirinAltinda_IstisnaFirlat()
      {
         ParaBase ytl =ParaBase.CreatePara(8,Birim.YTL);
         ytl.Cikar(13);
      }
      [Test]
      public void YTL_USD_DonusumMetodu()
      {
         ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
         ParaBase dolar=ParaDonusturucu.Donustur(ytl, Birim.USD);
         Assert.AreEqual(dolar.Miktar,4);
      }
      [Test]
      public void USD_YTL_DonusumMetodu()
      {
         ParaBase dolar = ParaBase.CreatePara(8, Birim.USD);
         ParaBase ytl = ParaDonusturucu.Donustur(dolar, Birim.YTL);
         Assert.AreEqual(ytl.Miktar, 16);
       }
}
public class ParaBase
{
     public static ParaBase CreatePara(double _miktar, Birim _birim)
     {
        return new ParaBase(_miktar, _birim);
     }
     protected double miktar;
     private Birim birim;
     protected ParaBase(double _miktar, Birim _birim)
     {
         miktar = _miktar;
         birim = _birim;
      }
      public double Miktar
      {
         get { return miktar; }
      }
      public Birim Birim
      {
        get { return birim; }
      }
      public bool AyniMi(ParaBase kiyasPara)
      {
         return (Miktar == kiyasPara.Miktar) && (Birim==kiyasPara.Birim);
      }
      public void Ekle(int _ekMiktar)
      {
         miktar += _ekMiktar;
      }
      public void Cikar(int _cikacakMiktar)
      {
          if (_cikacakMiktar > Miktar) throw new YetersizMiktarException("Yeterli para yok");
          miktar -= _cikacakMiktar;
       }
}
public class YetersizMiktarException : Exception
{
     public YetersizMiktarException(string Message) : base(Message) { }
}
public class ParaDonusturucu
{
      public static ParaBase Donustur(ParaBase DonusturulecekPara, Birim hedefBirim)
      {
         double caprazKur = CaprazKurlar.KurDegeri(DonusturulecekPara.Birim, hedefBirim);
         double yeniMiktar = DonusturulecekPara.Miktar*caprazKur;
         return ParaBase.CreatePara(yeniMiktar, hedefBirim);
      }
}
public static class CaprazKurlar
{
      static readonly List CaprazKurListesi=new List{new USD_YTL_CaprazKur(),new  YTL_USD_CaprazKur()};
      public static double KurDegeri(Birim kaynakBirim, Birim hedefBirim)
      {
          foreach (CaprazKurBase kur in CaprazKurListesi)
          {
              if((kur.HedefBirim==hedefBirim) &&(kur.KaynakBirim==kaynakBirim))
                {
                   return kur.CaprazKurDegeri;
                }
            }
        return 0;
       }
}
public class USD_YTL_CaprazKur:CaprazKurBase
{
    public override Birim KaynakBirim
    {
       get { return Birim.USD; }
    }
    public override Birim HedefBirim
    {
       get { return Birim.YTL; }
    }
    public override double CaprazKurDegeri
    {
      get { return 2.0; }
    }
}
public class YTL_USD_CaprazKur : CaprazKurBase
{
     public override Birim KaynakBirim
     {
        get { return Birim.YTL; }
     }
     public override Birim HedefBirim
     {
        get { return Birim.USD; }
     }
     public override double CaprazKurDegeri
     {
        get { return 0.5; }
     }
}
public abstract class CaprazKurBase
{
     public abstract Birim KaynakBirim { get; }
     public abstract Birim HedefBirim { get; }
     public abstract double CaprazKurDegeri { get; }
}
public enum Birim
{
    YTL=0,
    USD=1,
    EUR=2
}

Burada şöyle bir soru kafamızı kurcalıyor.”Her yeni parabirimi eklendiğinde,birim sayısı kadar kombinasyon oluşacak.Her kombinasyon için yeni bir sınıf mı oluşturacağız?(YTl_YEN_CAPRAZKUR,DIN_YTL_CAPRAZKUR…)Ya da biz bu değerleri bir yerlerden mi okumalıyız?Evet bu değerleri veritabanından okumalıyız.Bu durumda her dönüşüm için bir sınıf oluşturmamıza gerek yok.Soyut sınıfımızın soyutluğunu kaldırır, veritabanında CaprazKur tablosundan gelen verileri bu sınıfa doldurarak kullanırız.

Son olarak “ayniMi” metoduna bakalım.Farklı miktarlarda farklı para birimlerini karşılaştıran testimizi yazalım.

[Test]
public void FarkliBirimler_Farkli_Miktarlar_AyniDeger_Equals_Return_true()
{
    ParaBase ytl = ParaBase.CreatePara(8, Birim.YTL);
    ParaBase dolar = ParaBase.CreatePara(4, Birim.USD);
    Assert.AreEqual(false, ytl.AyniMi(dolar));
}

Testimizi çalıştırdığımızda başarısız olacağımızı göreceğiz.Zira “AyniMi” metodu içerisinde kontrolümüz şu şekilde:

      return (Miktar == kiyasPara.Miktar) && (Birim==kiyasPara.Birim);

Bu durumda farkli para birimlerindeki paralar hiçbir zaman eşit olmayacak.”AyniMi” metodunun içini değiştiriyoruz.

public bool AyniMi(ParaBase kiyasPara)
{
    if (Birim == kiyasPara.Birim)
    {
       return (Miktar == kiyasPara.Miktar);
    }
    ParaBase kaynakPara= ParaDonusturucu.Donustur(this, kiyasPara.Birim);
    return (kaynakPara.Miktar == kiyasPara.Miktar);
}

Testlerimizi tekrar çalıştırıyoruz.Hepsi yeşil…Tekrar vurgulamak gerekirse birim testlerin bize sağladığı en önemli fayda,koddaki değişikliklerin diğer noktalarda ne gibi sorunlar çıkartacağını bize göstermesidir.”AyniMi” metodunda yaptığımız değişiklik en son testimizde sorun çıkartmaz ama önceki testlerimizi patlatabilirdi.

“Unit test” yazı dizisinin sonuna geldik..

• Command Pattern-1

“Pdf Okuyucu” örneğimizi genişleterek devam ediyoruz.PdfPager adında sayfaları ileri-geri çevirmemize yardım eden bir sınıfımız vardı.Şimdi de sayfalar üzerinde not almamızı sağlayacak bir PdfWriter sınıfımız olsun.Bu sınıf yardımı ile sayfalar üzerinde not alabilelim ya da aldığımız önceki notları silebilelim.

Önce ReadCommand sınıfımızı hatırlayalım:

public class ReadCommand:ICommand
{
    public PdfPager pdfPager { get; set; }
    public char IslemTipi { get; set; }
    public int Miktar { get; set; }   

    public void Execute()
    {
        pdfPager.Read(IslemTipi, Miktar);
    }
    public void Undo()
    {
        ChangeIslemTipi();
        Execute();
    }
    public void Redo()
    {
        ChangeIslemTipi();
        Execute();
    }
    public void ChangeIslemTipi()
    {
        IslemTipi = IslemTipi == '+' ? '-' : '+';
    }
}

Command arayüzünü hatırlayalım.

public interface ICommand
{
    void Execute();
    void Undo();
    void Redo();
}

Yeni komut sınıfımız olan WriteCommand sınıfımızda da IslemTipi alanına(not ekle,not sil) ihtiyacımız olacak.Undo ve Redo metodları da önce işlem tipini değiştirip sonra execute metodunu çağıracak.Öyleyse ortak kod bloklarımız var.Bu durumda arayüzü soyut sınıfa çeviriyoruz.Yeni command soyut sınıfımızı inceleyelim:

public abstract class Command
    {
        public abstract void Execute();
        public  void Undo()
        {
            ChangeIslemTipi();
            Execute();
        }
        public  void Redo()
        {
            ChangeIslemTipi();
            Execute();
        }
        public void ChangeIslemTipi()
        {
            IslemTipi = IslemTipi == '+' ? '-' : '+';
        }
        public abstract char IslemTipi { get; set; }
    }

Şimdi de ReadCommad ve WriteCommand sınıfılarımızın son haline bakalım.

    public class ReadCommand:Command
    {
        public PdfPager pdfPager { get; set; }
        public override char IslemTipi { get; set; }
        public int Miktar { get; set; }
        public override void Execute()
        {
            pdfPager.Read(IslemTipi, Miktar);
        }
    }

public class WriteCommand:Command
    {
       public override void Execute()
        {
            pdfWriter.PdfNotlariniYonet(IslemTipi,Not);
        }
        public override char IslemTipi { get; set; }
        public string Not { get; set; }
        public PdfWriter pdfWriter { get; set; }
    }

PdfPager sınıfında hangi sayfada olduğumuzu gösteren CurrentPageIndex adında bir alanımız vardı.Yeni sınıfımız PdfWriter için de hangi sayfaya not aldığımızı gösterecek böyle bir alana ihtiyaç var.Aslında CurrentPageIndex alanının bu iki sınıfa da ait olmadığını direk Book sınıfının bir özelliği olduğunu görüyoruz.Öyleyse bu özelliği, Book sınıfına taşıyoruz.

Book sınıfının son durumu şöyle:

 public class Book
    {
        private readonly List<Command> commands = new List<Command>();
        public readonly PdfPager pager=new PdfPager();
        public readonly PdfWriter writer = new PdfWriter();
        private int CurrentCommandIndex { get; set; }
        public int CurrentPageIndex { get; set; }

        public Book()
        {
            CurrentCommandIndex = -1;
            writer.book = this;
            pager.book = this;
        }
        public void Oku(char IslemTipi, int Miktar)
        {
            ReadCommand readCommand = new ReadCommand { IslemTipi = IslemTipi, Miktar = Miktar, pdfPager = pager};
            commands.Add(readCommand);
            CurrentCommandIndex++;
            readCommand.Execute();
        }
        public void IslemleriGeriAl(int times)
        {
            for (int i = 0; i < times; i++)
            {
                commands[CurrentCommandIndex].Undo();
                CurrentCommandIndex--;
            }
        }
        public void IslemleriIleriAl(int times)
        {
            for (int i = 0; i < times; i++)
            {
                CurrentCommandIndex++;
                commands[CurrentCommandIndex].Redo();
            }
        }
        public void NotAl(char IslemTipi,string not)
        {
            WriteCommand writeCommand = new WriteCommand { IslemTipi = IslemTipi, Not = not, pdfWriter = writer };
            commands.Add(writeCommand);
            CurrentCommandIndex++;
            writeCommand.Execute();
        }
    }

PdfWriter sınıfımız:

 public  class PdfWriter
    {
      public Book book { get; set; }
      readonly IDictionary<int,string> NotList=new Dictionary<int, string>();
      public void  PdfUzerineNotKaydet(string not)
      {
           NotList.Add(book.CurrentPageIndex,not);
      }
      public void PdfUzerineNotSil(string not)
      {
          FindAndDeleteNot(not);
      }
      private void FindAndDeleteNot(string not)
        {
           foreach(KeyValuePair<int,string> pair in NotList)
           {
               if(pair.Value==not)
               {
                   NotList.Remove(pair.Key);
                   break;
               }
           }
        }
        public void PdfNotlariniYonet(char IslemTipi, string not)
        {
            switch (IslemTipi)
            {
                case '+':
                    PdfUzerineNotKaydet(not);
                    break;
                case '-':
                    PdfUzerineNotSil(not);
                    break;
            }
        }
    }

ve nihayet Musteri sınıfı:

 public class Musteri
    {
        public static void Oku()
        {
            Book book = new Book();
            book.CurrentPageIndex = 28;

            book.NotAl('+',"deneme");
            book.Oku('+', 5);
            book.NotAl('+', "deneme2");
            book.Oku('+', 7);
            book.NotAl('+', "deneme3");
            book.Oku('+', 8);
            book.NotAl('-', "deneme");
            book.IslemleriGeriAl(2);
            int sayfaNumarasi = book.CurrentPageIndex;
        }
    }

book.IslemleriGeriAl(2); satırına gelindiğinde sayfa numarası 48,book nesnesinin içinde yer alan writer nesnesi üzerinde tuttuğumuz NotList alanı: (33,deneme2),(40,deneme3) değerlerini gösterir.
book.IslemleriGeriAl(2); satırını da çalıştırdığımzıda önce book.NotAl(‘-’, “deneme”); komutumuz tersine çalışıp sildiğimiz “deneme” notunu geri yazacağız.Sonra da book.Oku(‘+’, 8); komutunu tersine çalıştırıp 8 sayfa geri gideceğiz.Son durumda sayfa numarası 40,book nesnesinin içinde yer alan writer nesnesi üzerinde tuttuğumuz NotList alanı: (33,deneme2),(40,deneme3),(48,deneme) değerlerini gösterir.

Temel iş mantığında hatalar,mantıksızlar olabilir.Sonuçta bu bir örnek.Önemli olan command pattern desenin işleyiş mantığını anlamak.
Tasarım desenleri ile alakalı bir kaç şey söylerek bu yazıyı tamamlamak istiyorum.Tasarım desenleri uygulanması zorunlu metodolojiler değildir.Çözüm getirdiği iddia edilen durumlar için uygunluğu daha önceden birçok kez tescil edilmiş,genelleşmiş yöntemlerdir.Her geliştiricinin kendine has durumları için kendine özel çözümleri,tasarım desenleri olabilir.Yazılımcının tasarım deseni ezberlemesi çok mantıksız ve gereksiz geliyor bana..Ben command Pattern’i ezbere bilmiyorum.Bu kodu yazdıktan sonra bile ezberimde değil.İhtiyacım olduğunda daha önceden yazılmış kodu inceleyerek kendi durumuma göre özelleştirip kullanıyorum.Bazı durumlarda “illa da tasarım deseni kullanarak yapacağım(overengineering)” diye basit bir kodu karmaşıklaştırmanın hiç bir anlamı yok.Yazılım geliştirme, deneme-yanılma yöntemine dayalı(heuristic) bir iştir.Yukarıda yazılan kod, yeni yeni deneme-yanılma yöntemleri kullanılarak daha iyi bir duruma getirilebilir.
Sağlıcakla kalın.

Her ne kadar yazılım jargonunun tamamen Türkçeleştirilmesinin zorlama olacağına inansam da zaman içinde bu alternatif kelimelerin zihnimizde yer edeceğini düşünüyorum.Bazı komik ve saçma çeviriler de olmuyor değil..”Programı run ettim” yerine “programı koşturdum” cümlesi hep komik gelmiştir bana.At değilki bu program, koşturasın.İlla Türkçe kullanalım diyorsak “Programı çalıştırdım” diyebiliriz.
Bir de “Kodun test case’lerini run ederken çok extraordinary bir situation gördüm” şeklinde konuşan concon tipler var.Bu konuya daha sonra değiniriz.
Ben sözlükte geçen bazı temel kavramlar ve Türkçe karşılıklarını sıraladım:
Attribute:Öznitelik
Property:Özellik
Field:Alan
Class:Sınıf
Default Value:Varsayılan değer
Dependency:Bağımlılık
Pattern:Desen
Abstract:Soyut
Object:Nesne
Constructor:Yapıcı
Encapsulation:Sarmalama
Proxy:Vekil

Ama bazı kelimeler de varki İngilizcesi çok kısa ama Türkçesi çok uzun olmuş.Örneğin Caching:Önbelleğe koyma