Managed Extensibility Framework (MEF)
Bu konu başlığında, Managed Extensibility Framework 4. bölümde tanıtıldı olan .NET Framework yer velanmıştır.
Managed Extensibility Framework veya MEF, basit ve genişletilebilir uygulamalar oluşturmaya yönelik bir kitaplıktır. Uygulama geliştiricilerinin yapılandırmaya gerek yoktur uzantılarını bulmalarını ve kullanmalarını sağlar. Ayrıca uzantı geliştiricilerinin kodu kolayca kapsüllemesine ve hassas sabit bağımlılıklardan kaçınmaya da olanak sağlar. MEF, uzantıların yalnızca uygulamalar içinde değil uygulamalar arasında da yeniden kullanılmasına izin verir.
Imagine genişletilebilirlik için destek sağlamaları gereken büyük bir uygulamanın mimarı olduğunu kabul ediyorum. Uygulamanın çok sayıda daha küçük bileşen içermesi gerekir ve bunları oluşturmak ve çalıştırma sorumluluğundadır.
Soruna en basit yaklaşım, bileşenleri uygulamanıza kaynak kod olarak eklemek ve doğrudan kodunuzdan çağırarak yapmaktır. Bunun bir dizi belirgin dezavantajı vardır. En önemlisi, bir Web uygulamasında kabul edilebilir ancak istemci uygulamasında çalışılamaz olan bir kısıtlama olan kaynak kodu değiştirmeden yeni bileşenler ekilemez. Aynı derecede sorunludur; üçüncü taraflarca geliştirilene ve aynı nedenle sizin bileşenlerinize erişmelerine izin veremeyen bileşenler için kaynak koduna erişiminiz olamaz.
Biraz daha karmaşık bir yaklaşım, uygulama ve bileşenleri arasında bir farka izin sağlamak için bir uzantı noktası veya arabirim sağlamaktır. Bu model altında, bir bileşenin uygulay olabileceği bir arabirim ve uygulamanıza etkileşim kurmasını sağlamak için bir API sebilirsiniz. Bu, kaynak kodu erişimi gerektirme sorununu çözer, ancak yine de kendi güçlükleri vardır.
Uygulama, bileşenleri kendi başına bulmak için herhangi bir kapasiteye sahip olmadığı için, hangi bileşenlerin kullanılabilir olduğu ve yükleniyor olması gerektiği açıkça açık bir şekilde açık bir şekilde anlatılamalı. Bu genellikle kullanılabilir bileşenleri bir yapılandırma dosyasına açıkça kaydederek yapılandırmasını gerçekleştirebilirsiniz. Bu, bileşenlerin doğru olduğunu kabul etmek, özellikle de güncelleştirmeyi yapmaları beklenen geliştirici değil son kullanıcıysa bakım sorununa neden olur.
Ayrıca, uygulamanın katı olarak tanımlanmış kanalları dışında bileşenler birbirleriyle iletişim kuramaz. Uygulama mimarı belirli bir iletişim ihtiyacıyla ilgili bir tahminde yoksa, bu genellikle imkansızdır.
Son olarak, bileşen geliştiricilerin hangi derlemenin uygulayacakları arabirimi içerdiğine sıkı bir bağımlılığı kabul etmeleri gerekir. Bu, bir bileşenin birden fazla uygulamada kullanılmalarını zorlaştırarak bileşenler için bir test çerçevesi oluşturmanızı da zorlaştırabilirsiniz.
MEF, kullanılabilir bileşenlerin bu açık kaydı yerine, bunları bileşim aracılığıyla örtülü olarak bulmanın bir yolunu sağlar. Parça olarak adlandırılan MEF bileşeni, hem bağımlılıklarını (içeri aktarmalar olarak bilinir) hem de hangi özellikleri (dışarı aktarmalar olarak bilinir) kullanılabilir olduğunu bildirimli olarak belirtir. Bir parça oluşturulduğunda, MEF bileşim altyapısı diğer parçalardan kullanılabilenlerle içeri aktarmalarını karşılar.
Bu yaklaşım, önceki bölümde ele alınacak sorunları çözer. MEF parçaları, yeteneklerini bildirimli olarak belirterek çalışma zamanında keşfedilebilir. Bu da uygulamanın sabit kodlu başvurular veya hassas yapılandırma dosyaları olmadan parçaları kullanabileceği anlamına gelir. MEF, uygulamaların meta verilerine göre parçaları bulmalarına ve incelemelerine, hatta derlemelerini yüklemelerine gerek kalmadan bunları bulmalarına ve incelemelerine olanak sağlar. Sonuç olarak uzantıların ne zaman ve nasıl yük olacağını dikkatli bir şekilde belirtmenize gerek yoktur.
Bir parça, sağlanan dışarı aktarmalara ek olarak, diğer parçalar tarafından doldurulacak olan içeri aktarmalarını da belirterek. Bu, parçalar arasındaki iletişimi yalnızca mümkün değil, kolay bir şekilde sağlar ve kodun iyi çarpanlara iner. Örneğin, birçok bileşende ortak olan hizmetler ayrı bir bölüme alınarak kolayca değiştirilebilir veya değiştirilebilir.
MEF modeli, belirli bir uygulama derlemesi üzerinde sabit bağımlılık gerekmeyy olduğundan, uzantıların uygulamada yeniden kullanılmasına olanak sağlar. Bu, uzantı bileşenlerini test etmek için, uygulamadan bağımsız bir test donanımı geliştirmeyi de kolaylaştırır.
MEF kullanılarak yazılan genişletilebilir bir uygulama, uzantı bileşenleri tarafından doldurulan bir içeri aktarma bildirebilir ve uygulama hizmetlerini uzantılara göstermek için dışarı aktarmalar da bildirebilir. Her uzantı bileşeni bir dışarı aktarma bildirer ve içeri aktarmaları da bildirebilirsiniz. Bu şekilde uzantı bileşenleri otomatik olarak genişletilebilir.
MEF, .NET Framework 4'.NET Framework parçasıdır ve her .NET Framework kullanılabilir. MEF'i ister Windows Forms, WPF, ister başka bir teknoloji ya da kaynak kullanan sunucu uygulamalarında kullanın, istemci uygulamalarınız için ASP.NET.
Önceki sürümler .NET Framework uygulamaların uzantıları yalıtıp yönetmesine olanak sağlayacak şekilde tasarlanmış Yönetilen Eklenti Çerçevesi'ne (MAF) ekti. MAF'nin odak noktası MEF'den biraz daha yüksek düzeydedir ve uzantı yalıtımına ve derleme yükleme ve kaldırmaya odaklanırken MEF'nin odak noktası keşfedebilirlik, genişletilebilirlik ve taşınabilirliktir. İki çerçeve sorunsuz bir şekilde birlikte çalışır ve tek bir uygulama her iki durumdan da faydalanabilirsiniz.
MEF'nin neler yapalarını görmenin en basit yolu basit bir MEF uygulaması oluşturmaktır. Bu örnekte SimpleCalculator adlı çok basit bir hesap makinesi kurabilirsiniz. SimpleCalculator'ın amacı, "5+3" veya "6-2" şeklinde temel aritmetik komutları kabul eden ve doğru yanıtları döndüren bir konsol uygulaması oluşturmaktır. MEF kullanarak, uygulama kodunu değiştirmeden yeni işleçler ekabileceksiniz.
Bu örneğin tam kodunu indirmek için bkz. SimpleCalculator örneği (Visual Basic).
Not
SimpleCalculator'ın amacı, kullanımı için gerçekçi bir senaryo sağlamak yerine MEF kavramlarını ve söz dizimlerini göstermektir. MEF'nin gücünden en çok yararlanabilecek uygulamaların çoğu SimpleCalculator'dan daha karmaşıktır. Daha kapsamlı örnekler için bkz. Managed Extensibility Framework GitHub.
Başlamak için, Visual Studio konsol uygulaması projesi oluşturun ve olarak ad girin
SimpleCalculator
.MEF'nin bulunduğu
System.ComponentModel.Composition
derlemeye bir başvuru ekleyin.Module1.vb veyaProgram.cs'yi açın ve ve
Imports
için veyausing
deyimleriSystem.ComponentModel.Composition
ekleyinSystem.ComponentModel.Composition.Hosting
. Bu iki ad alanı, genişletilebilir bir uygulama geliştirmek için ihtiyacınız olacak MEF türlerini içerir.Anahtar sözcüğünü Visual Basic modülünü
Public
bildiren satıraModule1
ekleyin.
MEF oluşturma modelinin çekirdeği, kullanılabilir tüm parçaları içeren ve bileşimi gerçekleştiren bileşim kapsayıcısıdır. Bileşim, dışarı aktarmalara yapılan içeri aktarmaların eşleşmesidir. En yaygın bileşim kapsayıcısı türü olan CompositionContainerbu kapsayıcıyı SimpleCalculator için kullanabilirsiniz.
Visual Basic kullanıyorsanız Module1.vb içinde adlıProgram
bir genel sınıf ekleyin.
Module1.vb veya Program
Program.cs'de sınıfına aşağıdaki satırı ekleyin:
Dim _container As CompositionContainer
private CompositionContainer _container;
Bileşim kapsayıcıları, kullanılabilir olan parçaları bulmak için katalog kullanır. Katalog, bir kaynaktan bulunan parçaları kullanılabilir yapan bir nesnedir. MEF, sağlanan tür, derleme veya dizinden parçaları bulmak için kataloglar sağlar. Uygulama geliştiricileri, Web hizmeti gibi diğer kaynaklardan parçaları bulmak için kolayca yeni kataloglar oluşturabilir.
Sınıfına aşağıdaki oluşturucu ekleyin Program
:
Public Sub New()
' An aggregate catalog that combines multiple catalogs.
Dim catalog = New AggregateCatalog()
' Adds all the parts found in the same assembly as the Program class.
catalog.Catalogs.Add(New AssemblyCatalog(GetType(Program).Assembly))
' Create the CompositionContainer with the parts in the catalog.
_container = New CompositionContainer(catalog)
' Fill the imports of this object.
Try
_container.ComposeParts(Me)
Catch ex As CompositionException
Console.WriteLine(ex.ToString)
End Try
End Sub
private Program()
{
try
{
// An aggregate catalog that combines multiple catalogs.
var catalog = new AggregateCatalog();
// Adds all the parts found in the same assembly as the Program class.
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));
// Create the CompositionContainer with the parts in the catalog.
_container = new CompositionContainer(catalog);
_container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
Console.WriteLine(compositionException.ToString());
}
}
çağrısı, ComposeParts bileşim kapsayıcısını belirli bir parça kümesi (bu örnekte geçerli örneği) oluşturmasını söyler Program
. Ancak bu noktada hiçbir şey olmaz çünkü doldurulacak Program
içeri aktarma yoktur.
İlk olarak, bir hesaplayıcıyı Program
içeri aktarın. Bu, içine gidecek konsol girişi ve çıkışı Program
gibi kullanıcı arabirimi endişelerinin hesaplayıcı mantığından ayrılmasına olanak sağlar.
Sınıfına aşağıdaki kodu Program
ekleyin:
<Import(GetType(ICalculator))>
Public Property calculator As ICalculator
[Import(typeof(ICalculator))]
public ICalculator calculator;
Nesnenin bildiriminin olağan dışı calculator
olmadığını, ancak özniteliğiyle birlikte dekore edilmiş olduğunu fark ImportAttribute edersiniz. Bu öznitelik bir şeyi içeri aktarma olarak bildiriyor; diğer bir ifadeyle, nesne ed-ed-yken bileşim altyapısı tarafından doldurulur.
Her içeri aktarmada hangi dışarı aktarmalarla eşleneceklerini belirleyen bir anlaşma vardır. Sözleşme açıkça belirtilen bir dize olabilir veya mef tarafından belirli bir türden (bu durumda arabirimi) otomatik olarak oluşturulacaktır ICalculator
. Eşleşen bir sözleşmeyle bildirilen tüm dışarı aktarmalar bu içeri aktarmayı karşılar. nesnesinin türü aslında calculator
iken bu gerekli ICalculator
değildir. Anlaşma, içeri aktarma nesnesinin türünden bağımsızdır. (Bu durumda, 'i dışarıda bırakın typeof(ICalculator)
. MEF, sözleşmenin açıkça belirtmedikçe otomatik olarak içeri aktarma türüne bağlı olduğunu varsayacaktır.)
Bu çok basit arabirimi modüle veya ad alanına SimpleCalculator
ekleyin:
Public Interface ICalculator
Function Calculate(input As String) As String
End Interface
public interface ICalculator
{
string Calculate(string input);
}
Tanımlandığına göre ICalculator
, bunu uygulayan bir sınıfa ihtiyacınız vardır. Aşağıdaki sınıfı modüle veya ad alanına SimpleCalculator
ekleyin:
<Export(GetType(ICalculator))>
Public Class MySimpleCalculator
Implements ICalculator
End Class
[Export(typeof(ICalculator))]
class MySimpleCalculator : ICalculator
{
}
içinde içeri aktarmayla eş olacak dışarı aktarma işlemi şu şekildedir Program
. Dışarı aktarmanın içeri aktarmayla eşleşmesi için dışarı aktarmanın aynı sözleşmeye sahip olması gerekir. Sözleşmeye dayalı olarak dışarı aktarma typeof(MySimpleCalculator)
işlemi bir eşleşmeye neden olur ve içeri aktarma doldurulmaz; sözleşmenin tam olarak eşleşmesi gerekir.
Bileşim kapsayıcısı bu derlemede bulunan tüm parçalarla doldurulduğundan parça MySimpleCalculator
kullanılabilir olur. oluşturucusu nesne Program
üzerinde oluşturma işlemi Program
gerçekleştirecek olduğunda, içeri aktarması MySimpleCalculator
bu amaç için oluşturulacak bir nesnesiyle doldurulur.
Kullanıcı arabirimi katmanının (Program
) başka bir şey bilmek zorunda değildir. Bu nedenle, kullanıcı arabirimi mantığının geri kalanını yönteminde doldurabilirsiniz Main
.
Main
yöntemine aşağıdaki kodu ekleyin:
Sub Main()
' Composition is performed in the constructor.
Dim p As New Program()
Dim s As String
Console.WriteLine("Enter Command:")
While (True)
s = Console.ReadLine()
Console.WriteLine(p.calculator.Calculate(s))
End While
End Sub
static void Main(string[] args)
{
// Composition is performed in the constructor.
var p = new Program();
Console.WriteLine("Enter Command:");
while (true)
{
string s = Console.ReadLine();
Console.WriteLine(p.calculator.Calculate(s));
}
}
Bu kod, bir giriş satırını okur ve sonuç üzerinde öğesine çağrı Calculate
ICalculator
yaparak konsola geri yazar. Bu, ihtiyacınız olan tüm kodlarda Program
bulunur. Çalışmanın tüm geri kalanı parçalar halinde olur.
SimpleCalculator 'ın Genişletilebilir olması için, işlem listesini içeri aktarması gerekir. Sıradan ImportAttribute bir öznitelik bir ve yalnızca bir ExportAttribute ile doldurulur. Birden fazla kullanılabilir varsa, bileşim altyapısı bir hata üretir. Herhangi bir sayıda dışarı aktarma tarafından doldurulabilecek bir içeri aktarma oluşturmak için, özniteliğini kullanabilirsiniz ImportManyAttribute .
Sınıfına aşağıdaki Operations özelliğini MySimpleCalculator
ekleyin:
<ImportMany()>
Public Property operations As IEnumerable(Of Lazy(Of IOperation, IOperationData))
[ImportMany]
IEnumerable<Lazy<IOperation, IOperationData>> operations;
Lazy<T,TMetadata> , dışarı aktarmalar için dolaylı başvuruları tutmak üzere MEF tarafından sağlanmış bir türdür. Burada dışa aktarılmış nesnenin kendisinin yanı sıra dışarı aktarma meta verileriniveya dışarı aktarılmış nesneyi açıklayan bilgileri de alırsınız. Her biri Lazy<T,TMetadata> , gerçek bir işlemi temsil eden bir nesne ve meta verilerini temsil eden bir IOperationData
nesnesi içerir IOperation
.
Aşağıdaki basit arabirimleri modüle veya SimpleCalculator
ad alanına ekleyin:
Public Interface IOperation
Function Operate(left As Integer, right As Integer) As Integer
End Interface
Public Interface IOperationData
ReadOnly Property Symbol As Char
End Interface
public interface IOperation
{
int Operate(int left, int right);
}
public interface IOperationData
{
char Symbol { get; }
}
Bu durumda, her bir işlemin meta verileri +,-, * gibi bir işlemi temsil eden simgedir. Ek işlemi kullanılabilir hale getirmek için modüle veya SimpleCalculator
ad alanına aşağıdaki sınıfı ekleyin:
<Export(GetType(IOperation))>
<ExportMetadata("Symbol", "+"c)>
Public Class Add
Implements IOperation
Public Function Operate(left As Integer, right As Integer) As Integer Implements IOperation.Operate
Return left + right
End Function
End Class
[Export(typeof(IOperation))]
[ExportMetadata("Symbol", '+')]
class Add: IOperation
{
public int Operate(int left, int right)
{
return left + right;
}
}
ExportAttributeÖzniteliği daha önce olduğu gibi çalışır. ExportMetadataAttributeÖzniteliği, meta verileri bir ad-değer çifti biçiminde bu dışarı aktarmaya iliştirir. Add
Sınıf uyguladığı IOperation
sırada, uygulayan IOperationData
bir sınıf açıkça tanımlanmamıştır. Bunun yerine, bir sınıf, belirtilen meta verilerin adlarına göre özellikler ile MEF tarafından örtülü olarak oluşturulur. (Bu, MEF 'teki meta verilere erişmenin çeşitli yöntemlerinden biridir.)
MEF 'te birleşim özyinelemeli. Program
Açık olan nesneyi, türü MySimpleCalculator
olması için bir ICalculator
tanesi içeri aktardınız. MySimpleCalculator
, sırasıyla bir nesne koleksiyonu IOperation
içeri aktarır ve içeri aktarma işlemi oluşturulduğunda, içeri aktarmaların Program
aynı anda doldurulur MySimpleCalculator
. Add
Sınıf daha fazla içeri aktarma bildirmişse, bunun da doldurulması gerekir. Doldurulmamış herhangi bir içeri aktarma işlemi bir bileşim hatası ile sonuçlanır. (Ancak, içeri aktarmaları isteğe bağlı olarak bildirmek veya varsayılan değerleri atamak mümkündür.)
Bu parçalar yerinde olduğunda, her şey Hesaplayıcı mantığının kendisidir. Yöntemini uygulamak Calculate
için aşağıdaki kodu MySimpleCalculator
sınıfına ekleyin:
Public Function Calculate(input As String) As String Implements ICalculator.Calculate
Dim left, right As Integer
Dim operation As Char
' Finds the operator.
Dim fn = FindFirstNonDigit(input)
If fn < 0 Then
Return "Could not parse command."
End If
operation = input(fn)
Try
' Separate out the operands.
left = Integer.Parse(input.Substring(0, fn))
right = Integer.Parse(input.Substring(fn + 1))
Catch ex As Exception
Return "Could not parse command."
End Try
For Each i As Lazy(Of IOperation, IOperationData) In operations
If i.Metadata.symbol = operation Then
Return i.Value.Operate(left, right).ToString()
End If
Next
Return "Operation not found!"
End Function
public String Calculate(string input)
{
int left;
int right;
char operation;
// Finds the operator.
int fn = FindFirstNonDigit(input);
if (fn < 0) return "Could not parse command.";
try
{
// Separate out the operands.
left = int.Parse(input.Substring(0, fn));
right = int.Parse(input.Substring(fn + 1));
}
catch
{
return "Could not parse command.";
}
operation = input[fn];
foreach (Lazy<IOperation, IOperationData> i in operations)
{
if (i.Metadata.Symbol.Equals(operation))
{
return i.Value.Operate(left, right).ToString();
}
}
return "Operation Not Found!";
}
İlk adımlar, giriş dizesini sol ve sağ işlenenler ve bir işleç karakteri olarak ayrıştırır. foreach
Döngüde, koleksiyonun her üyesi operations
incelenir. Bu nesneler türündedir Lazy<T,TMetadata> ve meta veri değerlerine ve aktarılmış nesnesine sırasıyla özelliği ve Value özelliği ile Metadata erişilebilir. Bu durumda Symbol
, nesnesinin özelliği IOperationData
bir eşleşme olarak bulunursa, hesaplayıcı nesnenin yöntemini IOperation
çağırır Operate
ve sonucu döndürür.
Hesaplayıcıyı tamamlayabilmeniz için bir dizedeki ilk basamak olmayan karakterin konumunu döndüren bir yardımcı yöntemi de gereklidir. Sınıfına aşağıdaki yardımcı yöntemi MySimpleCalculator
ekleyin:
Private Function FindFirstNonDigit(s As String) As Integer
For i = 0 To s.Length - 1
If Not Char.IsDigit(s(i)) Then Return i
Next
Return -1
End Function
private int FindFirstNonDigit(string s)
{
for (int i = 0; i < s.Length; i++)
{
if (!char.IsDigit(s[i])) return i;
}
return -1;
}
Artık projeyi derleyip çalıştırabilmelisiniz. Visual Basic, anahtar sözcüğünü öğesine Module1
eklediğinizden emin Public
olun. Konsol penceresinde, "5 + 3" gibi bir ek işlem yazın ve Hesaplayıcı sonuçları döndürür. Başka herhangi bir operatör "Işlem bulunamadı!" iletisi ile sonuçlanır.
Hesap Makinası artık işe yarar, yeni bir işlem eklemek kolaydır. Aşağıdaki sınıfı modüle veya SimpleCalculator
ad alanına ekleyin:
<Export(GetType(IOperation))>
<ExportMetadata("Symbol", "-"c)>
Public Class Subtract
Implements IOperation
Public Function Operate(left As Integer, right As Integer) As Integer Implements IOperation.Operate
Return left - right
End Function
End Class
[Export(typeof(IOperation))]
[ExportMetadata("Symbol", '-')]
class Subtract : IOperation
{
public int Operate(int left, int right)
{
return left - right;
}
}
Projeyi derleyin ve çalıştırın. "5-3" gibi bir çıkarma işlemi yazın. Hesaplayıcı artık çıkarma ve ekleme de desteklemektedir.
Kaynak koda sınıflar eklemek yeterince basittir, ancak MEF, bir uygulamanın parçalar için kendi kaynağını göz atabilme olanağı sağlar. Bunu göstermek için, SimpleCalculator ' ı, bir dizini ve kendi derlemesini, parçaları için bir ekleyerek bir DirectoryCatalog Dizin arayacak şekilde değiştirmeniz gerekir.
SimpleCalculator projesine adlı Extensions
Yeni bir dizin ekleyin. Çözüm düzeyinde değil, proje düzeyine eklediğinizden emin olun. Ardından adlı ExtendedOperations
çözüme yeni bir sınıf kitaplığı projesi ekleyin. Yeni proje ayrı bir derlemede derlenir.
extendedoperations projesi için Project özellikler tasarımcısını açın ve derle veya derle sekmesine tıklayın. derleme çıkış yolunu veya çıkış yolunu , SimpleCalculator proje dizinindeki (..) uzantıları dizinine işaret etmek üzere değiştirin. \Simplehesaplator\extensions\).
Module1. vb veya program. cs' de, oluşturucuya aşağıdaki satırı Program
ekleyin:
catalog.Catalogs.Add(
New DirectoryCatalog(
"C:\SimpleCalculator\SimpleCalculator\Extensions"))
catalog.Catalogs.Add(
new DirectoryCatalog(
"C:\\SimpleCalculator\\SimpleCalculator\\Extensions"));
Örnek yolu, uzantılar dizininizin yolunu ile değiştirin. (Bu mutlak yol yalnızca hata ayıklama amaçlıdır. Bir üretim uygulamasında göreli bir yol kullanırsınız.) Artık, DirectoryCatalog Uzantılar dizinindeki tüm derlemelerde bulunan herhangi bir parçayı bileşim kapsayıcısına ekler.
ExtendedOperations projesinde, SimpleCalculator ve System. ComponentModel. Composition başvurularını ekleyin. ExtendedOperations sınıf dosyasında, System. ComponentModel. Composition için bir Imports
veya bir using
ifade ekleyin. Visual Basic ayrıca, SimpleCalculator için bir Imports
ifade ekleyin. Ardından, aşağıdaki sınıfı ExtendedOperations sınıf dosyasına ekleyin:
<Export(GetType(SimpleCalculator.IOperation))>
<ExportMetadata("Symbol", "%"c)>
Public Class Modulo
Implements IOperation
Public Function Operate(left As Integer, right As Integer) As Integer Implements IOperation.Operate
Return left Mod right
End Function
End Class
[Export(typeof(SimpleCalculator.IOperation))]
[ExportMetadata("Symbol", '%')]
public class Mod : SimpleCalculator.IOperation
{
public int Operate(int left, int right)
{
return left % right;
}
}
Sözleşmenin eşleşmesi için özniteliğinin ile ExportAttribute aynı türde ImportAttribute olması gerektiğini unutmayın.
Projeyi derleyin ve çalıştırın. Yeni mod (%) işlecini test edin.
Bu konu, MEF 'in temel kavramlarını ele almaktadır.
Parçalar, kataloglar ve bileşim kapsayıcısı
Parçalar ve bileşim kapsayıcısı, MEF uygulamasının temel yapı taşlarıdır. Bir bölüm, kendisini içeren veya dahil olmak üzere bir değeri içeri aktaran veya dışarı aktaran herhangi bir nesnedir. Bir katalog, belirli bir kaynaktan bir parçalar koleksiyonu sağlar. Bileşim kapsayıcısı, bir katalog tarafından, dışarı aktarmalar için içeri aktarmalar bağlamayı bağlayan bir katalog tarafından sunulan bölümleri kullanır.
İçeri aktarmalar ve dışarı aktarmalar
İçeri ve dışarı aktarmalar, bileşenlerin iletişim kurduğu yoldur. İçeri aktarma ile, bileşen belirli bir değer veya nesne için ihtiyacı belirtir ve bir dışarı aktarma ile bir değerin kullanılabilirliğini belirtir. Her içeri aktarma, sözleşmesi yoluyla dışarı aktarmalar listesi ile eşleştirilir.
Bu örneğe ilişkin tüm kodu indirmek için bkz. SimpleCalculator örneği (Visual Basic).
daha fazla bilgi ve kod örneği için bkz. Managed Extensibility Framework. MEF türlerinin bir listesi için bkz System.ComponentModel.Composition . ad alanı.