Managed Extensibility Framework'e (Yönetilen Genişletilebilirlik Çerçevesi) Genel bir Bakış

Makale
08/01/2011

Bu konu, .NET Framework 4'de tanıtılan Managed Extensibility Framework'le ilgili genel bir bakış sunar.

Bu konu aşağıdaki bölümleri içerir.

MEF nedir?
Genişletilebilirlik Sorunu
MEF Ne Sağlar?
MEF Nerede Mevcuttur?
MEF ve MAF
SimpleCalculator (Basit Hesap Makinesi): Örnek bir Uygulama
Bileşim Kapsayıcı ve Kataloglar
Öznitelikler ile İçeri ve Dışarı Aktarmalar
Daha Fazla İçeri Aktarma ve ImportMany
Hesap Makinesi Mantığı
Yeni bir Sınıf Kullanarak SimpleCalculator'ı Genişletme
Yeni bir Derleme Kullanarak SimpleCalculator'ı Genişletme
Sonuç
Şimdi Nereye Gitmeliyim?

MEF nedir?

Managed Extensibility Framework veya MEF, hafif genişletilebilir uygulamalar oluşturmaya yarayan bir kitaplıktır. Geliştiricilere yapılandırma gerektirmeden uzantıları keşfedip kullanma imkanı sağlar. Uzantı geliştiricilerine kodu kolayca şifreleyip kırılgan sıkı bağımlıklardan kaçınılmasını da sağlar. MEF uzantılarının uygulamalar içinde yeniden kullanılmasına izin verilmesinin yanında, uygulamalar arasında kullanılmasını da ağlar.

Genişletilebilirlik Sorunu

Genişletilebilirlik için destek sağlayan geniş bir uygulamanın mimarı olduğunuzu düşünün. Uygulamanız çok sayıda küçük bileşen içermek zorundadır ve bunların oluşturulması ve çalıştırılmasından sorumludur.

Soruna en basit yaklaşım, bileşenleri uygulamanıza kaynak kodu olarak ekleyip bunları doğrudan koddan çağırmaktır. Bunun belirgin bazı dezavantajları vardır. En önemlisi, kaynak kodu değiştirmeden yeni bileşen ekleyememenizdir. Örneğin, bir Web uygulamasında kabul edilebilir bir sınırlama, istemci bir uygulamada çalışmayabilir. Ayrı bir sorun olarak, sizin kendi geliştirdikleriniz için izin vermediğiniz gibi üçüncü tarafların geliştirdiği bileşenler için kaynak koda erişim iznine sahip olmayabilirsiniz.

Biraz daha karmaşık bir yaklaşım, uygulama ve bileşenleri arasında bağlantıyı kesmeye izin vermek için bir uzantı noktası veya arayüz sağlamak olabilir. Bu model altında, uygulamanızla etkileşmek üzere bir bileşenin uygulayacağı bir arayüz ve bunu etkileştirmek için bir API sağlayabilirsiniz. Bu, kaynak koduna erişim gereksinimi sorununu çözer ama başka zorluklara sahiptir.

Uygulamanın kendisi bileşenleri keşfetme yeteneğine sahip olmadığından, hangi bileşenlerin mevcut olduğu ve yüklenmesi gerekti uygulamaya açıkça bildirilmelidir. Bu, genellikle bir yapılandırma dosyasındaki kullanılabilir bileşenleri açıkça kaydederek gerçekleştirilir. Özellikle güncelleştirmeyi yapması beklenen kişi geliştirici değil de son kullanıcıysa; bu, bileşenlerin doğru olduğunu garanti etmenin bir bakım konusu olduğunu gösterir.

Buna ek olarak, uygulamanın kendisi tarafından tanımlanan kanallar aracılığı dışında bileşenler birbiriyle iletişim yeteneğine sahip değildir. Uygulama mimarisi belirli bir iletişim ihtiyacı beklemiyorsa, bu olanaksızdır.

Son olarak, bileşen geliştiricileri hangi derlemenin uyguladıkları arayüzü içerdiği üzerine sıkı bir bağımlılık kabul etmek zorundadır. Bu, bir bileşenin birden fazla uygulamada kullanılmasını zorlaştırır ve bileşenler için bir test çerçevesi oluşturduğunuzda sorunlara sebep olabilir.

MEF Ne Sağlar?

Mevcut bileşenlerin açık kaydı yerine MEF, composition aracılığıyla bunları açıkça keşfetmenizi sağlar. part olarak çağrılan bir MEF bileşeni, hem bağımlılıklarını (imports olarak bilinir) hem de hangi kabileyetlere (exports olarak bilinir) erişim sağladığını belirtir. Bir bölüm oluşturulduğunda, MEF bileşim motoru, diğer bölümlerden erişilen içeri aktarımları karşılar.

Bu yaklaşım, önceki bölümde açıklanan sorunların giderilmesini sağlar. MEF bölümleri bildirimli olarak kabiliyetlerini belirttiğinden, bunlar çalışma zamanında keşfedilebilir. Bu, bir uygulamamom kırılgan yapılandırma dosyaları ya da sıkı kodlanmış başvurular olmadan bölümleri kullanabileceği anlamına gelir. MEF, ugulamalarınkendi meta verileri tarafından örneklemeden veya derlemelerini bile yüklemeden bulup bölümleri incelemenizi sağlar. Sonuç olarak, uzantıların nasıl ve ne zaman yüklenmiş olması gerektiğini belirtmenize gerek yoktur.

Sağlanan dışa aktarımlarının yanında, bir bölüm diğer bölümler tarafından doldurulacak kendi içeri aktarımlarını belirtebilir. Bu, bölüm arasında iletişimi kolaylaştırır ve kodun iyi bir şekilde düzenlenmesini sağlar. Örneğin, birçok bileşen için ortak hizmetler ayrı bir bölüm içinde kolayca değiştirilebilir.

MEF modeli belirli bir uygulama derlemesi üzerinde sıkı bir bağımlılık gerektirmediğinden, uzantıların uygulamadan uygulamaya yeniden kullanılmasına izin verir. Bu ayrıca uzantı bileşenlerini test etmek için uygulamadan bağımsız bir test bandı oluşturmayı kolaylaşıtırır.

MEF kullanarak yazılan genişletilebilir bir uygulama uzantı bileşenleri tarafından dolduralabilecek bir içeri aktarım bildirir ve uzantılara uygulama hizmetlerini göstermek için dışarı aktarımları da bildirebilir. Her uzantı bileşeni bir dışarı aktarım bildirir ve içeri aktarımlar da bildirebilir. Bu şekilde, uzantı bileşenlerinin kendileri otomatik olarak genişletilebilirdir.

MEF Nerede Mevcuttur?

MEF, .NET Framework 4'ün tamamlayıcı bir bileşenidir ve .NET Framework'ün kullanıldığı tüm yerlerde mevcuttur. Windows Forms, WPF veya diğer tüm teknolojileri kullanan istemci uygulamalarınızda veya ASP.NET kullanan sunucu uygulamalarda MEF kullanabilirsiniz.

MEF ve MAF

.NET Framewok'ün önceki sürümleri Managed Add-in Framework'ü (MAF) sunmuş ve uzantıları yalıtıp yönetmek için uygulamalara izin vermek üzere tasarlanmıştır. MAF'in odağı, MEF'ten biraz farklı olarak uzantı yalıtımına ve derleme yükleme ile geri yüklemeye yoğunlaşır. Öte yandan MEF'in odağı bulunabilirlik, genişletilebilirlik ve taşınabilirlik üzerinedir. Bu iki çerçeve sorunsuz olarak ortak biçimde çalışır ve bir uygulama ikisinden de faydalanabilir.

SimpleCalculator (Basit Hesap Makinesi): Örnek bir Uygulama

mef neler yapabileceğinizi görmek için en kolay yolu basit bir mef yapı oluşturmaktır. Bu örnekte, SimpleCalculator adlı çok basit bir hesap makinesi oluşturmak. SimpleCalculator'ün amacı, "5+3" veya "6-2" biçiminde temel aritmetik komutları kabul edip doğru sonuçları döndüren bir konsol uygulaması oluşturmaktır. MEF kullanarak, uygulama kodunu değiştirmeden yeni işleçler ekleyebileceksiniz.

Bu örneğin tam kodunu yüklemek için bkz: SimpleCalculator örnek.

Not
Kavramlar ve mef sözdizimini göstermek yerine mutlaka gerçekçi bir senaryo için kullanılmasını sağlamak üzere SimpleCalculator amacı budur.mef gücünden en yararlı uygulamaların çoğunu SimpleCalculator daha karmaşıktır.Daha kapsamlı örnek için bkz: Genişletilebilirlik Framework yönetilen Codeplex üzerinde.

, Başlatmak için Visual Studio 2010adlı yeni bir konsol uygulaması proje oluşturmak, SimpleCalculator. mef bulunduğu System.ComponentModel.Composition derlemesine ekleyin. Module1.vb veya Program.cs'i açın ve System.ComponentModel.Composition ile System.ComponentModel.Composition.Hosting için Imports ya da using deyimlerini ekleyin. Bu iki isim uzayı, genişletilebilir bir uygulama geliştirmek için ihtiyaç duyduğunuz MEF türlerini içerir. Visual Basic'te, ekleme Public bildirir satırında anahtar sözcük Module1 modülü.

Bileşim Kapsayıcı ve Kataloglar

MEF bileşim modelinin çekirdeği, mevcut tüm kısımları içeren ve bileşimi gerçekleştiren composition container olur. (Başka bir deyişle, içeri aktarımların dışa aktarımlarla eşleşmesi.) Bileşim kapsayıcının en genel türü CompositionContainer'dır ve SimpleCalculator için bunu kullanacaksınız.

Visual Basic'te, Module1.vb dosyasındaki adlı bir public class Ekle Program. Daha sonra Module1.vb veya Program.cs'te Program sınıfına aşağıdaki satırı ekleyin.

Dim _container As CompositionContainer

private CompositionContainer _container;

Bunun için kullanılabilir bölümleri bulmak için, bileşim kapsayıcılar bir catalog kullanımı sağlar. Bir katalog, bazı kaynaklardaki bölümleri kullanılabilir hale getiren bir nesnedir. mef sağlanan bir türünü, bir derleme veya bir dizin bölümleri bulmak için kataloglar sağlar. Uygulama geliştiricileri, bir Web hizmeti gibi diğer kaynaklardan bölümleri bulmak için yeni kataloglar kolayca oluşturabilirsiniz.

Aşağıdaki oluşturucuyu Program sınıfına ekleyin.

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 Exception
        Console.WriteLine(ex.ToString)
    End Try
End Sub

private Program()
{
    //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);

    //Fill the imports of this object
    try
    {
        this._container.ComposeParts(this);
    }
    catch (CompositionException compositionException)
    {
        Console.WriteLine(compositionException.ToString());
   }
}

ComposeParts çağrısı, bu durumda Program'ın mevcut örneği, bileşim kapsayıcıya özel bir bölüm kümesi oluşturmasını söyler. Ancak bu noktada hiçbir şey oluşmaz, çünkü Program doldurmak için içeri aktarımlara sahip değildir.

Öznitelikler ile İçeri ve Dışarı Aktarmalar

İlk olarak Program bir hesap makinesini içeri aktarır. Bu, hesap makinesi mantığından Program'a gidecek konsol girdi ve çıktısı gibi kullanıcı arayüzü sorunlarının ayıklanmasını sağlar.

Aşağıdaki kodu Program sınıfına ekleyin:

<Import(GetType(ICalculator))>
Public Property calculator As ICalculator

[Import(typeof(ICalculator))]
public ICalculator calculator;

Dikkat bildiriminde, calculator nesne olağandışı değil ancak ile donatılmış ImportAttribute özniteliği. Bu öznitelik herhangi bir şeyin içeri aktarım olduğunu bildirir; nesne oluşturulduğunda bileşim motoru tarafından doldurulacaktır.

Her içeri aktarma hangi dışarı aktarımlarla eşleşeceğini belirleyen bir contract'a sahiptir, Anlaşma tam olarak belirtilmiş bir dize olabilir veya verilen bir türden MEF tarafından otomatik olarak da oluşturulabilir. Bu durumda arayüz ICalculator olur. Eşleşen bir anlaşma ile bildirilen tüm dışarı aktarımlar bu içeri aktarımı karşılar. Türüne dikkat edin calculator nesnedir aslında ICalculator, bu gerekli değildir. Sözleşme alma nesne türünden bağımsızdır. (Bu durumda, typeof(ICalculator)'u ihmal edebilirsiniz. MEF, açıkça belirtmedikçe anlaşmayı otomatik olarak içeri aktarımının türüne bağlı varsayar.)

Bu çok basit arabirim modülüne ekleyin veya SimpleCalculator ad:

Public Interface ICalculator
    Function Calculate(ByVal input As String) As String
End Interface

public interface ICalculator
{
    String Calculate(String input);
}

Şimdi ICalculator'i tanımladınız, bunu uygulayan bir sınıfa ihtiyacınız var. Aşağıdaki sınıfı modüle ya da SimpleCalculator isim uzayına ekleyin:

<Export(GetType(ICalculator))>
Public Class MySimpleCalculator
   Implements ICalculator

End Class

[Export(typeof(ICalculator))]
class MySimpleCalculator : ICalculator
{

}

Program'da içeri aktarımla eşleşecek dışarı aktarım burdadır. Alma eşleşecek şekilde dışa aktarmak için Dışa Aktar aynı sözleşme olması gerekir. typeof(MySimpleCalculator)'a bağlı olarak bir anlaşma altında dışarı aktarım, yanlış bir eşleşme oluşturur ve içeri aktarım doldurulmaz; anlaşma tam bir eşleşmeye ihtiyaç duyar.

Bu derlemede bileşim kapsayıcı mevcut tüm bölümler ile doldurulacağından, MySimpleCalculator bölümü erişilebilir olacaktır. Program'ın oluşturucusu Program nesnesi üzerinde bileşim gerçekleştirdiğinde, içeri aktarım bu amaçla oluşturacak MySimpleCalculator nesnesi ile doldurulur.

Kullanıcı arabirim katmanı (Program) başka bir şey bilmek zorunda değildir. Bu nedenle kullanıcı arabirimi mantığını geri kalanı doldurmak için Main yöntemi.

Aşağıdaki kodu ekleyip Main yöntemi:

Sub Main()
    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)
{
    Program p = new Program(); //Composition is performed in the constructor
    String s;
    Console.WriteLine("Enter Command:");
    while (true)
    {
        s = Console.ReadLine();
        Console.WriteLine(p.calculator.Calculate(s));
    }
}

Bu kod bir satır girdi okur ve sonuç üzerinde ICalculator'in bunu konsola yeniden yazan Calculate yöntemini çağırır. Program içinde ihtiyacınız olam kodların tümü bunlardır. İşin kalanının tümü, bölümler içinde gerçekleşir.

Daha Fazla İçeri Aktarma ve ImportMany

SimpleCalculator'ın genişletilebilir olması için, işleçlerin bir listesinin içeri alınması gerekir. Sıradan bir ImportAttribute özniteliği, bire bir ExportAttribute ile doldurulur. Birden fazla varsa, bileşim motoru hata verir. Herhangi bir sayıda verir doldurulabilir bir alma işlemi oluşturmak için kullanabileceğiniz ImportManyAttribute özniteliği.

Aşağıdaki işlemleri özelliğini eklemek MySimpleCalculator class:

<ImportMany()>
Public Property operations As IEnumerable(Of Lazy(Of IOperation, IOperationData))

[ImportMany]
IEnumerable<Lazy<IOperation, IOperationData>> operations;

Lazy<T, TMetadata>, dışarı aktarımlara başvuruları dolaylı olarak tutmak için MEF tarafından sağlanan bir türdür. Burada, dışarı aktarılan nesnenin kendisinin yanında, export metadata veya dışarı aktarılan nesneyi tanımlayan bilgiler de alırsınız. Her Lazy<T, TMetadata>, kendi meta verisini temsil eden bir IOperationData nesnesi ve asıl işlemi temsil eden bir IOperation nesnesi içerir.

Aşağıdaki basit arayüzleri modüle ya da SimpleCalculator isim uzayına ekleyin:

Public Interface IOperation
    Function Operate(ByVal left As Integer, ByVal 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 işlem için meta veriler söz konusu operasyonu gibi gösteren sembolüdür +, -, *, vb.. Ek işlemi kullanılabilir yapmak için, aşağıdak sınıfı modüle ya da SimpleCalculator isim uzayına ekleyin:

<Export(GetType(IOperation))>
<ExportMetadata("Symbol", "+"c)>
Public Class Add
    Implements IOperation

    Public Function Operate(ByVal left As Integer, ByVal 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 öznitelik yöntemleri; önceden yaptığı gibi. ExportMetadataAttribute özniteliği isim-değer çifti biçiminde meta veriyi bu dışarı aktarıma iliştirir. Sırada Add sınıf uygulayan IOperation, gerçekleştiren bir sınıf IOperationData açıkça tanımlanmamış. Bunun yerine, bir sınıf örtülü olarak mef tarafından sağlanan meta verileri adlarına dayalı özellikleri ile oluşturulur. (Bu, MEF'te meta verilere erişme yollarından birisidir.)

MEF'te bileşim recursive'dir. MySimpleCalculator türü haline getirilen bir ICalculator'i içeri aktaran Program nesnesini açık olarak oluşturdunuz. MySimpleCalculator, sırasıyla IOperation nesnelerinin bir kısmını içeri aktarır ve aynı zamanda Program'ım içeri aktarımları olarak MySimpleCalculator oluşturulduğunda bu içeri aktarım doldurulur. Add sınıfı başka bir içeri aktarım bildirseydi, bunun da doldurulması gerekirdi. Bileşimde doldurulmamış tüm içeri aktarımlar hataya sebep olur. (Bunun yanında içeri aktarımları isteğe bağlı şeklinde bildirebilir veya bunlara varsayılan değerler atayabilirsiniz.)

Hesap Makinesi Mantığı

Burdaki bu bölümler ile, tüm kalanlar hesap makinesinin mantığının kendisidir. Aşağıdaki kodda ekleme MySimpleCalculator uygulamak için sınıf Calculate yöntemi:

Public Function Calculate(ByVal input As String) As String Implements ICalculator.Calculate
    Dim left, right As Integer
    Dim operation As Char
    Dim fn = FindFirstNonDigit(input) 'Finds the operator
    If fn < 0 Then
        Return "Could not parse command."
    End If
    operation = input(fn)
    Try
        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;
    int fn = FindFirstNonDigit(input); //finds the operator
    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, girdi dizisini sol ve sağ terimler ile bir işleç karakter olarak ayrıştırır. foreach döngüsünde, operations kolleksiyonun her üyesi incelenir. Bu nesneler, Lazy<T, TMetadata>'in türü ve bunların meta verilerinin değerleridir, ayrıca dışarı aktarılan nesne sırasıyla Metadata özelliği ve Value özelliği ile erişilebilir olur. Bu durumda, IOperationData nesnesinin Symbol özelliği bir eşleşme olarak bulunursa, hesap makinası IOperation nesnesinin Operate yöntemini çağırır ve sonucu döndürür.

Hesap Makinesi tamamlamak için bir dizedeki ilk rakam olmayan karakter konumunu verir yardımcı yönteme de gerekir. Aşağıdaki yardımcı yönteme ekleyin MySimpleCalculator class:

Private Function FindFirstNonDigit(ByVal s As String) As Integer
    For i = 0 To s.Length
        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;
}

Şimdi projeyi derleyip çalıştırabiliyor olmanız gerekir. Visual Basic'te, eklediğiniz emin olun Public anahtar Module1. Konsol penceresinde, "5 + 3" gibi bir toplama işlemi yazın ve hesap makinesi sonuçlar verir. Diğer tüm işlemler "İşlem bulunamadı!" iletisi ile sonuçlanır.

Yeni bir Sınıf Kullanarak SimpleCalculator'ı Genişletme

Şimdi hesap makinası çalıştığı gibi, yeni bir işlem eklemek de kolaydır. Aşağıdaki sınıfı modüle ya da SimpleCalculator isim uzayına ekleyin:

<Export(GetType(IOperation))>
<ExportMetadata("Symbol", "-"c)>
Public Class Subtract
    Implements IOperation

    Public Function Operate(ByVal left As Integer, ByVal 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;
    }
}

Derlemek ve projeyi çalıştırın. "5-3" Gibi bir çıkarma işlemi yazın. Hesap makinesi, toplama yanı sıra çıkarma şimdi destekler.

Yeni bir Derleme Kullanarak SimpleCalculator'ı Genişletme

Sınıfları ekleme kaynak kod yeterince basit ama mef dışında bir uygulamanın kendi kaynak bölümlerini görebilme olanağı sağlar. Bunu göstermek için, bölümlere yönelik derlemeyle birlikte bir dizin araması için bir DirectoryCatalog ekleyerek SimpleCalculator'ı değiştirmeniz gerekir.

Adlı yeni bir dizin eklemek uzantıları SimpleCalculator projesi. Bunu proje düzeyine ekleyip çözüm düzeyine eklemediğinizden emin olun. Sonra yeni bir Class Library projesi adlı, ekleyin ExtendedOperations. Yeni proje ayrı bir derleme içine derlenecek.

ExtendedOperations proje için proje özelliklerini Tasarımcısı açın ve derleme veya Build sekmesi. Değişiklik çıkış yolu oluşturmak veya çıkış yolu SimpleCalculator proje dizininde uzantıları dizine yönlendirin (.. \SimpleCalculator\Extensions\).

Module1.vb veya Program.cs, aşağıdaki satırı Program kurucusu:

catalog.Catalogs.Add(New DirectoryCatalog("C:\SimpleCalculator\SimpleCalculator\Extensions"))

catalog.Catalogs.Add(new DirectoryCatalog("C:\\SimpleCalculator\\SimpleCalculator\\Extensions"));

Örnek yolu Extensions dizini yolunuzla değiştirin. (Bu mutlak hata ayıklama amacıyla yalnızca yoludur. Bir üretim uygulamasında, göreceli bir yol kullanır.) Şimdi DirectoryCatalog, Extension dizinindeki tüm derlemelerde bulunan tüm bölümler bileşim kapsayıcısına eklenecektir.

ExtendedOperations projesinde, SimpleCalculator ve System.ComponentModel.Composition başvurular ekleyin. ExtendedOperations sınıfı dosyasına ekleyin bir Imports veya bir using deyimi System.ComponentModel.Composition. Visual Basic'te de eklemek bir Imports deyimi SimpleCalculator. Daha sonra 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(ByVal left As Integer, ByVal 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;
    }
}

Anlaşmanın eşleşmesi için, ExportAttribute özniteliği ImportAttribute ile aynı türe sahip olması gerektiğine dikkat edin.

Derlemek ve projeyi çalıştırın. Yeni Mod (%) işleci sınayın.

Sonuç

Bu konu MEF'in temel kavramlarını ele aldı.

Bölümler, kataloglar ve bileşim kapsayıcı

Bölümler ve bileşim kapsayıcı, bir MEF uygulamasının temel yapı taşıdır. Bir bölüm, kendisi de dahil bir değeri içeri aktaran veya dışarı aktaran objelerin tümüdür. Bir katalog, belirli bir kaynaktan bölümler koleksiyonu sağlar. Bileşim kapsayıcı, içeri aktarımları dışarı aktarımlara bağlayan bileşimi gerçekleştirmek için bir katalog tarafından sağlanan bölümleri kullanır.
İçeri aktarımlar ve dışarı aktarımlar

İçeri aktarımlar ve dışarı aktarımlar, bileşenlerin iletişim kurduğu bir yönemdir. Bir içeri aktarım ile, bileşen belirli bir değer veya nesne için ihtiyacı belirtir ve bir dışarı aktarım ile bir değerin erişilebilirliğini belirler. Her içeri aktarım, anlaşma tarafından bir dışarı aktarım listesiyle eşleşir.

Şimdi Nereye Gitmeliyim?