.NET Framework ile geliştirdiğiniz uygulamaları genişletebilmek adına, 3.5 yıl önce Microsoft .NET Framework ile geliştirilmiş bir framework sunmuştu hatırlarsanız. Managed Extensibility Framework(MEF) ile uygulamalarımızı artık daha kolay bir şekilde genişletebilir hale gelmiştik. O zamandan bu zamana kadar MEF’in DI(Dependency Injection) ve IoC (Inverse of Control) açısından farkları, eksiklikleri çok tartışılsa da, MEF’in geliştirdiğiniz uygulamaları genişletebilmek adına ciddi anlamda faydalı bir çözüm olduğu sanırım ortak buluşulan nokta. Bu noktada MEF ile çeşitli DI ve IoC yaklaşımlarını uygulayabildiğinizi ama MEF’in bir IoC Container’ı olmadığının altını çizerek bu konuya çok girmeden, asıl konumuza geçiyorum…

.NET Framework 4.5 ile MEF tarafında gelen oldukça faydalı değişikliklerden bahsediyor olacağım. Biraz fazla kod örneği şeklinde olacağı için daha önce MEF ile çalışmamış kişiler için karmaşık olabilir. O yüzden daha önce MEF ile ilgili saçmaladığım şeyleri okumanızı tavsiye ederim.

1. MEF ile esneklik kazanıyoruz…
2. MEF’de “Part”lara kendi “metadata” bilgilerimizi nasıl ekleriz acaba?
3. MEF’i basit bir WPF uygulaması ile daha iyi anlıyoruz…
4. Managed Extensibility Framework(MEF)’de ki kataloglar…
5. Asp.Net MVC Framework’de MEF ile Controller eklentileri…

MEF’in genişletilebilirliğini tanımlayan ‘Part’ kavramının kullanımı ile gelen yenilik, en faydalı ve kolaylık sağlayan özellik diyebilirim. Attribute bazlı tanımlar ile yarattığımız Part’ları daha sonra MEF tarafında yöneterek uygulamalarımızın genişletilebilirliğini gerçekleştiriyorduk. .NET Framework 4.5 ile Attribute tanımları yapmadan, Part’larımızı tanımlayabiliyoruz artık.

Biraz daha anlaşılabilir olması adına; belli arayüzlerimizi, uygulamalarımıza RegistrationBuilder ile register edebiliyoruz. Bu yeniliğin en güzel tarafı, mevcut geliştirmiş olduğunuz bileşenleri, bileşenlerde ekstra bir değişiklik yapmadan, MEF ile yeni geliştirdiğiniz uygulamalara dahil edebiliyor olmanız.

.NET Framework 4.5 ile MEF tarafında gelen bir başka özellikde Generic arayüz ve sınıfları artık ‘Export’ edebiliyor olmamız. Yani Generic bir sınıfımız var ise, bunu başka uygulamalarda kullanabilmek adına Part olarak yorumlayabiliyoruz.

Bu iki özelliği kod örnekleri ile biraz daha netleştirmeye çalışacağım. Genişletilebilirliğe de örnek olması adına bir tane müzik grubunu soyutlaştıran konsol uygulaması yapıyor olacağım. Müzisyen, enstürman, grup elemanı ve ünlü bir müzisyen grubumuzun özellikleri olacak. Grubumuza, grubumuzun yapısını bozmadan, her hangi bir enstürmanı çalan grup elemanını katabiliyor olacağız en sonunda. Öncelikle bu kavramları oluşturuyor olacağız. Bu kavramları oluştururken MEF ile ilgili ekstra hiç bir şey yapmıyor olacağımızın altını çizmek isterim.

Başlayalım…

    //Generic bir Interface ile müzisyen tanımızın için bir arayüz oluşturuyoruz.
    //Play() metodu ile müzisyenlerin, bir şeyler çalacağını belirtiyoruz.
    public interface IMusicPlayer<T> where T : class
    {
        void Play();
    }

    //Müzisyenlerin çalacağı enstürmanların base sınıfı olarak
    //MusicalInsturment'ı kullanıyor olacağız.
    //PlayTheInstrument() metodu ile ilgili enstürmanın nasıl çalınacağını tanımlıyoruz.
    public abstract class MusicalInstrument
    {
        public abstract void PlayTheInstrument();
    }

    //Yukarıda oluşturduğumuz IMusicPlayer arayüzü ve MusicalInstrument sınıfından
    //generic bir BandMember<T> sınıfı oluşturuyoruz. Bu sınıf ile tanımlayacağımız
    //enstürmanları çalabilecek grup elemanlarını oluşturuyor olacağız.
    //Genişletebilirliği sağlayacak temel yapı diyebiliriz. Bu sayede herhangi bir
    //MusicalInsturment'e sahip olan BandMember'ımız grubumuz
    //dahilinde müzik yapabilecek.
    public class BandMember<T> : IMusicPlayer<T> where T : MusicalInstrument
    {
        //Generic yapıdan gelen T tipimiz MusicalInstrument tipinde olup,
        //BandMember'ın çalacağı enstürmanı belirtiyor.
        protected T _ensturment;

        public BandMember(T e)
        {
            _ensturment = e;
        }

        //IMusicPlayer arayüzünden gelen Play() metodu ile müzisyenimiz
        //bir şeyler çalmasını tetikliyoruz. (:
        public void Play()
        {
            Console.WriteLine(this.ToString() + " plays " + _ensturment.ToString());
            _ensturment.PlayTheInstrument();
        }
    }

    //Son olarak bir tane de enstürman tanımımızı yapalım.
    //Gitar olsun ilk enstürmanımız.
    public class Guitar : MusicalInstrument
    {
        private string _name = "";
        public Guitar(string name = "Custom Guitar")
        {
            _name = name;
        }

        //Gitara özel bir Solo() metodumuz olsun
        public void Solo()
        {
            Console.WriteLine("Solo with " + _name + " is just amazing");
        }

        public override string ToString()
        {
            return _name;
        }

        //MusicalInstrument'dan türeyen gitar sınıfımız, base sınıfdan gelen
        //PlayTheInstrument() metodunu kendi içinde tanımlıyor. Böylece gitara
        //özel yapıları oluşturabiliriz.
        public override void PlayTheInstrument()
        {
            Console.WriteLine("Guitar is played");
        }
    }

Buraya kadar MEF ile ilgili ekstra hiç bir şey yapmadık. Standart C# yapıları ile grubumuzun nasıl bir oluşum dahilinde oluşabileceğinin tanımlamalarını yaptık.Dikkat ederseniz MEF’in daha önce ki Export kavramına ilişkin herhangi bir geliştirme yapmadım. Şimdi MEF ile bu tanımlamaların nasıl çalışacağını oluşturalım. Bunun için çok komplike bir yapı oluşturmadan, bir konsol uygulaması üstünden gidiyor olacağım.