Kısaca benim neler en çok hoşuma gitti onlardan bahsetmek isterim, belki daha cazip gelir bu haber bu sayede (:

Benim en çok hoşuma giden yenilik MEF Part’larını belirtmek için kullandığımız attribute’ları yeni gelen RegistrationBuilder ile sayesinde farklı bir şekilde belirtebiliyor olmamız. Mesela belli bir sınıfta belirtilen Part’larımızdan türüyen export edilecek diğer sınıflarımız için [Export] attribute’unu tanımlamak gerekmekteydi. Hem kendini tekrarlayan bir yapı oluşmasıns sebep olan hem de bazen unutulabilen ve  runtime’da fark edilebilen bir durum oluyordu. Yeni gelen RegistrationBuilder ile aşağıdaki gibi Export edilecek Part’larımı daha kolay ve anlaşılır bir şekilde tanımlayabiliyoruz.

 //ForTypesDerivedFrom() metodu ile BaseModule gibi kendi sınıfımızdan
 //türümiş tüm objelerin export edilebileceğini söylüyoruz.
 var builder = new RegistrationBuilder();
 builder.ForTypesDerivedFrom().Export();

//MEF kataloglarına da RegistrationBuilder objemizi verebiliyoruz
 var catalog = new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly(), builder);
 

Generic olan sınıfları artık Export edebiliyoruz. Yani IGenericType<T> gibi bir arayüzümüz olduğunda ve bundan türeyen sınıflarımızı Export etmek istediğimiz de [Export(IGenericType<>)] şeklinde attribute’u güncellemek yeterli olacak.

Ayrıca Exception mesajlarında ki iyileştirmeler de Run-time’da alınan hataları biraz daha açıklayıcı hala getiriyor. Bu da hata tespiti için çok can kurtaracak.

Bu arada MEF 2.0 versiyonu, .NET Framework 4.5′ün içinde de geliyor olacak. Ama tabi ondan önce çıkar mı bilemiyorum…Çıkarsa ne ala…Neyse şimdilik bu kadar…

IObservable<T> ve IObserver<T> yeni gelen arayüzlerimizden…Bu arayüzler “push-based notifications” diye literatürde yer alan sistemler oluşturmamız için faydalanabileceğimiz arayüzler. “push-based notifications” nedir ile başlasak sanırım daha kolay olacak bazı şeyler. Artık bir çok kişinin kullandığı sosyal paylaşım sitelerinden örnekler verebiliriz daha iyi anlamak için. Facebook’da örneğin, sayfa ile her hangi bir etkileşim olmadan zaman zaman sağdan soldan “1 tane mesajınız var”, “X kişisi Y’nin fotoğrafını beğendi” gibi bildirimler alıyoruz. Bu tarz bildirimlere “push-based notifications” diyoruz. Türkçeleştirmek için kasamadım açıkcası ama basitçe bir nesnenin, kendisine bağlanan ya da üye olan parçalara bildirimler göndererek, kendinde olan değişimleri bildirmesi olarak açıklayabiliriz. Gözlemci ve gözlenen olarak düşünürsek biraz daha netleşebilir sanırım. Bütün bu kavramlar aslında mevcut event yaklaşımı ile üstü kapalı olarak bize sunulmakta tüm yazılım geliştirme dillerinde. Ayrıca “Observer” tasarım kalıbı şeklinde de literatürde yerini uzun süredir korumakta.

IObservable ve IObserver arayüzleri de bu tasarım kalıbının .NET Framework’de ki yansıması. Peki neden yeni olarak .NET Framework 4.0 ile geldi ya da mevcut event yapısı zaten bu kavramları karşılamıyor mu sorularını sorabilirsiniz…Gelişen ihtiyaçlar ve kullanıcı eğilimlerinden dolayı asenkron çağrılar ve dağınık olay bazlı(distrubted events) yaklaşımları kendi sistemlerimizde, kendimize özgün yöntemler ile kullanmamız gerekebiliyor. Bundan dolayı bu iki arayüz ile daha kontrollü bir şekilde kendi “push-based notification” tarzı uygulamalarımızı .NET Framework ile daha kolay geliştirebiliyoruz. Bir örnek ile devam edip biraz daha netleştirelim.Yabacağımız örnek basit bir konsol uygulaması olup, doların yükselişini simule eden ve bu yükselişi takip eden bir uygulama olacak. Oldukça basit…Yine standart olarak kod üzerinden açıklamalar ile anlatmaya çalışacağım. O zaman başlıyoruz…

    //IObservable arayüzünden gözlemnecek nesnemizin sınıfı yaratıyoruz.
    //T tipindeki nesne yarattığımız nesne ya da daha temel bir nesne olabilir.
    //IObservable arayüzünden türüyen sınıf, arayüzden gelen Subscribe()
    //metodunu tanımlamak durumda. Bu metod ile bu nesnemizi gözleyecek
    //nesneleri tanımlıyoruz.
    public class Dolar : IObservable
    {
        //Nesnemizi birden fazla gözlemci gözleyebileceği için
        //List tipinde bir nesne ile gözlemcileri saklayabileceğimiz
        //bir koleksiyon tanımlıyoruz.
        private List> _subscribers;
        private int _amount;

        public Dolar()
        {
            _subscribers = new List>();
        }

        public int Amount
        {
            get
            {
                return _amount;
            }
            set
            {
                _amount = value;
                //Nesnemizde oluşacak değişiklikleri gözlemcilere,
                //gözlemcilerin(-ki bunlar IObserver arayüzünden
                //yaratılan sınıflar) OnNext() metodu ile bildiriyoruz.
                foreach (var item in _subscribers)
                {
                    item.OnNext(this);
                }
            }
        }

        //Subscribe metodu IObservable arayüzünden gelen bir metod.
        //Bu metod ile nesnemizi gözlemleyecek diğer nesneleri belirtebiliyoruz.
        //Bir başka deyişle nesnemize abone olacak ve onun değişikliklerinden
        //etkilenecek olan nesneleri alıyoruz.
        //IDisposable tipinde bir dönüş değeri olmasının sebebi, gözlemcilerin
        //gerektiği zaman aboneliklerini iptal ettirebilmelerini sağlıyor.
        //Bu örnekte bu konuya değinmedim.Belki ileride
        public IDisposable Subscribe(IObserver observer)
        {
            if (!_subscribers.Contains(observer))
                _subscribers.Add(observer);

            return null;
        }
    }

Gözlenecek nesnemizin sınıfı oluşturduktan sonra, bu nesne üzerindeki değişiklikleri takip ve kontrol edeceğimiz, gözlemci nesnelerimizin sınıflarını aşağıdaki gibi yazabiliriz.

    //Aşağıdaki örnek sınıfta, IObserver arayüzünden yarattığımız nesne
    //CurrencyTracker nesnesi, Dolar tipinde ki nesneleri gözlemleyecek.
    //IObserver arayüzünden gelen 3 tane zorunlu metod var.
    //OnNext() metodu ile değişen datayı gözlemciye bildiriyoruz,
    //OnError() metodu ile hata oluştuğu durumları gözlemciye bildirebiliyoruz,
    //OnCompleted() metodu ile de bildirimlerin tamamlandığı bilgisini verebiliyoruz.
    public class CurrencyTracker : IObserver
    {
        public CurrencyTracker()
        {

        }

        public void OnCompleted()
        {
            Console.WriteLine("İşlem Tamamlandı");
        }

        public void OnError(Exception error)
        {
            Console.WriteLine("Hata oluştu");
        }

        public void OnNext(Dolar value)
        {
            Console.WriteLine("Dolar'ın değeri:{0} ",value.Amount);
        }
    }

    //Bu örnek için, yukardaki diğer gözlemciye benzeyen başka bir
    //gözlemci, aynı mantıkla çalışmakta.Ek olarak OnNext() metodunda
    //gelen veri değerini kontrol ediyor.
    public class LimitTracker : IObserver
    {

        public LimitTracker()
        {

        }

        public void OnCompleted()
        {
            Console.WriteLine("İşlem Tamamlandı");

        }

        public void OnError(Exception error)
        {
            Console.WriteLine("Hata oluştu");
        }

        public void OnNext(Dolar value)
        {
            if(value.Amount>70)
                Console.WriteLine("Dolar'ın değeri çok yüksek: {0} .Kriz olabilir.", value.Amount);
        }
    }

Son olarak ise yazdığımız kodların nasıl çalıştığını görmek adına aşağıdaki gibi basit bir konsol uygulaması yazıyoruz.

    class Program
    {
        static void Main(string[] args)
        {

            Dolar d = new Dolar();
            CurrencyTracker ct = new CurrencyTracker();
            LimitTracker lt = new LimitTracker();

            //Dolar nesnemize abone oluyoruz ve gözlemlemeye başlıyoruz
            d.Subscribe(lt);
            d.Subscribe(ct);

            //1000 milisaniye de bir Dolar tipindeki nesnemizin Amount değerini
            //değiştiriyoruz.
            Timer t = new Timer((s) =>
            {
                d.Amount = new Random().Next(100);
            }, null, TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(1000));

            Console.ReadLine();
        }
    }

Örnek uygulamamızın çıktısı da aşağıdaki gibi olacaktır…

Şimdilik bu kadar…Oldukça basit bir örnekle .NET 4.0 ile gelen IObserverve IObservableaçıklamaya çalıştım, umarım biraz olsun faydası olur.

Örnek projeyi buradan indirebilirsiniz…

• WPF ile Model View ViewModel yazı dizisi
• ASP.NET MVC 3 ve Razor View Engine
• WCF Öğreniyorum video dizisi (Yeni başladı takip edin derim)
• ASP.NET 4.0-URL Routing
• Internet Explorer 9–Sabitlenmiş Siteler
• Visual Studio 2010 Mimari Araçlar yazı dizisi

• Nedirtv Söyleşileri – .NET Framework 4.0 ile Gelen Yenilikler-Bölüm 1
• Nedirtv Söyleşileri – .NET Framework 4.0 ile Gelen Yenilikler-Bölüm 2

Biraz fazla anırmışım (: ama ilk defa böyle bir söyleşide yer almanın tecrübesizliği diye kendimi avutuyor ve bunun için özür diliyorum. İlerleyen günler içerisinde bu söyleşilerin devamının geleceğini de söylemeden edemicem. Takip edin derim…

Şu an ki versiyonun “Preview” olduğunu ve bir çok sorunla karşılaşabileceğinizi hatırlatmakta fayda var.

Bugün itibari ile Microsoft, WebMatrix adında yeni bir araç çıkardı. Şu an Beta olan bu araç, oldukça faydalı bir araç aslında… WebMatrix, Windows ortamında Visual Studio olmadan basitçe Asp.Net uygulamaları geliştirebileceğiniz bir ortam. Ortam diyorum çünkü içerdiği IIS Express Edition,SQL Server Compact Edition ile ciddi anlamda dolu dolu bir içeriğe sahip. WebMatrix ile Microsoft, geçtiğimiz günlerde duyurulan Asp.Net’in yeni “View” motoru “Razor”u da bu araç ile de test edebilirsiniz.

Bu adresten daha ayrıntılı bilgilere ulaşabilirsiniz. Yetmez ise Scott Guthrie’nin bu yazısı oldukça yeterli olacaktır.

1. Workflow Foundation Öğreniyorum – Ders 0 – Hello World
2. Workflow Foundation Öğreniyorum – Ders 1 – Biraz Daha Bileşen
3. Workflow Foundation Öğreniyorum – Ders 2 – Kodla Başbaşayız
4. Workflow Foundation Öğreniyorum – Ders 3 – Yeni Bir Yüz – Flowchart
5. Workflow Foundation Öğreniyorum – Ders 4 – Flowchart için Ek İşlemler
6. Workflow Foundation Öğreniyorum – Ders 5 – Argument Kavramı ile Tanışalım
7. Workflow Foundation Öğreniyorum – Ders 6 – Expression Activities
8. Workflow Foundation Öğreniyorum – Ders 7 – Homework
9. Workflow Foundation Öğreniyorum – Ders 8 – Exception Handling

Devamını da takip ediyor olun da derim…Aha da dedim…

Managed Extensibility Framework(MEF)‘de, “Part”lar bu kataloglar ile framework bünyesine dahil olur. Bir başka deyişle, MEF, [Export] ettiğimiz bileşenlerimizi(ki bunlar “Part”lar oluyor) bu kataloglar yardımı ile bulur. Yapboz parçalarının tutulduğu kutu, ya da bilgisayar parçalarının birleştiği kasa gibi düşünebiliriz aslında. Bu kataloglar neler, kısaca bakalım bir, ne çıkacak içlerinden…:)

DirectoryCatalog

Adından aslında anlaşılıyor. “DirectoryCatalog”, MEF’de “Part”ların, belli bir dizindeki assembly’ler içinde aranmasını sağlıyor. Yani MEF ile geliştirdiğimiz uygulama eğer DirectoryCatalog kullanıyrsa, belirttiğimiz bir dizin içerisindeki dosyalarda(*.dll gibi), [Export] ettiğimiz tipleri arayacaktır. Sanırım MEF’de en çok kullanılan, daha doğrusu tercih edilen katalog budur…Yanlız burda hatırlatmak gereken bir nokta var. DirectoryCatalog’u Silverlight’ın mimarisinden dolayı, Silverlight uygulamalarında kullanamıyoruz.

AssemblyCatalog

MEF’in “Part”ları bellirtilen assembly’de aramasını sağlayan katalog tipi AssemblyCatalog oluyor. Uygulamamızın kendi içinde gizlediğimiz [Export]‘ları kullanabilmek adına kullanımı tercih edilebilir. Ya da “reflection” ile yarattığımız “assembly”leri kullanmak için de kullanabiliriz.

TypeCatalog

MEF’in belli tipte “Part”ları aramasını belirttiğimiz katalog tipi de TypeCatalog oluyor. Bu uygulama içersindeki belirttiğimiz tipte olan tüm [Export]‘ları MEF tarafından kullanılabilir hale getiriyor.

AggregateCatalog

MEF’in birden fazla “Catalog” ile arama yapmasını istediğimiz zaman AggregateCatalog’dan faydalanıyoruz. Bu katalog tipi, çalışma zamanında farklı katalogları bünyesine ekleyerek, birden fazla katalog tipinde MEF Part’larının aranmasını sağlıyor.

Bu sefer hiç kod yazmadık ama MEF için önemli bir kavramı biraz daha netleştirmeye çalıştık. Umarım faydalı olmuştur. Bu kataloglar ile örnekleri ilerleyen yazılarda yapıyor olacağım…Farklarını,artılarını,eksilerini çok daha iyi beraber anlıyor oluruz…Şimdilik bu kadar…

Ayrıca ayrıntılı bilgi ve dökümantasyon için de MSDN sayfasına göz atmanızı tavsiye ederim.