SOLID Prensipleri: Yazılım Tasarımının Temel Taşları

SOLID Prensipleri: Yazılım Tasarımının Temel Taşları

Yazılım geliştirme sürecinde kaliteli, esnek ve sürdürülebilir bir kod üretmek, geliştiricilerin ve yazılım projelerinin başarısını belirleyen önemli bir faktördür. Bu hedeflere ulaşmada yardımcı olan SOLID prensipleri, yazılım tasarımındaki temel taşları oluşturur. Bu prensipler, yazılımın değişime açık, anlaşılır ve bakımı kolay olmasını sağlamak amacıyla geliştirilmiştir.

SOLID prensipleri, yazılım tasarımında esneklik, sürdürülebilirlik ve anlaşılabilirlik sağlamak adına güçlü bir temel oluşturur. Bu prensipleri anlamak ve uygulamak, yazılım projelerinin başarıya ulaşmasında önemli bir rol oynar. Her bir prensip, yazılım geliştiricilerine daha etkili ve kaliteli kod yazmaları konusunda rehberlik eder.

1. Tek Sorumluluk Prensibi (Single Responsibility Principle – SRP):

Tek Sorumluluk Prensibi, bir sınıfın yalnızca bir sorumluluğu olması gerektiğini savunur. Bu prensip, bir sınıfın tek bir işlevi yerine getirmesini ve bu sayede değişikliklere karşı daha dirençli olmasını amaçlar. Bir sınıfın birden fazla sorumluluğu üstlenmesi, bakım maliyetini artırabilir ve kodun karmaşıklığını artırabilir.

// Kötü tasarlanmış sınıf
public class DosyaIslemleri 
{
    public void DosyaOku() 
    {
        // ...
    }

    public void VeritabaniBaglantiKur() 
    {
        // ...
    }
}

// İyi tasarlanmış sınıflar
public class DosyaOkuma 
{
    public void DosyaOku() 
    {
        // ...
    }
}

public class VeritabaniBaglanti 
{
    public void BaglantiKur() 
    {
        // ...
    }
}

2. Açık/Kapalı Prensibi (Open/Closed Principle – OCP):

Açık/Kapalı Prensibi, bir sınıfın değişikliklere kapalı ancak yeni özelliklere açık olması gerektiğini belirtir. Yani mevcut kodu değiştirmek yerine, yeni özellikler ekleyerek genişletilebilir bir tasarım hedeflenir. Bu prensip, yazılımın modülerliğini artırarak gelecekteki değişikliklere karşı direncini sağlar.

// Kötü tasarlanmış sınıf
public class Odeme 
{
    public void OdemeYap(string odemeTipi) 
    {
        if (odemeTipi == "Nakit") 
        {
            // ...
        } 
        else if (odemeTipi == "KrediKarti") 
        {
            // ...
        }
    }
}

// İyi tasarlanmış sınıflar
public abstract class Odeme 
{
    public abstract void OdemeYap();
}

public class NakitOdeme : Odeme 
{
    public override void OdemeYap() 
    {
        // ...
    }
}

public class KrediKartiOdeme : Odeme 
{
    public override void OdemeYap() 
    {
        // ...
    }
}

3. Liskov Yerine Koyma Prensibi (Liskov Substitution Principle – LSP):

Liskov Yerine Koyma Prensibi, türetilmiş sınıfların, temel sınıfların yerine geçebilmesi gerektiğini ifade eder. Bu prensip, miras alınan sınıfların, üst sınıfların beklenen davranışlarını sergilemesini ve kullanımı kolay olmasını sağlar.

// Kötü tasarlanmış sınıf
public class Kus 
{
    public void Uc() 
    {
        // ...
    }
}

// İyi tasarlanmış sınıflar
public class Hayvan 
{
    public void HareketEt() 
    {
        // ...
    }
}

public class Marti : Hayvan 
{
    public void Yuz() 
    {
        // ...
    }
}

4. Arayüz Ayrımı Prensibi (Interface Segregation Principle – ISP):

Arayüz Ayrımı Prensibi, bir arayüzün, kullanıcısına sadece ihtiyaç duyduğu metodları sunması gerektiğini belirtir. Bu prensip, bir sınıfın, kendisi için gereksiz metodları içeren bir arayüzü uygulamamasını amaçlar.

// Kötü tasarlanmış arayüz
public interface IOtomobil 
{
    void Sur();
    void ParkEt();
}

// İyi tasarlanmış arayüzler
public interface ISurulebilir 
{
    void Sur();
}

public interface IParkEdilebilir 
{
    void ParkEt();
}

5. Bağımlılıkların Tersine Çevrilmesi Prensibi (Dependency Inversion Principle – DIP):

Bağımlılıkların Tersine Çevrilmesi Prensibi, yüksek seviyeli modüllerin düşük seviyeli modüllere bağlı olmaması, her ikisinin de soyuta bağlı olması gerektiğini belirtir. Bu prensip, yüksek seviyeli modülün, düşük seviyeli modülün detaylarına bağlı olmamasını sağlayarak esnek bir tasarım hedefler.

// Kötü tasarlanmış sınıf
public class VeritabaniBaglanti 
{
    public void Baglan() 
    {
        // ...
    }
}

public class Islem 
{
    private readonly VeritabaniBaglanti _baglanti;

    public Islem() 
    {
        _baglanti = new VeritabaniBaglanti();
    }
}

// İyi tasarlanmış sınıflar
public interface IVeritabaniBaglanti 
{
    void Baglan();
}

public class VeritabaniBaglanti : IVeritabaniBaglanti 
{
    public void Baglan() 
    {
        // ...
    }
}

public class Islem 
{
    private readonly IVeritabaniBaglanti _baglanti;

    public Islem(IVeritabaniBaglanti baglanti) 
    {
        _baglanti = baglanti;
    }
}

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir