C#

Liskov Yerine Geçme Prensibi

Herkese merhaba, C# yazılarımıza kaldığımız yerden devam ediyoruz. Bu yazımızda SOLID prensiplerinden biri olan Liskov Yerine Geçme Prensibi’ni anlatacağım. Hadi başlayalım !

Yazıyı C# kategorisi altında yazmış olsam da aslında C#’a ait bir özellik değil, nesne tabanlı programlama yapabileceğiniz Java, Python, Dart gibi tüm dillerde bu prensibi uygulayabilirsiniz. Yani Liskov Yerine Geçme Prensibi C#’a özgü bir şey değil, diğer tüm SOLID prensiplerinde olduğu gibi daha temiz ve anlaşılır kod yazmak için uyulması gereken yazılı olmayan kurallardan birisidir.

Liskov Yerine Geçme Prensibi Nedir ?

Liskov Yerine Geçme Prensibi (LSP), bir alt sınıfın bir üst sınıfın yerine geçebilmesi gerektiğini söyleyen bir nesne yönelimli programlama prensibidir. Bu prensip, bir alt sınıfın, üst sınıfın tüm işlevlerini aynı şekilde yerine getirebildiği ve hiçbir istisna olmadığı sürece doğru bir şekilde uygulanır. Bu prensip, nesne yönelimli programlama prensiplerinin temel bir parçasıdır ve yazılım geliştiricilerinin kodlama yaklaşımlarında ve tasarımlarında dikkate almaları gereken önemli bir kavramdır.

C# gibi modern programlama dilleri, LSP’yi uygulamak için bir dizi özellik ve araç sağlar. Bu makale, C# örnek kodları kullanarak Liskov Yerine Geçme Prensibi’nin ne olduğunu ve nasıl uygulandığını açıklamaktadır.

LSP’nin temel prensibi, bir alt sınıfın, üst sınıfın yerine geçebilmesi gerektiğidir. Bu, alt sınıfın, üst sınıfın tüm işlevlerini aynı şekilde yerine getirdiği anlamına gelir. Bu durumda, alt sınıf, üst sınıfın herhangi bir kodunu bozmamalıdır. Bu nedenle, LSP, alt sınıfın, üst sınıfın davranışlarını ve işlevlerini değiştirmeden önce bu davranışların nasıl çalıştığını anlamasını gerektirir.

C# İle Uygulanması

Aşağıdaki örnekte, bir LSP ihlali örneği verilmiştir:

public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }
 
    public int Area()
    {
        return Width * Height;
    }
}
 
public class Square : Rectangle
{
    public override int Width
    {
        set { base.Width = base.Height = value; }
    }
 
    public override int Height
    {
        set { base.Width = base.Height = value; }
    }
}

Bu örnek, Kare sınıfını dikdörtgen sınıfının alt sınıfı olarak tanımlar. Ancak, bu durumda, Kare sınıfı, LSP’yi ihlal eder. Nedeni, Kare sınıfının Width ve Height özelliklerinin her ikisini de aynı anda ayarlayarak bir kare oluşturmasıdır. Bu, dikdörtgen sınıfının özelliklerini kullanan kodlarda beklenmeyen sonuçlara neden olabilir.

Bu LSP ihlalini çözmek için, Kare sınıfını, dikdörtgen sınıfının özelliklerini devralmak yerine, iki ayrı özellik olarak tanımlamalıyız:

public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }
    public int Area()
    {
         return Width * Height;
    }
}

public class Square : Rectangle
{
     private int _size;
     public int Size
     {
          get { return _size; }
          set { _size = value; Width = Height = value; }
     }
}

Bu yeni örnekte, Kare sınıfı artık Width ve Height özelliklerini devralmıyor. Bunun yerine, Kare sınıfı bir Size özelliği tanımlar. Size özelliği, dikdörtgen sınıfının alanı hesaplamak için kullanılan Width ve Height özelliklerini ayarlar. Bu nedenle, Kare sınıfı, dikdörtgen sınıfının yerine geçebilir ve LSP prensibine uygun olarak çalışır.

Bu basit örnekle birlikte, LSP’nin önemli bir konsept olduğu açıkça görülmektedir. Yazılım geliştiricilerinin, LSP’yi uygularken dikkatli olmaları ve her zaman üst sınıfların davranışlarını ve işlevlerini anlamaları gerekir.

LSP’nin önemi, birçok modern programlama dilinde yer alan araçlarla daha da artar. Örneğin, C#’da bir nesne yönelimli programlama konsepti olan arayüzler, LSP prensibinin uygulanmasını kolaylaştırır. Arayüzler, alt sınıfların, bir arayüzü uygulayarak bir üst sınıfın yerine geçmesine izin verir. Bu sayede, LSP’ye uygunluğu sağlamak daha kolay hale gelir.

Sonuç

Özetle, Liskov Yerine Geçme Prensibi, bir alt sınıfın bir üst sınıfın yerine geçebilmesi gerektiğini söyleyen önemli bir nesne yönelimli programlama prensibidir. Bu prensip, yazılım geliştiricilerinin kodlama yaklaşımlarında ve tasarımlarında dikkate almaları gereken bir konsepttir. C# gibi modern programlama dilleri, LSP’yi uygulamak için bir dizi araç ve özellik sağlar. LSP ihlallerinin önlenmesi, yazılım projelerinin güvenilirliğini ve sürdürülebilirliğini artırır.

Tüm C# yazılarımıza buraya, diğer SOLID prensipleri yazılarımıza buraya tıklayarak ulaşabilirsiniz. Herkese hayırlı günler.

Skorumuz:
Oy Vermek İçin Tıklayın
[Toplam: 0 Ortalama: 0]

Bir yanıt yazın

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

Göz Atın
Kapalı
Başa dön tuşu