SOLID Prensipleri: Yazılımda Sağlam Temeller

21 Mart 2025 Cuma 12:49
Yazılım Geliştirme
22 dk.

SOLID prensipleri, Robert C. Martin (Uncle Bob) tarafından ortaya atılmış ve yazılım geliştirme süreçlerinde daha esnek, sürdürülebilir ve bakım maliyetleri düşük sistemler oluşturmayı amaçlayan beş temel prensibi içeren bir yaklaşımdır. Bu prensiplerin her biri, yazılımın uzun vadede daha okunabilir, genişletilebilir ve yönetilebilir olmasını sağlamak için geliştirilmiştir.

Neden SOLID Prensipleri Kullanılır?

Yazılım projeleri, zaman içinde büyüdükçe ve geliştikçe karmaşıklıkları artar. Bu büyüme, kodun anlaşılırlığını azaltabilir, bakım maliyetlerini artırabilir ve değişiklik yapmayı zorlaştırabilir. SOLID prensipleri, bu tür sorunları önlemek için geliştirilmiş ve yazılım mühendisliği disiplininde bir standart haline gelmiştir.

SOLID prensipleri uygulanmadığında:

Kod tekrarları artar ve yönetimi zorlaşır.
Kod değişiklikleri başka bileşenleri etkileyebilir ve hata yapma olasılığı yükselir.
Genişletilebilirlik ve ölçeklenebilirlik sorunları ortaya çıkar.
Ekip içinde bilgi paylaşımı ve kod okunabilirliği azalır.
Yeni geliştiricilerin projeye adapte olması zorlaşır.
Uzun vadede bakım ve geliştirme maliyetleri artar.

WAGONN olarak, kurumsal yazılım projelerinde sürdürülebilirlik ve ölçeklenebilirliği sağlamak için SOLID prensiplerini esas alarak danışmanlık sunuyoruz. Yazılım projelerinizi en iyi şekilde yönetmek için bizimle iletişime geçebilirsiniz: İletişim.

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

Bu prensip, her sınıfın yalnızca bir sorumluluğu olması gerektiğini belirtir. Yani, bir sınıf yalnızca bir amaca hizmet etmeli ve değişmesi için yalnızca bir sebep olmalıdır.

Örnek:

<code class="csharp csharp-code">public class UserManager 
{
    public void AddUser(User user) 
    {
        // Kullanıcı ekleme işlemi
    }
}

public class EmailService 
{
    public void SendEmail(User user) 
    {
        // E-posta gönderme işlemi
    }
}</code>

Bu sayede her sınıf, kendi alanında tek bir sorumluluğa sahip olur.

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

Bu prensip, bir yazılım bileşeninin genişletilmeye açık ancak değiştirmeye kapalı olması gerektiğini belirtir. Mevcut kodu değiştirmek yerine, yeni özellikler eklenebilmelidir.

Örnek:

<code class="csharp csharp-code">public interface IFileProcessor 
{
    void Process();
}

public class PdfProcessor : IFileProcessor 
{
    public void Process() { /* PDF işleme */ }
}

public class WordProcessor : IFileProcessor 
{
    public void Process() { /* Word dosyası işleme */ }
}</code>

Bu yapıda yeni bir dosya türü eklemek için mevcut kodu değiştirmeye gerek yoktur.

3. Liskov Substitution Principle (LSP) - Liskov Yerine Koyma Prensibi

Bir alt sınıfın, üst sınıfın yerine sorunsuzca kullanılabilmesi gerektiğini belirtir.

Yanlış Kullanım:

<code class="csharp csharp-code">public class File
{
    public virtual void Compress() { }
}

public class ReadOnlyFile : File
{
    public override void Compress() 
    {
        throw new Exception("Read-only files cannot be compressed!");
    }
}</code>

Burada ReadOnlyFile, File sınıfını miras almasına rağmen Compress metodunu kullanamıyor. Doğru tasarım şu şekilde olabilir:

<code class="csharp csharp-code">public abstract class File {}

public class CompressibleFile : File
{
    public void Compress() { }
}

public class ReadOnlyFile : File
{
    public void Open() { }
}</code>

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

Bir sınıfın, ihtiyacı olmayan metodları içeren geniş bir arayüzü uygulamak zorunda olmaması gerektiğini belirtir.

Yanlış Kullanım:

<code class="csharp csharp-code">public interface INotify
{
    void SendEmail();
    void SendSms();
}</code>

Eğer PushNotificationService sınıfı bu arayüzü uygularsa, SendSms() metodunu gereksiz yere implement etmek zorunda kalır. Bunun yerine arayüzleri ayırabiliriz:

<code class="csharp csharp-code">public interface IEmailNotifier
{
    void SendEmail();
}

public interface ISmsNotifier
{
    void SendSms();
}</code>

Bu sayede her sınıf yalnızca ilgili metodları uygulamak zorunda kalır.

5. Dependency Inversion Principle (DIP) - Bağımlılıkların Ters Çevrilmesi Prensibi

Yüksek seviyeli modüllerin düşük seviyeli modüllere doğrudan bağımlı olmaması gerektiğini belirtir. Bunun yerine, soyutlamalar kullanılmalıdır.

Doğru Kullanım:

<code class="csharp csharp-code">public interface INotificationService
{
    void Notify();
}

public class EmailNotification : INotificationService
{
    public void Notify() { }
}

public class NotificationManager
{
    private INotificationService _service;
    public NotificationManager(INotificationService service) { _service = service; }
    public void Send() { _service.Notify(); }
}</code>

Sonuç

SOLID prensipleri, yazılım geliştirirken sürdürülebilir, esnek ve düşük maliyetli çözümler üretmemizi sağlar. WAGONN olarak, müşterilerimize en iyi yazılım çözümlerini sunarak projelerini ölçeklenebilir ve sürdürülebilir hale getirmelerine yardımcı oluyoruz. Projelerinizde en iyi yazılım mimarisini oluşturmak için bizimle iletişime geçebilirsiniz: WAGONN ile hemen İletişim geçmek için tıklayınız.

Çerezleri Kullanıyoruz