SOLID, yazılım geliştirme sürecinde kodun daha okunaklı, esnek ve sürdürülebilir olmasını sağlayan beş temel prensibi ifade eder. Bu prensipler, Robert C. Martin (Uncle Bob) tarafından tanımlanmıştır ve nesne yönelimli programlamanın (OOP) en iyi uygulamalarını temsil eder. İşte SOLID prensiplerinin açıklamaları ve her biri için birer örnek:

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

Bir sınıfın yalnızca tek bir sorumluluğu olmalıdır. Yani, bir sınıf yalnızca tek bir amaç için değiştirilebilir olmalıdır.

Örnek:

Yanlış kullanım:

class ReportGenerator
{
    public void GenerateReport() { /* Rapor oluşturma işlemleri */ }
    public void SaveToFile() { /* Dosyaya kaydetme işlemleri */ }
}

Doğru kullanım:

class ReportGenerator
{
    public string GenerateReport() { return "Rapor İçeriği"; }
}

class FileManager
{
    public void SaveToFile(string content) { /* Dosyaya kaydetme işlemleri */ }
}

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

Bir sınıf genişletilmeye açık, ancak değiştirilmeye kapalı olmalıdır. Yani, mevcut kod değiştirilmeden yeni işlevler eklenebilmelidir.

Örnek:

Yanlış kullanım:

class DiscountCalculator
{
    public double CalculateDiscount(string customerType, double price)
    {
        if (customerType == "Regular") return price * 0.9;
        else if (customerType == "VIP") return price * 0.8;
        return price;
    }
}

Doğru kullanım (Genişletilebilir bir yapı kullanımı):

interface IDiscountStrategy
{
    double ApplyDiscount(double price);
}

class RegularDiscount : IDiscountStrategy
{
    public double ApplyDiscount(double price) => price * 0.9;
}

class VIPDiscount : IDiscountStrategy
{
    public double ApplyDiscount(double price) => price * 0.8;
}

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

Bir alt sınıf, üst sınıfın yerine kullanılabilmelidir ve programın davranışı bozulmamalıdır.

Örnek:

Yanlış kullanım:

class Bird
{
    public virtual void Fly() { }
}

class Penguin : Bird
{
    public override void Fly() { throw new Exception("Penguenler uçamaz!"); }
}

Doğru kullanım:

abstract class Bird { }

interface IFlyable
{
    void Fly();
}

class Sparrow : Bird, IFlyable
{
    public void Fly() { /* Uçma işlemi */ }
}

class Penguin : Bird
{
    // Uçamayan bir kuş olarak tanımlandı
}

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

Büyük ve kapsamlı arayüzler yerine, daha küçük ve özelleşmiş arayüzler oluşturulmalıdır.

Örnek:

Yanlış kullanım:

interface IWorker
{
    void Work();
    void Eat();
}

class Robot : IWorker
{
    public void Work() { /* Çalışma işlemi */ }
    public void Eat() { throw new Exception("Robotlar yemek yemez!"); }
}

Doğru kullanım:

interface IWorkable { void Work(); }
interface IEatable { void Eat(); }

class Human : IWorkable, IEatable
{
    public void Work() { /* Çalışma işlemi */ }
    public void Eat() { /* Yemek yeme işlemi */ }
}

class Robot : IWorkable
{
    public void Work() { /* Çalışma işlemi */ }
}

5. Dependency Inversion Principle (DIP) – Bağımlılığı Ters Çevirme Prensibi

Üst seviye modüller, alt seviye modüllere doğrudan bağımlı olmamalıdır. Bunun yerine, her ikisi de soyutlamalara (interface veya abstract sınıflar) bağımlı olmalıdır.

Örnek:

Yanlış kullanım:

class DatabaseLogger
{
    public void Log(string message) { /* Log işlemi */ }
}

class Service
{
    private DatabaseLogger _logger = new DatabaseLogger();
    public void DoSomething() { _logger.Log("İşlem yapıldı"); }
}

Doğru kullanım:

interface ILogger
{
    void Log(string message);
}

class DatabaseLogger : ILogger
{
    public void Log(string message) { /* Log işlemi */ }
}

class Service
{
    private readonly ILogger _logger;
    public Service(ILogger logger) { _logger = logger; }
    public void DoSomething() { _logger.Log("İşlem yapıldı"); }
}

Sonuç olarak;

SOLID prensipleri, yazılım projelerinin sürdürülebilir, esnek ve kolay bakım yapılabilir olmasını sağlar.

• SRP ile her sınıfın tek bir sorumluluğu olur.
• OCP sayesinde mevcut kod bozulmadan genişletilebilir.
• LSP ile alt sınıflar, üst sınıfların yerine sorunsuzca kullanılabilir.
• ISP ile gereksiz bağımlılıklar azaltılır.
• DIP ile modüller arası bağımlılıklar en aza indirilerek daha esnek bir yapı oluşturulur.

Bu prensiplere uygun kod yazmak, yazılım projelerinizin daha sağlıklı ve uzun ömürlü olmasına katkı sağlayacaktır.