2008’de Microsoft “MEF” yani Managed Extensibility Framework isimli yeni bir framework üzerinde çalıştığını açıklamıştı.  Basitçe, biz geliştiricilere, “plug-in” yapısını destekleyen uygulamalar geliştirmemiz için yöntemler sunan bir framework diyebiliriz “MEF” için.

.NET Framework 4.0’a kadar, Microsoft, .NET’in içine koymuyor, “preview” adı altında sürekli geliştirmeler yapıyordu. .NET 4.0 ile beraber artık “MEF”i gönül rahatlığı ile kullanabiliyor olacağız.

Bu kısa girişten sonra, biraz daha derinlere inelim ve “MEF”in bize neler sağladığına ve neden kullanmamız gerektiğine bakalım. Öncelike “MEF” gibi bir framework’e neden ihtiyacımız var bunu anlamamız lazım. Tekrar kullanılabilirlik(Reusability) ve esneklik(extensibility), bir yazılımın yaşam sürecinde mutlaka bir şekilde karşımıza çıkan iki kavram. Geliştirdiğimiz yazılımlar çeşitli ihtiyaçlardan dolayı, ek özellikler ile genişletilmek istenebilir. Ya da geliştirdiğimiz yazılımı başka bir konfigürasyon ya da modüller ile başka bir şekilde kullanmamız da gerekebilir. Bu iki kavramı yazılımlara uygulamak oldukça zor ve sıkıntılıdır. Hele ki mimari tasarım sırasında bu iki kavramı göz ardı ettiysek sıkıntı çok daha büyük olur. Tabi ki bir yazılım illa ki esnek ya da tekrar kullanılabilir özelliğinin olması gerekmiyor. Ancak kişisel görüşüm, yazılımın yaşam süresinin uzun olabilmesi için bu iki kavramı karşılayabiliyor olması gerekmekte.

Esneklik ve tekrar kullanılabilirlik özelliklerine sahip bir yazılım ihtiyacı çok iyi bir tasarım gerektirir. Tasarımdan sonra ki geliştirme sürecini de bu iki kavram oldukça zorlar. Bu noktada “MEF”, .NET ile uygulama geliştirenlere bu süreci biraz daha kolaylaştırmak için elinden geleni yapıyor diyebilirim.

Bir PC’yi düşünelim…Anakartı ve bu kartın üzerine takılabilen ek kartlar ile çalışabilir bir sistem…X ekran kartı ile oynayamadığımız oyunları, X ekran kartını çıkartıp, Y ekran kartını takarak oynayabiliyoruz.Bunu ekran kartlarının, anakart ile belli bir arayüz standartı ile iletişim kurabilmesinden dolayı yapabiliyoruz.

“MEF” ile de bu tarz,“plug-in” yaklaşımı olan uygulamalar geliştirebiliyoruz. Run-time’da çıkarılıp, takılabilen “plug-in”ler ile uygulamalarımızı genişletebiliyoruz. Ve bütün bunlar System.ComponentModel.Composition.dll altında bulunan metod ve arayüzler sayesinde…

Kod üzerinden gidip ilk “MEF” uygulamamızı yaparsak sanırım bazı şeyler daha anlaşılır olur.Az önce yukarıda bahsetmiş olduğum PC örneği üzerinden gidiyor olacağım. Öncelikle aşağıdaki gibi 3 tane proje yaratıyoruz. Bunlardan biri ana uygulamamız(CustomPC,konsol uygulaması), biri arayüzümüz(DisplayAdapter) ve diğeri de ana kartımız(Xvidia). (:

Bu aşamada CustomPC ve XVidia projelerine System.ComponentModel.Composition.dll’i referans olarak eklememiz gerekmekte.

Öncelikle ana uygulamamız ve ekran kartımızın iletişim kuracağı arayüzümüzü oluşturalım. DisplayAdapter projesinde IDisplay.cs isimli aşağıdaki kodu içeren bir dosya yaratıyoruz;

46 using System;

47 using System.Collections.Generic;

48 using System.Linq;

49 using System.Text;

50

51 namespace DisplayAdapter

52 {

53 public interface IDisplayAdapter

54 {

55 void Display();

56 }

57 }

Bu arayüz sayesinde ana uygulamamız, “plug-in” olarak geliştirdiğimiz diğer bileşenleri çalıştırabiliyor olacak. Bundan sonra bu arayüzden yaratılan “plug-in”i geliştirebiliriz. Bir bakıma “ekran kartı”nı…(:

Bunun içinde XVidia projesinde aşağıdaki kodu yazmamız gerekmekte;

58 using System;

59 using System.Collections.Generic;

60 using System.Linq;

61 using System.Text;

62 using System.ComponentModel.Composition;

63

64 namespace DisplayAdapter

65 {

66 [Export(“”,typeof(IDisplayAdapter))]

67 public class XVidiaIDisplayAdapter

68 {

69

70 public void Display()

71 {

72 Console.WriteLine(“This is XVidia Display Adapter”);

73 }

74 }

75 }

Bu noktada “Export” özelliği dikkatimizi çekmiş olmalı. “MEF”‘de “Composable Parts” diye adlandırılan ve “MEF”in temel taşı olan bir kavram var. “Composable Parts” belli servisleri(metod) dışa sunan ve belli servisleride(metod) kullanan birimler. Ana uygulamalar ve “plug-in”ler bu birimlere göre çalışmakta. Yukarıdaki kod bloğunda “Export” özelliğini kullarak, XVidia sınıfını “IDisplayAdapter” arayüzünün metodlarını dışa sunduğunu göstermiş olduk.

Şimdi sıra “plug-in”leri çalıştıracak ana uygulamamıza geldi. Bunun için CustomPC projesinde aşağıdaki kodu içeren bir dosya yaratmamız yeterli.

82 using System;

83 using System.Collections.Generic;

84 using System.Linq;

85 using System.Text;

86 using System.ComponentModel.Composition.Hosting;

87 using System.Reflection;

88 using DisplayAdapter;

89 using System.ComponentModel.Composition;

90

91 namespace CustomPC

92 {

93 public class Computer

94 {

95 //Hangi arayüzün “MEF” tarafından import

96 //edileceğini belirtiyoruz.

97 [Import(typeof(IDisplayAdapter))]

98 public IDisplayAdapter DisplayAdapter { get; set; }

99

100 static void Main(string[] args)

101 {

102 Console.WriteLine(“PC’s configuration”);

103 Computer comp = new Computer();

104 comp.Init();

105

106 Console.ReadLine();

107 }

108

109 public void Init()

110 {

111 try

112 {

113 /*

114 * Plug-in’lerin olduğu yeri belirtmek için “MEF”

115 * ile gelen katalog kavramından faydalanıyoruz.

116 * İlerleyen yazılarda bu katalog kavramının

117 * derinlerine dalıyor olacağım.Şimdilik “plug-in”lerin

118 * bir dizinden okunacağını belirtmek için

119 * DirectoryCatalog sınıfı kullanıyoruz.

120 */

121 DirectoryCatalog dirCat = new DirectoryCatalog(Environment.CurrentDirectory + “\\plugin\\”);

122 /*

123 * “MEF” ile beraber gelen “CompositionBatch” ve

124 * “CompositionContainer” sınıfı ile “is a part of”

125 * ilişkisini kurabileceğimiz yapıyı yaratıyoruz.

126 * “is a part of” ilişkisi derken ne demek istediğimi

127 * açıklamamda fayda var sanırım.”plug-in”‘ler ana

128 * uygulamamızın bir parçası olacak.Ve bu parçalar

129 * takıp,çıkarılabilir özelliklere sahip olacak.

130 * Bütün bu ilişkiler “MEF” tarafından yönetiliyor olacak.

131 * “CompositionBatch” parçaların(Composable Parts)

132 * tutulduğu,”CompositionContainer” ise

133 * parçaların(Composable Parts)’ın metodlarının ve

134 * özelliklerinin sunulmasını sağlayan yapı olarak

135 * tanımlanabilir.

136 */

137 CompositionBatch batch = new CompositionBatch();

138 CompositionContainer container = new CompositionContainer(dirCat);

139

140 //Parçalarımızı ekliyoruz

141 batch.AddPart(this);

142

143 //Parçalarımızı ana uygulama ve birbirleri ile

144 //ilişkilendiriyoruz

145 container.Compose(batch);

146

147 //Parçalarımızı çalıştırıyoruz.Bu noktada

148 //arayüzün(IDisplayAdapter) sunduğu

149 //metodları sunabiliyoruz sadece.

150 DisplayAdapter.Display();

151 }

152 catch (Exception)

153 {

154

155 throw;

156 }

157

158

159 }

160

161

162 }

163

164

165 }

Ve işte bu kadar…Hemen özetliyelim ne yaptık. Bir tane “plug-in” desteği olan ana uygulama yaptık(CustomPC) ve bu ana uygulama üstünde çalışacak bir tane “plug-in” yaptık. Yaptığımız “plug-in” benzeri başka “plug-in”ler yaparak, uygulamamızı çeşitlendirebiliriz. Mesela XTI diye yeni bir ekran kartı, pardon “plug-in”….(:

Yukarıdaki CustomPC projesini çalıştırdığımız zaman hata alıyor olacağız. Peki ama neden? Bunun nedeni “XVidia” projesinin çıktısı olan *.Dll’in ana uygulama tarafına yüklenmemiş olması. CustomPC projesinin dizininde, “debug” klasörü altında “plugin” diye bir klasör açıp, “XVidia” projesinin çıktısı olan *.Dll’i kopyaladığımız zaman uygulamamızın sorunsuz bir şekilde çalıştığını göreceğiz.

“XVidia” projesinin çıktısı olan *.Dll yerine, benzer bir yapı ile oluşturulmuş bir *.Dll koyduğumuz zaman uygulamanın o *.Dll’i çalıştıracağını görüyor olacağız.

Çok basit ve güzel değil mi… .NET 4.0’ın bence en güzel yeniliği “MEF” ile entegre olması…İlerleyen yazılarda “MEF”in çok daha derinlerine dalıyor olacağım…Şimdilik bu kadar…