DEV Community: hdemiray

Pair Programming Nedir ? Faydaları Nelerdir ?

hdemiray — Mon, 18 Jan 2021 22:06:03 +0000

Pair programming 2 yazılımcının bir proje veya problem üzerinde çalışmasıdır. İkili programlama da denilebilir.

Agile(çevik yazılım geliştirme) yöntemlerindendir.

2 yazılımcı bilgisayar başına oturur ikiside aynı anda yazamayacağı için biri Observer(gözlemci) diğeri ise Driver(sürücü) rollerine geçer.

Sürücü, projeyi geliştiren veya probleme çözüm arayan kişi.

Gözlemci ise problem çözümünü inceleyen, feedback'ler veren ve sürücüyü yönlendiren kişidir.

Eşleşmeler

Bu ikili çalışmada 3 farklı eşleşme olabilir


Uzman	Uzman
Acemi	Uzman
Acemi	Acemi

Bunları incelediğimizde :

Uzman - Uzman : Çok iyi sonuçlar alınır. Kötü yanı ise, deneyim yüksek seviyede olduğu için, eğer ortada bir problem varsa çözümlere genelde deneyim ile ulaşırlar ve bu yeni fikirler açısından olumsuz bir durumdur.

Acemi - Uzman : Bu ikili en fazla verim alınan modeldir. Uzman geliştiricinin acemiye akıl hocalığı yapması ve gelişimine destek vermesi açısından önemlidir. Acemi geliştiricinin öğrenmeye açık olması ve sorgulayıcılığı ile yeni fikirler ortaya çıkacaktır. Çırak usta ilişkisi ile aceminin gelişimi gözlemlenebilecektir.

Acemi - Acemi : Bir acemi geliştiricinin akıl hocası yoksa eğer. Tek başına çalışmaktansa 2 aceminin beraber çalışması, farklı bakış açısından faydalı olur.

Pair Programming Faydaları

Disiplin artırır.
Kodun kalitesi artar.
Ortak kod sahipliği oluşur, birinin yazdığından diğerinin de haberi vardır ve bunun üzerine aynı bilgi ile tartışabilirler.
Moral ve motivasyonu yüksek tutar. Bir işte iki kişinin çalışması kodu yazan kişiyi motive eder.

Şirketler bunu kullanıyor mu?

Şirketlerin çoğu pair programmingi uygulamıyor, bunu maaliyetli buluyor bir işe iki kişi verildiği için.

Ancak burada maaliyetten çok bir kazanç var, ortaya çıkan iş daha kaliteli ve ileriye dönük oluyor.

Ekip ve takım olarak çalışan start up veya kurumsal firmalar mutlaka bu konuya önem veriyor.

Pair Programming için yanyana olma zorunluluğu yoktur.
Driver roldeki kişi ekranını Gözlemci kişiye paylaşarak ta eşli programlama yapılabilir.

Yine pair programminge çok benzeyen diğer eşli programlama türü olan Mob Programming (Çoklu programlama) ise ekipler tarafından kullanılır, burada 1 kişi sürücü ve ekibin geri kalanı gözlemci olur.

C# İle Generic Sınıflara Giriş

hdemiray — Wed, 23 Dec 2020 22:44:22 +0000

Generic sınıflar OOP programlama yaparken C# ta kurtarıcı bir özelliğe sahiptir. Bu yüzden genericleri çok iyi anlamamız gerekiyor.

Generic nedir ?

Örneklerle açıklamaya çalışayım.

Kurduğumuz bir CRUD operasyonlarını içeren yapıyı her nesne için tekrar tekrar yazmamak için onu bir tip kullanmaya zorlamadan generic bir yapı oluşturarak her nesnemize uyarlanabilir hale getireceğiz.

Customer sınıfımızı ve onun Crud operasyonlarını içeren DAL interface'i üzerinden gidelim.

  interface ICustomerDal  
  {
        List<Customer> GetAll();
        Customer Get(int id);
        void Add(Customer customer);
        void Update(Customer customer);
        void Delete(Customer customer);
  }

ICustomerDal customer classı için crud operasyonlarının imzalarını tutan bir interface. b

Burada bir sıkıntımız yok ancak aynı işlemlere ihtiyaç duyan birden fazla sınıfımız olunca ve işlemler birbirine çok benzeyince;

  interface IProductDal  
  {
        List<Product> GetAll();
        Product Get(int id);
        void Add(Product product);
        void Update(Product product);
        void Delete(Product product);
  }

Tip (customer,product) kısmını generic bir yapıyla halledebilirsek eğer bize çok faydası olacaktır.

Yeni bir interface oluşturuyorum ve ismini Irepository koyuyorum.

    interface IRepository<T>
    {
        List<T> GetAll();
        T Get(int id);
        void Add(T entity);
        void Update(T entity);
        void Delete(T entity);

    }

Yeni interface'imizin içerisine aynı metodları koyuyorum. Bu sefer listelerde gördüğümüz tip belirme olayını interface'in isimlendirme kısmında görüyoruz.

Bunun anlamı ben implemente edildiğim yerden bir tip alacağım ve içerimde bulunan metod ve alanlarda bu T yerine ne geldiyse onları uygulayacağım.

Kullanım Şekli

Artık ICustomerDal ve IProductDal interfacelerimizi boş bırakıyoruz ve Irepository implementasyonu gerçekleştiriyoruz.

    interface ICustomerDal:IRepository<Customer>
    {
       
    }
    interface IProductDal:IRepository<Product>
    {
        
    }

Görüldüğü gibi çalışacağımız tipi implemente ederken söylüyoruz ve kolayca uygulamış oluyoruz. Artık ortak operasyonları IRepository içerisine sadece product sınıfına veya customer sınıfına özel olan işleri ise onların interfaclerinde yazıyoruz ve aynı yapıyı daha az kod, daha sürdürülebilir bir yapı ile kurmuş oluyoruz.

Asp.Net Web Servis Giriş Rest-Ful Web Api

hdemiray — Mon, 21 Dec 2020 00:11:04 +0000

Web Servislere neden ihtiyaç duyulur ?

İnternete erişimi olan cihazların platform bağımlı olmaksızın bu cihazla iletişime geçmek ve http protokolü ile veri iletmek.

Metotlarımızı http protokolü üzerinden paylaşabiliriz.
Diğer yazılımcıların sadece arayüze odaklanması sağlanabilir.
İş bölümü için uygundur

Rest-Ful (Reperestantional State Transfer) : Restful Api'ler yukarıdaki 3 özelliğin tamamını sağlar.

Servislerde genelde ortak format olarak json format seçilir.

Json format hem hafiftir. (Boyut olarak)
Okunması diğer formatlara göre (xml vb..) çok daha kolaydır.
Kabul görmüş bir formattır genelde bu uygulanır.

Rest-ful Web Api'ler http protokolü kullanır , yani bir url'e ihtiyacımız var. Kısaca yazacağımız servisi kullanabilmek için server'a atmamız ve internete açmamız gerekir.

Url (https://api.github.com/users)
İnternet Media Type (Json,xml,images vs..)
Standart HTTP Metodları kullanırız (GET,POST,PUT,DELETE vs..)

WEB SERVİSLERİNİN AMACI FARKLI PLATFORMLAR ARASINDA AYNI VERİ PAYLAŞIMINI SAĞLAMAK

C# MVC Bundle Config İle Minify İşlemleri

hdemiray — Mon, 21 Dec 2020 00:01:34 +0000

Web sitelerinde açılışta her bir javascript ve css dosyaları için requestler gider ve bunların sayısı sitenin açılış hızını düşürebilir.

Bundle minify işlemi ile hem tüm scriptleri tek bir dosya ile gönderecek hemde dosyanın minify edilmesini yani yorum satırları silinmiş gereksiz satırlardan arınmış bir şekilde birleştirecek.

Bunun için ilk önce Projeye Nuget yardımı ile
Microsoft.Asp.Net.Optimization yüklenir
daha sonra yeni bir class açarız ve içerisine static bir metot yazarız ve bu dışarıdan BundleCollection tipinde veri alır

 public static void RegisterBundles(BundleCollection bundles)
        {
            bundles.Add(new ScriptBundle("~/bundles/scripts").Include(
               "~/Scripts/jquery-3.0.0.js",
               "~/Scripts/jquery.unobtrusive-ajax.min.js",
               "~/Scripts/bootstrap.js",
               "~/Scripts/DataTables/jquery.dataTables.js",
               "~/Scripts/DataTables/dataTables.bootstrap.js",
               "~/Scripts/custom.js",
               "~/Scripts/bootbox.js"
                ));

            bundles.Add(new StyleBundle("~/bundles/styles").Include(
                  "~/Content/bootstrap.css",
                  "~/Content/StyleSheet1.css",
                  "~/Content/DataTables/css/dataTables.bootstrap.css"
                ));
        }

ve buraya dosya yolları eklenir daha sonra layout 'tan bu alanlar silinir
yerlerine ise

@Scripts.Render("~/bundles/scripts")

@styles.Render("~/bundles/styles")

Eklenir daha sonra bu işlemi çağırmak için Global.asax dosyasına

BundleConfig.RegisterBundles(BundleTable.Bundles);

burada kendi yazdığımız sınıfı ve metodu çağırdık ve bundlecollection tipinde bir veri gönderdik.

Son olarak ise View'in altında bulunan webconfig dosyasına namespace ekleyeceğiz

<add namespace="System.Web.Optimization"/>

bu işlem proje yayınlanmadan önce yapılmalı yani bu şekilde proje geliştirmek sağlıklı değildir

C# Anti Forgery Token

hdemiray — Sun, 20 Dec 2020 23:53:45 +0000

CSRF saldırıları olarak geçen ;
arama çubuğunu post olarak veri yollamak veri ele geçirmek için kullanırlar.

Direkt oradan veri yollayamaması için controllerdan http post olan kısımı

[ValidateAntiForgeryToken] olarak başlatıyoruz ve pos formunun içerisine

@html.AntiforgeryToken()

metodunu koyuyoruz.

Abstract Classes / Abstract Sınıflar

hdemiray — Sun, 20 Dec 2020 23:50:14 +0000

Class yapısına sahiptir. Referans tiptir ama tamamen somut bir yapıya sahiptir.

Classın içerisinde operasyonlar bulunur.
Class : İçerisinde birbirisiyle ilgili operasyonları , field ve propertyleri tutan yapı.

Abstract Classta tanımlanan bir operasyon inherit edildiği sınıfta ezilmek (override) zorundadır.
Tamamlanmış operasyon (metod) da tutabilir yarım operasyonlarıda tutabilir(imza şeklinde).

Bir sınıf sadece bir sınıfı inherit edebileceği için dolayısı ile bir abstract class inherit edebilir başka bir classı inherit edemez.
Abstract classların normal classlardan tek farkı kabaca newlenememesi çünkü içerisinde tamamlanmamış operasyonlarda barındırabilir.

Peki abstract classlar constructor içerebilir mi ? Evet
Peki Nasıl çalışır ?

Sadece inherit edildiği class newlendiğinde çalışır ve constructor protected isim belirteci ile tanımlanmalıdır çünkü sadece inherit edildiği yerde kullanılabilir.

        abstract class MevzuatBase
        {
            public abstract void Degerlendir();
            public void Kaydet(){
                Console.Write("Kaydedildi !");
            }
        }
        class AMevzuat:MevzuatBase
        {
            public override void Degerlendir(){
                Console.Write("A Mevzuat Değerlendirdi !");
            }
        }
        
        class AMevzuat:MevzuatBase
        {
            public override void Degerlendir(){
                Console.Write("A Mevzuat Değerlendirdi !");
            }
        }```

C# Access Modifiers Private, Public, Internal, Protected Nedir ? / Erişim Bildirgeçleri

hdemiray — Sun, 20 Dec 2020 23:45:39 +0000

Bir class oluşturulduğunda bu classın default erişim belirteci internal 'dır.

Erişim Belirteçleri : Public, Internal, Protected, Private

Internal: Proje namespace'inden harici bir alanda referans verilse dahi kullanılamaz. Aynı assembly içinde geçerli demektir.

Public: Referans verildiği heryerde kullanılabilir. Farklı assemblylerde fieldd property yada classlarını kullanabilir.

En üst seviyeli bir class public veya internal olarak kullanılmak zorundadır.
Private veya protected olarak yalnızca başka bir classın içerisinde tanımlanabilir.

Private: Private sadece bir üst blokta geçerlidir(kıvırcık parantez). Ve inherit edildiği yerde kullanılamaz.

public class MyClass()
{
    class MyOtherClass()
    {
        //buradan alttaki değişkene erişemeyiz.
    }
    private MyPrivateClass()
    {
        //bu class yalnızca üst classta kullanılabilir.
        private int num=1;
    }
}

Bir field'ın default belirteci private'dır. Örn: int num=1; private bir değişkendir.

Protected: Private ile aynı özellikleri taşır bir üst parantezde çalışır onun haricinde inherit edildiği yerde de erişilebilir. Ancak private inherit edildiği yerde erişilemez.

IoC (Inversion of Control) Container

hdemiray — Sun, 20 Dec 2020 23:38:28 +0000

Nedir ? Dependency inversion uygularken kullandığımız dependency injection tasarım dilinde bir interface örneği istenirse ona somut olan sınıftan verir arkada örneğini tutar(new) ve yaşam döngüsünü tutar tek seferlikmi çalışacak (singelton) her seferinde yeniden mi oluşturulacak gibi.

Bu kontrol araçlarına örnek olarak

Ninject, Unity(Microsoft), Castle Windsow, Structure Map. Dry IoC , LightInject

Nasıl Kullanılır projeye eklenir.(Ninject)

Bunlar farklı dosyalardaki farklı configurasyonlar olarak düşünelim.

Katmanlar arası geçişte singleton kullanıyoruz

kernel.Bind<IMevzuat>().To<IkinciMevzuat>().SingletonScope(); 

CustomerManager CustomerManager=new CustomerManager(kernel.Get<IMevzuat>());
CustomerManager.Add();

Kernel bir kutu gibidir ona koyduğumuzu isteyen heryere dağıtır tek
Noktadan kontrol imkanı sunar.

C# Değer Ve Referans Tipler Nedir ? Farkları Nelerdir ? / Value And Referance Type What Are The Differences ?

hdemiray — Sun, 20 Dec 2020 23:34:45 +0000

Nesnel programlama büyük ölçüde referans tiplerin üzerine kuruludur.

Referans Tip Çalışma Şekli

Değer tip ve referans tipler bellekte iki ayrı alanda tutulur.
Bu alanlar Stack ve Heap bölümleridir.

Stack: alanında sayısal ifadeler tutulur bunlar değer tiplidir: int,double,decimal,bool(0,1),enum(1,2,3,4,5),stack(sınıflara benzer) tipte yapılar da stack alanında tutulur.

Değer tip sadece tanımlanan sayıda durur.
ÖRN:

int sayi1; Tanımladığı anda stackte tutulur

sayi1=10; Stack te sayi1=10 olarak tutulur
int sayi2=sayi1 Stack te sayi2=10 olarak tutulur ve sayi1 deki değişiklik sayi2 yi etkilemez.

Referans Tipler: class, interface,abstract class, string, diziler, int array de olsa dizide olsa referans tiplidir. Referans tipler newlenenlerdir (stack hariç).

EK BİLGİ: Stringler referans tiplidir ancak çalışma şekli değer tip gibidir.

string[] sehirler;Tanımladığımızda stackte yer tutar.

string[] sehirler = new string[]{"Ankara","İstanbul","İzmir"}; string[] sehirler2 = new string[]{"Adana","Bursa","Bolu"};

İçerisine değer verildiğinde bir numara atanır ve heap bölümünde new string[]{"Ankara","İstanbul","İzmir"}; şeklinde bu numara ile bir referans alanı tutar.

ASIL FARK BU NOKTADA

//bu iki değeri eşitlersek eğer

sehirler2 = sehirler;

bu iki değeri eşitlersek eğer sehirler2 tanımlanırken stackte aldığı numara sehirler dizisinin aldığı değere eşitleniyor ve her ikiside heap bölümünde aynı noktayı referans gösteriyor sehirler2 nin asıl değerine herhangi bir müdahele olmuyor

Bu noktada eğer şehirler 2 de bir alanda değişiklik yaparsak bu şehirler dizisinide etkileyecektir. Çünkü şehirler 2 de artık referans olarak şehirler dizisinin heapteki alanını gösteriyor.

sehirler2[0]= "Eskişehir"; Console.Write(sehirler[0]);

Bu koddan alacağımız sonuç Ankara değil "Eskişehir" olacaktır.

Peki şehirler2 nin başlangıçta gösterdiği referansa ne olacak ?

Garbage Collector dediğimiz nesne
Referansı kalmamış o referansı gösteren hiçbir tanım kalmamışsa
O referansı bellekten silecek yapıdır. Çöpçümüzdür.

Framework ve Library Nedir ? Farkları Nelerdir ?

hdemiray — Sun, 20 Dec 2020 23:19:31 +0000

Framework uygulama çatısıdır.

Uygulama o çatıda geliştirilir. Örn ASP.NET MVC

Kütüphane bir çatının altında yardımcı yapılardır.

Kütüphane basitleştirilmiş kod fonksiyonlar topluluğudur.
Framework bir uygulama çatısıdır uygulama o yapıya göre inşa edilir.
Örn AngularJs.

Yazılımda Interface Nedir ?

hdemiray — Sun, 20 Dec 2020 23:15:26 +0000

Yazılımsal olarak classlara arayüz görevi görür ve classların o operasyonları imzalamasını zorunlu hale getirir.

Sürdürülebilir yazılımın en büyük üyelerindendir.
Interface'ler ile sürdürülebilir yazlımlar geliştiririz.

Projelerimizde olay insanların gündelik hayatlarıdır. Dolayısı ile gündelik hayat her gün değişkenlik gösteriyor.
Kurallar değişiyo, ihtiyaçlar değişiyor vs.

Interfaceler ile yazılımda değişim denilen süreci kolayca yönetebiliyoruz. Yani if programcılığının önüne geçiyoruz ve spagetti kodlardan kurtuluyoruz.

public static void Main()
{

    CustomerManager CustomerManager =new CustomerManager(BirinciMevzuat);
}


class CustomerManager 
{

    private IMevzuat _mevzuat;
    public CustomerManager(IMevzuat mevzuat)
    {
        _mevzuat = mevzuat
    }
    public void Add()
    {
        _mevzuat.IslemYap();
    }
}
interface IMevzuat
{
    void IslemYap();
}
class BırıncıMevzuat: IMevzuat
{
    public void IslemYap()
    {
        Console.Write("Birinci Mevzuat işlem yaptı");
    }
}
class IkinciMevzuat: IMevzuat
{
    public void IslemYap()
    {
        Console.Write("İkinci Mevzuat işlem yaptı");
    }
}

SOLID Programlama Prensipleri / SOLID Principles

hdemiray — Sun, 20 Dec 2020 23:13:45 +0000

Prensipler bakımı ve anlaşılması kolay kod yazmak için vardır.

Bu prensiplerin nerede ve nasıl kullanılması bilinmesi gerekir.
Ama bu her zaman ve heryerde doğru olan bir önerme değildir.
(Örneğin prototip aşamasındaki bir proje için.)

S- Single Responsibility Principle

Bir Componenet sadece bir amaç için değiştirilmeli.
Component = Sınıf, library, fonksiyon vb..

Kodun küçük ve bir amaca hizmet eden compenentler şeklinde tasarlanması yeniden kullanilabilirliği arttırır.

Componentlerin küçük olması daha rahat anlaşılmalarını sağlar.

Eğer birden fazla amaca hizmet ediyorsa o zaman bu prensibi ihlal ediyor demektir.

Örneğin bir Account Sınıfı

using System;
using System.Collections.Generic;
using System.Text;
 
namespace SOLID
{
    public class Account
    {
 
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Street { get; set; }
        public int ZipCode { get; set; }
        public string City { get; set; }
        public Guid AccountId { get; set; }
        public string Password { get; set; }
        public string UserName { get; set; }
 
        public void ChangePasswırd(string newPassword) => Console.WriteLine($"Changed password to {newPassword}");
        public void ChangeAddress(string street, int zipCode, string city) => Console.WriteLine("Changed adress");
        public string GetAccountHolderFirstName(Guid accountNumber) => this.FirstName;
        public string GetAccountHolderLastName(Guid accountNumber) => this.LastName;
 
        public void DepositMoney(decimal amount) => Console.WriteLine($"{amount} has been deposited to {this.AccountId}");
        public void WithdrawMoney(decimal amount) => Console.WriteLine($"{amount} has been withdrawn from {this.AccountId}");
        public void Login(string username, string password) => Console.WriteLine($"{username} has tried to log in.");
        public void Logout(string username) => Console.WriteLine($"{username} has tried to log out.");
 
    }
}

Görüldüğü gibi içerisinde birçok metod özellik vb şeyler var.

class AddressVerifier
{
    public bool IsAddressValid(Account account)
    {
        //burada account ile tonlarca gereksiz ozellik geliyor
        return true;
    }
}

Burada Account sınıfı ile adresin doğruluğu kontrol edilmek isteniyor ancak adresten başka tonlarca özellik geliyor. Bu tarz sıkıntıları engellemek için ;

public class Account
{
    public Guid AccountId { get; set; }
    public Profile Profile { get; set; }
    public Address Address { get; set; }
}

public class Address
{
    public string  Street { get; set; }
    public int ZipCode { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
}
public class AddressVerifier
{
   public bool IsAdrressValid(Address address)
   {
        return true;
   }
}

Şeklinde yapmak en doğrusu olacaktır.

O - Open/Closed Principle

Bir Componenet değişime kapalı , gelişime açık olmalıdır. Var olan kodları değiştirerek değil genişleterek kullanmak.

Genelde (backward compatibility) sorunlarını çözmek için yararlı olur.

Örneğin zipCode yani Türkiye'de posta kodu olarak geçen bu kod ile o eyaletin veya şehrin var olup olmadığına bakacağız.

Burada basitçe gelen koda göre kodun geçerli olup olmadığı kontrol ediliyor. Bölge icabı zip Kod 10 un altında olanlar geçersiz koddur.

public class AddressVerifier
{
   public static bool IsValidZipCode(int zipCode)
   {
       if (zipCode < 10)
       {
           return false;
       }
       return true;
   }
}

Doğruluk kontrol edildikten sonra başka bir sınıfta kullanılıyor ve doğru bir kod ise karşılaştırmaya giriyor
public class StateFinder
{
    public String GetStateNameForZipCode(int zipCode)
    {
        if (!AddressVerifier.IsValidZipCode(zipCode))
        {
           throw new InvalidOperationException($"Invalid ZipCode : {zipCode}");
        }
 
        switch (zipCode)
        {
           case 11:
              return "California";
           case 12:
              return "Utah";
           default:
              throw new InvalidOperationException($"No state is found with {zipCode}");
        }
    }
}

namespace SOLID_S
{
    class Program
    {
        static void Main(string[] args)
        {
            var stateFinder = new StateFinder();
            try
            {
                Console.WriteLine(stateFinder.GetStateNameForZipCode(11));
                Console.WriteLine(stateFinder.GetStateNameForZipCode(9));
            }
            catch (InvalidOperationException exception)
            {
                Console.WriteLine(exception.Message);
            }
        }
    }
}

Böyle bir çalışmada ekrana çıkacak olan yazı;

Baştada söylendiği gibi değişime kapalı gelişime açık olmalı. Yani örneğin bir tane daha ülkenin desteklenmesi istendi
Ve bu ülkenin geçerli olan zip kodları bizimkini kapsıyor 10 dan küçük değilde 5 ten küçük olmayanlar geçersiz sayılıyor.
Bu durumda biz sınıfımızı değiştirmiş oluruz böylece kodda hatalar da yaratmış olabiliriz.

public class AddressVerifier
{
   public static bool IsValidZipCode(int zipCode)
   {
       if (zipCode < 5)
       {
           return false;
       }
       return true;
   }
}

Var olan bir sınıftaki metodu değiştirmiş olduk ve ihlal gerçekleştirmiş olduk. Bu bize programın işleyişinde hatalar getirecektir.
Yeni Ekran çıktısı;

Şimdi yapacağımız şey ise iki ülkenin farklı yerlerde değerlendirilmesini sağlamak.
Bunun için static metodumuz olan IsValidZipCode 'u virtual olarak tanımlıyoruz. Yeni bir sınıf açıyoruz ve implemente ediyoruz.

public class AddressVerifier
{
   public virtual bool IsValidZipCode(int zipCode)
   {
       if (zipCode < 10)
       {
           return false;
       }
       return true;
   }
}

public class GermanAddressVerifier : AddressVerifier
{
   public override bool IsValidZipCode(int zipCode)
   {
       if (zipCode < 5)
       {
           return false;
       }
       return true;
   }
}

Address verifier sınıflarımız bu şekilde olmalı.

namespace SOLID_S
{
    public class StateFinder
    {

    //Artık burada kullanılmak istenen ülkenin verifier'i gönderilecek.
        public string GetStateNameForZipCode(int zipCode,AddressVerifier verifier)
        {
            if (!verifier.IsValidZipCode(zipCode))
            {
                throw new InvalidOperationException($"Invalid ZipCode : {zipCode}");
            }
 
            switch (zipCode)
            {
                case 9:
                    return "Munih";
                case 8:
                    return "Berlin";
                case 11:
                    return "California";
                case 12:
                    return "Utah";
                default:
                    throw new InvalidOperationException($"No state is found with {zipCode}");
            }
        }
 
    }
}

SON OLARAK PROGRAM SINIFINA KULLANILISI GORMEK ICIN BAKARSAK
//Artık burada kullanılmak istenen ülkenin verifier'i parametre olarak gönderilecek.

namespace SOLID_S
{
    class Program
    {
        static void Main(string[] args)
        {
            var stateFinder = new StateFinder();
            try
            {
                var addressVerifier = new AddressVerifier();
 
                Console.WriteLine(stateFinder.GetStateNameForZipCode(11,addressVerifier));
                Console.WriteLine(stateFinder.GetStateNameForZipCode(9,addressVerifier));
            }
            catch (InvalidOperationException exception)
            {
                Console.WriteLine(exception.Message);
            }
 
            try
            {
                var addressVerifier = new GermanyAddressVerifier();
                Console.WriteLine(stateFinder.GetStateNameForZipCode(9, addressVerifier));
            }
            catch (InvalidOperationException exception)
            {
                Console.WriteLine(exception.Message);
            }
        }
    }
}

BU ŞEKİLDE ARTIK ADDRESS VERİFİER SINIFIMIZI DEĞİŞTİRMEMİŞ GELİŞTİRMİŞ OLDUK

L - Liskov's Substitution Principle

Birbirinden kalıtım alan sınıfların sistemi bozmadan değiştirilebilimesini esas alır.
Sistemin kararlılığının bozulmaması için değişim zamanında değişimin sorunsuz gerçekleşmesini istiyor.

*A - Invariants (Değişmeyen şeyler) *: Sınıfta asla değişmeyen özellikler : örneğin bir matematik sınıfı var ve içinde pi sayısını tutan değişken var bunun değişmemesi gerekir.

*B - Pre-Conditions (İşlem yapılmadan önce yapılan kontroller) *: Bir metod yazdınız örneğin para yatırma metodu miktar isimli bir parametre alıyor ve metodun doğru çalışması için belli değerler arasında değerler alması bekleniyor. Miktar eksi olması beklenmez miktarı kontrol etme işlemi pre-conditions'lardandır.

*C - Post-conditions (İşlem sonrası yapılan kontroller) *: Örneğin para yatırma işlemi tamamlandı daha sonra paranın 0 ' dan büyük olmasının kontrolünü sağlamak post-conditions'lardır.

Bu kontroller sayesinde yapılan hatalar hemen farkedilir ve sistemin yanlış verilerle çalışmaması sağlanır.

namespace SOLID_S
{
    //KONTROLCU BIR SINIF YAPIYORUZ 
    public class Require
    {
        public static void That(Func<bool> check)
        {
            if (!check())
            {
                throw new ArgumentException("Invalid argument has been passed");
            }
        }
    }
}

REQUIRE SINIFININ POST CONDITION'I ADDRESS SERVICE SINIFININ PRE-CONDITION'IDIR

YANI BIR KODUN POST CONDITION'I BASKA BIR KOD PARCASININ PRE-CONDITION'I OLABILIR

namespace SOLID_S
{
    public class AddressService
    {
        public void ChangeAddress(Guid accountId, Address newAddress) => Console.WriteLine("Changed address"); 
 
        public virtual Address GetAddressForUser(int userId)
        {
            Require.That(() => userId > 10);
 
            var address = new Address()
            {
                Street = "Testreet",
                ZipCode = 12312,
                City = "Tokat",
                Country = "USA",
                State = "New England"
 
            };
 
            Require.That(() => address.ZipCode > 1000);
            return address;
        }
    }
}

public class AccountService
{
    public void ChangeAddress(Address address)
    {
        Require.That(() => address.ZipCode > 1000); 
        Console.WriteLine("Account address has been changed succesfully");
    }
}

BU SEKILDE YAZILIMA KONTROLLER KOYARAK YAPILAN HATALARI CABUK ALGILAMA VE OLASI DURUMLARI ONLEME ICIN TEDBIRLER OLUSTURULMUSTUR

I - Interface Segregation Principle

Başka sınıfları kullanan kodların ihtiyaçlarından fazlasını kullanmasını engellemek ve bu sayede
Bakımını ve okunabilirliğini arttırmak amacıyla sunulmuş bir prensiptir.

Bir sınıfın işlevleri tutarlı ve ufak arayüzler ile bölünür.

Örneğin bir aşevi classimiz olsun ve bu aşevi class'ı insanlara yemek verme metodu olsun.

public interface IHuman
{
    void Eat();
    void Talk();
    void Walk();
    void Sleep();
}

public class Asevi
{
    public void AddToList(IHuman human)
    {
        throw new NotImplementedException();
    }
}

Eğer buraya bir hayvan ekleyecek olursak onun içinde ayrı bir metod yazmamız gerekir şöyle ki;

public interface IAnimal
{
    void Eat();
    void Talk();
    void Walk();
    void Sleep();
    void Bite();
}

public class Asevi
{
    public void AddToList(IHuman human)
    {
        throw new NotImplementedException();
    }

    public void AddToList(IAnimal animal)
    {
        throw new NotImplementedException();
    }
}

Görüldüğü gibi bir metod daha eklemem gerekiyor ve kodlar fazlaca büyüyor. Asevinin aradığı ortak özelliği
Yani yemek yeme özelliğini kullanarak tek metodda bu işi çözebiliriz ve aralarında ilişki oluşturmuş oluruz.

namespace SOLID_I
{
    public class Asevi
    {
        public void AddToList(IOmnivore human)
        {
            throw new NotImplementedException();
        }
    }
 
    public interface IHuman :IOmnivore
    {
        void Talk();
        void Walk();
        void Sleep();
    }
 
    public interface IAnimal :IOmnivore
    {
        void Walk();
        void Sleep();
        void Bite();
    }
 
    public interface IOmnivore
    {
        void Eat();
    }
}

Her ikisinin icerisindeki yemek yeme fonksiyonunu interface olarak SEGREGATE (ayırma) ettik ve onu human ile animal interface'lerine miras olarak aldık böylece ikiside eat fonksiyonunu bir interface 'dan almış oldu ve Asevi sınıfına tek bir metod eklemek yeterli gelmiş oldu. Bundan sonraki eklenecek farklı canlı türlerinde yemek yemesi ana özellik olarak alınacak ve hala tek bir metod üzerinden sürdürülebilir olacak.

D - Dependency Inversion Principle

Yüksek seviyeli sınıfların düşük seviyeli sınıfları kendi halleriyle değilde soyut halleri ile kullanmasını konu alır. Buda bağımlılığı düşürür.

Genel anlamda anlattığı şey bir sınıf eğer başka bir sınıfı kullanacaksa onu newlemeden yani soyut bir başka sınıf ile kullanmalıdır.

Dependenc Inversion Prensibinde temel olarak bir tasarım dili kullanılır bu Dependency Injection'dır

Ctor'dan bağımlılık sınıfının implementasyonu olan interfacei geçmektir.

class CustomerManager 
{
    private IMevzuat _mevzuat;
    public CustomerManager(IMevzuat mevzuat)
    {
        _mevzuat = mevzuat
    }
    public void Add()
    {
        _mevzuat.IslemYap();
    }
}



class CustomerManager 
{
    private IMevzuat _mevzuat;
    public CustomerManager(IMevzuat mevzuat)
    {
        _mevzuat = mevzuat
    }
    public void Add()
    {
        _mevzuat.IslemYap();
    }
}
interface IMevzuat
{
    void IslemYap();
}
class BırıncıMevzuat: IMevzuat
{
    public void IslemYap()
    {
        Console.Write("Birinci Mevzuat işlem yaptı");
    }
}
class IkinciMevzuat: IMevzuat
{
    public void IslemYap()
    {
        Console.Write("İkinci Mevzuat işlem yaptı");
    }
}

Bu yapı sayesnde yeni mevzuat eklense dahi customer manager sınıfında herhangi bir değişiklik yapmaya gerek kalmaz interface onu otomatık getirir.

Katmanlı mimarilerdeki katmanların geçişini sağlamak için dependency injection tasarım deseni yaygın olarak kullanılır. (Bkz: IoC Container Link)

Business katmanı veri erişim katmanı ile iletişim kurarken veri erişim katmanındaki somutla değil soyutla iletişim kurar.
Eğer veri erişim katmanında entity framework ile yapılmışsa ve ileride bunu değiştirereceği zaman business katmanında değişmemesi için.