C# 8.0 – Default Implementations In Interfaces

Merhaba;

Bir sınıfın imzası olan ve içerisinde tanımlanmış olan üyeleri ilgili sınıfa implement etmeye zorlayan interface yapıları C# 8.0 ile radikal bir yenilikle karşımıza gelmiş bulunmaktadır. Bu içeriğimizde C# 8.0 ile interfacelere özel gelen Default Implementations özelliği üzerine konuşuyor olacağız.

Interface; içerisine tanımlayacağımız ve kendisinden türetilecek olan sınıflarda uygulatacağımız memberların sade ve sadece imzasını tutmakta, gövdelerini derived classlarda oluşturmaya zorlamaktadır. Bu durum interface’in bir sınıfın imzası olmasını sağlayan temel çalışma yapılanmasının ta kendisidir.

C# 8.0 ile Default Implementations özelliği ile artık interface yapılarında istenilen üyelerin gövdeleri oluşturulabilmekte ve kendisinden kalıtım alan nesneler üzerinde ilgili üye çalıştırılabilmektedir.

    interface IExample
    {
        void X();
    }
    class ExampleClass : IExample
    {
        public void X()
        {
            Console.WriteLine("X metodu.");
        }
    }

Yukarıdaki örnek kod bloklarını incelerseniz eğer; “IExample” interface’inden türetilen “ExampleClass” classında interface içerisindeki metot zoraki uygulanmaktadır. Evet… Bu, bu güne kadar kullandığımız ve bildiğimiz bir durumdur.

Eğer ki;

    interface IExample
    {
        void X();
        void Y()
        {
            Console.WriteLine("Y metodu.");
        }
    }

şeklinde bir inşada bulunursanız C# 8.0 versiyonu sayesinde bir müddet alışmamızın zahmetli olacağı bu tanımlamayı yapabilirsiniz.

    class ExampleClass : IExample
    {
        public void X()
        {
            Console.WriteLine("X metodu.");
        }
    }

Default Implementations olarak tanımlanan “Y” metodu gövdesi interface’de mevcut olduğundan dolayı ilgili interfaceden türetilen classlarda implement edilmeye zorlanmayacaktır. Bu şekilde bir tanımlama interface referansı üzerinden direkt olarak erişilebilir bir şekilde public özelliği gösterecektir. Ayriyetten bu üyenin başında istenilen erişim belirleyicisi kullanılabilir.

        static void Main(string[] args)
        {
            IExample x = new ExampleClass();
            x.Y();
        }

Ayriyetten aşağıdaki gibi static keywordü ile işaretleyip ilgili memberı static belleğe yükleyebilir ve interface tipi üzerinden erişebiliriz.

    interface IExample
    {
        void X();
        static void Y()
        {
            Console.WriteLine("Y metodu.");
        }
    }
        static void Main(string[] args)
        {
            IExample.Y();
        }

Şimdi bu özelliği gördükten sonra aklınıza soyut sınıflar gelmiş olabilir ve ‘abstract class’lar bu ve buna benzer işlemler için oluşturulmuş değiller mi?‘, ‘interface’ler, class’lar gibi davranıyorsa eğer çoklu kalıtıma geri dönmüyor muyuz?‘ ya da ‘sanki artık interface’in normal sınıftan bir farkı kalmadı‘ vs. şeklinde sorular sorabilirsiniz.

Şahsen bu özelliğin geniş stratejik yapılanmalarda tarifi olamayacak kritik durumları dolaylı ve maliyetli yöntemlerle geçiştirmektense, pratik ve etkili bir çözüm sunmakta olduğunu düşünüyorum. Tabi ki de bu şekilde çelişkilere düşünülmesinide doğal görüyorum. Nihayetinde C# programlama dili burada gelen sorumluluğu parça parça üstlenen farklı enstrünmanlar(Abstract Class, Interface) barındırmaktadır. Birde bunun yanında bu özellik eklenmiştir. Dolayısıyla sahada operasyonel durumlarda Default Implementation’ın mı yoksa Abstract Class yapısının mı kullanılacağına dair tercih müşkülatının yaşanabilmesi yüksek ihtimaldir. Tüm bunların yanında C#’ın mevcut haliyle öğrenilmesi zor bir dil haline gelmiş olmasıda cabasıdır.

İlgilenenlerin faydalanması dileğiyle…
Sonraki yazılarımda görüşmek üzere…
İyi çalışmalar…

Bunlar da hoşunuza gidebilir...

Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

*

Copy Protected by Chetan's WP-Copyprotect.