Managed Extensibility Framework (MEF)

  • Artikel

Topik ini memberikan gambaran umum tentang Kerangka Kerja Ekstensibilitas Terkelola yang diperkenalkan dalam .NET Framework 4.

Apa itu MEF?

Managed Extensibility Framework atau MEF adalah pustaka untuk membuat aplikasi yang ringan dan dapat diperluas. Ini memungkinkan pengembang aplikasi untuk menemukan dan menggunakan ekstensi tanpa konfigurasi yang diperlukan. Ini juga memungkinkan pengembang ekstensi dengan mudah merangkum kode dan menghindari dependensi keras yang rapuh. MEF tidak hanya memungkinkan ekstensi digunakan kembali dalam aplikasi, tetapi juga di seluruh aplikasi.

Masalah ekstensibilitas

Bayangkan Anda adalah arsitek aplikasi besar yang harus memberikan dukungan untuk ekstensibilitas. Aplikasi Anda harus menyertakan sejumlah besar komponen yang lebih kecil, dan bertanggung jawab untuk membuat dan menjalankannya.

Pendekatan paling sederhana untuk masalah ini adalah menyertakan komponen sebagai kode sumber dalam aplikasi Anda, dan memanggilnya langsung dari kode Anda. Ini memiliki sejumlah kelemahan yang jelas. Yang paling penting, Anda tidak dapat menambahkan komponen baru tanpa memodifikasi kode sumber, pembatasan yang mungkin dapat diterima di, misalnya, aplikasi Web, tetapi tidak dapat dikerjakan dalam aplikasi klien. Sama-sama bermasalah, Anda mungkin tidak memiliki akses ke kode sumber untuk komponen, karena mungkin dikembangkan oleh pihak ketiga, dan karena alasan yang sama Anda tidak dapat mengizinkan mereka mengakses milik Anda.

Pendekatan yang sedikit lebih canggih adalah menyediakan titik ekstensi atau antarmuka, untuk memungkinkan pemisahan antara aplikasi dan komponennya. Di bawah model ini, Anda mungkin menyediakan antarmuka yang dapat diterapkan komponen, dan API untuk memungkinkannya berinteraksi dengan aplikasi Anda. Ini memecahkan masalah membutuhkan akses kode sumber, tetapi masih memiliki kesulitan sendiri.

Karena aplikasi tidak memiliki kapasitas apa pun untuk menemukan komponen sendiri, aplikasi harus tetap diberi tahu secara eksplisit komponen mana yang tersedia dan harus dimuat. Ini biasanya dicapai dengan secara eksplisit mendaftarkan komponen yang tersedia dalam file konfigurasi. Ini berarti bahwa memastikan bahwa komponen sudah benar menjadi masalah pemeliharaan, terutama jika itu adalah pengguna akhir dan bukan pengembang yang diharapkan untuk melakukan pembaruan.

Selain itu, komponen tidak mampu berkomunikasi satu sama lain, kecuali melalui saluran aplikasi yang ditentukan dengan kaku itu sendiri. Jika arsitek aplikasi belum mengantisipasi kebutuhan akan komunikasi tertentu, biasanya itu tidak mungkin.

Akhirnya, pengembang komponen harus menerima dependensi keras pada assembly apa yang berisi antarmuka yang mereka terapkan. Ini menyulitkan komponen untuk digunakan di lebih dari satu aplikasi, dan juga dapat membuat masalah saat Anda membuat kerangka kerja pengujian untuk komponen.

Apa yang disediakan MEF

Alih-alih pendaftaran eksplisit komponen yang tersedia ini, MEF menyediakan cara untuk menemukannya secara implisit, melalui komposisi. Komponen MEF, yang disebut bagian, secara deklaratif menentukan dependensinya (dikenal sebagai impor) dan kemampuan apa (dikenal sebagai ekspor) yang disediakannya. Ketika bagian dibuat, mesin komposisi MEF memenuhi impornya dengan apa yang tersedia dari bagian lain.

Pendekatan ini memecahkan masalah yang dibahas di bagian sebelumnya. Karena bagian MEF secara deklaratif menentukan kemampuannya, komponen tersebut dapat ditemukan pada durasi, yang berarti aplikasi dapat menggunakan bagian tanpa referensi yang dikodekan secara permanen atau file konfigurasi yang rapuh. MEF memungkinkan aplikasi untuk menemukan dan memeriksa bagian berdasarkan metadata mereka, tanpa membuat instans atau bahkan memuat rakitan mereka. Akibatnya, tidak perlu dengan hati-hati menentukan kapan dan bagaimana ekstensi harus dimuat.

Selain ekspor yang disediakan, bagian dapat menentukan impornya, yang akan diisi oleh bagian lain. Ini membuat komunikasi di antara bagian-bagian tidak hanya mungkin, tetapi mudah, dan memungkinkan faktor kode yang baik. Misalnya, layanan yang umum untuk banyak komponen dapat diperhitungkan menjadi bagian terpisah dan mudah dimodifikasi atau diganti.

Karena model MEF tidak memerlukan dependensi keras pada rakitan aplikasi tertentu, model ini memungkinkan ekstensi digunakan kembali dari aplikasi ke aplikasi. Ini juga memudahkan untuk mengembangkan rangkaian pengujian, independen dari aplikasi, untuk menguji komponen ekstensi.

Aplikasi yang dapat diperluas yang ditulis dengan menggunakan MEF menyatakan impor yang dapat diisi oleh komponen ekstensi, dan juga dapat menyatakan ekspor untuk mengekspos layanan aplikasi ke ekstensi. Setiap komponen ekstensi menyatakan ekspor, dan juga dapat menyatakan impor. Dengan cara ini, komponen ekstensi itu sendiri secara otomatis dapat diperluas.

Di mana MEF tersedia

MEF adalah bagian integral dari .NET Framework 4, dan tersedia di mana pun .NET Framework digunakan. Anda dapat menggunakan MEF di aplikasi klien Anda, baik menggunakan Formulir Windows, WPF, atau teknologi lainnya, atau dalam aplikasi server yang menggunakan ASP.NET.

MEF dan MAF

Versi .NET Framework sebelumnya memperkenalkan Managed Add-in Framework (MAF), yang dirancang untuk memungkinkan aplikasi mengisolasi dan mengelola ekstensi. Fokus MAF sedikit lebih tinggi daripada MEF, berkonsentrasi pada isolasi ekstensi dan pemuatan dan bongkar muat perakitan, sedangkan MEF berfokus pada kemampuan penemuan, ekstensibilitas, dan portabilitas. Kedua kerangka kerja beroperasi dengan lancar, dan satu aplikasi dapat memanfaatkan keduanya.

SimpleCalculator: Contoh aplikasi

Cara paling sederhana untuk melihat apa yang dapat dilakukan MEF adalah dengan membangun aplikasi MEF sederhana. Dalam contoh ini, Anda membangun kalkulator yang sangat sederhana bernama SimpleCalculator. Tujuan SimpleCalculator adalah untuk membuat aplikasi konsol yang menerima perintah aritmatika dasar, dalam bentuk "5+3" atau "6-2", dan mengembalikan jawaban yang benar. Dengan menggunakan MEF, Anda akan dapat menambahkan operator baru tanpa mengubah kode aplikasi.

Untuk mengunduh kode lengkap untuk contoh ini, lihat sampel SimpleCalculator (Visual Basic).

Catatan

Tujuan SimpleCalculator adalah untuk menunjukkan konsep dan sintaks MEF, daripada harus memberikan skenario realistis untuk penggunaannya. Banyak aplikasi yang paling mendapat manfaat dari kekuatan MEF lebih kompleks daripada SimpleCalculator. Untuk contoh yang lebih luas, lihat Kerangka Kerja Ekstensibilitas Terkelola di GitHub.

  • Untuk memulai, di Visual Studio, buat proyek Aplikasi Konsol baru dan beri nama SimpleCalculator.

  • Tambahkan referensi ke assembly System.ComponentModel.Composition, tempat MEF berada.

  • Buka Module1.vb atau Program.cs dan tambahkan Imports atau using pernyataan untuk System.ComponentModel.Composition dan System.ComponentModel.Composition.Hosting. Kedua namespace ini berisi jenis MEF yang Anda perlukan untuk mengembangkan aplikasi yang dapat diperluas.

  • Jika Anda menggunakan Visual Basic, tambahkan Public kata kunci ke baris yang mendeklarasikan Module1 modul.

Kontainer komposisi dan katalog

Inti dari model komposisi MEF adalah kontainer komposisi, yang berisi semua bagian yang tersedia dan melakukan komposisi. Komposisi adalah pencocokan impor dengan ekspor. Jenis kontainer komposisi yang paling umum adalah CompositionContainer, dan Anda akan menggunakan ini untuk SimpleCalculator.

Jika Anda menggunakan Visual Basic, tambahkan kelas publik bernama Program di Module1.vb.

Tambahkan baris berikut ke Program kelas di Module1.vb atau Program.cs:

Dim _container As CompositionContainer

private CompositionContainer _container;

Untuk menemukan bagian yang tersedia untuk itu, kontainer komposisi menggunakan katalog. Katalog adalah objek yang membuat bagian yang tersedia ditemukan dari beberapa sumber. MEF menyediakan katalog untuk menemukan bagian dari jenis yang disediakan, rakitan, atau direktori. Pengembang aplikasi dapat dengan mudah membuat katalog baru untuk menemukan bagian dari sumber lain, seperti layanan Web.

Tambahkan konstruktor berikut ke Program kelas :

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());
    }
}

Panggilan untuk ComposeParts memberi tahu kontainer komposisi untuk menyusun sekumpulan bagian tertentu, dalam hal ini instans saat ini dari Program. Namun, pada titik ini, tidak ada yang akan terjadi, karena Program tidak memiliki impor untuk diisi.

Impor dan Ekspor dengan atribut

Pertama, Anda telah Program mengimpor kalkulator. Ini memungkinkan pemisahan masalah antarmuka pengguna, seperti input dan output konsol yang akan masuk ke Program, dari logika kalkulator.

Tambahkan kode berikut ke kelas Program:

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

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

Perhatikan bahwa deklarasi calculator objek tidak biasa, tetapi dihiasi dengan ImportAttribute atribut. Atribut ini menyatakan sesuatu sebagai impor; artinya, itu akan diisi oleh mesin komposisi ketika objek dikomposisi.

Setiap impor memiliki kontrak, yang menentukan ekspor apa yang akan dicocokkannya. Kontrak dapat menjadi string yang ditentukan secara eksplisit, atau dapat secara otomatis dihasilkan oleh MEF dari jenis tertentu, dalam hal ini antarmuka ICalculator. Setiap ekspor yang dinyatakan dengan kontrak yang cocok akan memenuhi impor ini. Perhatikan bahwa meskipun jenis calculator objek sebenarnya ICalculator, ini tidak diperlukan. Kontrak tidak bergantung pada jenis objek pengimporan. (Dalam hal ini, Anda bisa meninggalkan typeof(ICalculator). MEF akan secara otomatis mengasumsikan kontrak didasarkan pada jenis impor kecuali Anda menentukannya secara eksplisit.)

Tambahkan antarmuka yang sangat sederhana ini ke modul atau SimpleCalculator namespace layanan:

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

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

Sekarang setelah Anda mendefinisikan ICalculator, Anda memerlukan kelas yang mengimplementasikannya. Tambahkan kelas berikut ke modul atau SimpleCalculator namespace layanan:

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

End Class

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

}

Berikut adalah ekspor yang akan cocok dengan impor di Program. Agar ekspor sesuai dengan impor, ekspor harus memiliki kontrak yang sama. Mengekspor berdasarkan typeof(MySimpleCalculator) kontrak akan menghasilkan ketidakcocokan, dan impor tidak akan terisi; kontrak harus sama persis.

Karena kontainer komposisi akan diisi dengan semua bagian yang tersedia di perakitan ini, bagian MySimpleCalculator akan tersedia. Ketika konstruktor untuk Program melakukan komposisi pada objek, impornya akan diisi dengan Program objek, yang akan dibuat untuk tujuan tersebutMySimpleCalculator.

Lapisan antarmuka pengguna (Program) tidak perlu mengetahui hal lain. Oleh karena itu, Anda dapat mengisi logika antarmuka pengguna lainnya dalam metodeMain.

Tambahkan kode berikut ke metode Main:

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));
    }
}

Kode ini hanya membaca baris input dan memanggil Calculate fungsi ICalculator pada hasil, yang ditulis kembali ke konsol. Itu saja kode yang Anda butuhkan di Program. Semua pekerjaan lainnya akan terjadi di bagian-bagian.

Atribut Impor dan ImportMany

Agar SimpleCalculator dapat diperluas, aplikasi ini perlu mengimpor daftar operasi. Atribut biasa ImportAttribute diisi oleh satu dan hanya satu ExportAttribute. Jika lebih dari satu tersedia, mesin komposisi menghasilkan kesalahan. Untuk membuat impor yang dapat diisi oleh sejumlah ekspor, Anda dapat menggunakan ImportManyAttribute atribut.

Tambahkan properti berikut ke kelas MySimpleCalculator:

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

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

Lazy<T,TMetadata> adalah jenis yang disediakan oleh MEF untuk menyimpan referensi tidak langsung ke ekspor. Di sini, selain objek yang diekspor itu sendiri, Anda juga mendapatkan metadata ekspor, atau informasi yang menjelaskan objek yang diekspor. Masing-masing Lazy<T,TMetadata> berisi IOperation objek, yang mewakili operasi aktual, dan IOperationData objek, yang mewakili metadatanya.

Tambahkan antarmuka sederhana berikut ke modul atau SimpleCalculator namespace layanan:

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; }
}

Dalam hal ini, metadata untuk setiap operasi adalah simbol yang mewakili operasi tersebut, seperti +, -, *, dan sebagainya. Untuk membuat operasi penambahan tersedia, tambahkan kelas berikut ke modul atau SimpleCalculator namespace layanan:

<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;
    }
}

Atribut ExportAttribute berfungsi seperti sebelumnya. Atribut ExportMetadataAttribute melampirkan metadata, dalam bentuk pasangan nama-nilai, ke ekspor tersebut. Sementara kelas Add mengimplementasikan IOperation, kelas yang menerapkan IOperationData tidak ditentukan secara eksplisit. Sebaliknya, kelas secara implisit dibuat oleh MEF dengan properti berdasarkan nama metadata yang disediakan. (Ini adalah salah satu dari beberapa cara untuk mengakses metadata di MEF.)

Komposisi dalam MEF bersifat rekursif. Anda secara eksplisit menyusun Program objek, yang mengimpor ICalculator yang ternyata berjenis MySimpleCalculator. MySimpleCalculator, pada gilirannya, mengimpor kumpulan IOperation objek, dan impor tersebut akan diisi ketika MySimpleCalculator dibuat, pada saat yang sama dengan impor Program. Add Jika kelas menyatakan impor lebih lanjut, itu juga harus diisi, dan sebagainya. Impor yang dibiarkan tidak terisi menghasilkan kesalahan komposisi. (Namun, dimungkinkan untuk menyatakan impor bersifat opsional atau menetapkan nilai default.)

Logika kalkulator

Dengan bagian-bagian ini di tempat, yang tersisa hanyalah logika kalkulator itu sendiri. Tambahkan kode berikut di MySimpleCalculator kelas untuk mengimplementasikan Calculate metode:

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!";
}

Langkah-langkah awal mengurai string input ke operand kiri dan kanan dan karakter operator. Dalam perulangan foreach, setiap anggota operations koleksi diperiksa. Objek ini berjenis Lazy<T,TMetadata>, dan nilai metadatanya dan objek yang diekspor dapat diakses dengan Metadata properti dan Value properti masing-masing. Dalam hal ini, jika Symbol properti IOperationData objek ditemukan cocok, kalkulator memanggil Operate metode IOperation objek dan mengembalikan hasilnya.

Untuk menyelesaikan kalkulator, Anda juga memerlukan metode pembantu yang mengembalikan posisi karakter non-digit pertama dalam string. Tambahkan bantuan metode berikut ke kelas MySimpleCalculator:

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;
}

Anda sekarang dapat mengkompilasi dan menjalankan proyek. Dalam Visual Basic, pastikan Anda menambahkan Public kata kunci ke Module1. Di jendela konsol, ketik operasi penambahan, seperti "5+3", dan kalkulator mengembalikan hasilnya. Operator lain menghasilkan pesan "Operasi Tidak Ditemukan!".

Memperluas SimpleCalculator menggunakan kelas baru

Sekarang setelah kalkulator berfungsi, menambahkan operasi baru itu mudah. Tambahkan kelas berikut ke modul atau SimpleCalculator namespace layanan:

<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;
    }
}

Kompilasi dan jalankan proyek. Ketik operasi pengurangan, seperti "5-3". Kalkulator sekarang mendukung pengurangan serta penambahan.

Memperluas SimpleCalculator menggunakan rakitan baru

Menambahkan kelas ke kode sumber cukup sederhana, tetapi MEF menyediakan kemampuan untuk melihat ke luar sumber aplikasi sendiri untuk bagian-bagiannya. Untuk menunjukkan hal ini, Anda harus memodifikasi SimpleCalculator untuk mencari direktori, serta rakitannya sendiri, untuk bagian-bagian, dengan menambahkan DirectoryCatalog.

Tambahkan direktori baru bernama Extensions ke proyek SimpleCalculator. Pastikan untuk menambahkannya di tingkat proyek, dan bukan pada tingkat solusi. Kemudian tambahkan proyek Pustaka Kelas .NET Framework baru ke solusi, bernama ExtendedOperations. Proyek baru akan dikompilasi ke dalam rakitan terpisah.

Buka Project Properties Designer untuk proyek ExtendedOperations dan klik tab Kompilasi atau Build. Ubah jalur output Build atau jalur Output untuk menunjuk ke direktori Ekstensi di direktori proyek SimpleCalculator (..\SimpleCalculator\Extensions\).

Di Module1.vb atau Program.cs, tambahkan baris berikut ke Program konstruktor:

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

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

Ganti jalur contoh dengan jalur ke direktori Ekstensi Anda. (Jalur absolut ini hanya untuk tujuan penelusuran kesalahan. Dalam aplikasi produksi, Anda akan menggunakan jalur relatif.) DirectoryCatalog sekarang akan menambahkan bagian apa pun yang ditemukan di rakitan apa pun di direktori Ekstensi ke kontainer komposisi.

Dalam proyek ExtendedOperations, tambahkan referensi ke SimpleCalculator dan System.ComponentModel.Composition. Dalam file kelas ExtendedOperations, tambahkan Imports atau using pernyataan untuk System.ComponentModel.Composition. Di Visual Basic, tambahkan juga Imports pernyataan untuk SimpleCalculator. Kemudian tambahkan kelas berikut ke file kelas ExtendedOperations:

<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;
    }
}

Perhatikan bahwa agar kontrak cocok, ExportAttribute atribut harus memiliki jenis yang sama dengan ImportAttribute.

Kompilasi dan jalankan proyek. Uji operator Mod (%) baru.

Kesimpulan

Topik ini membahas konsep dasar MEF.

  • Bagian, katalog, dan kontainer komposisi

    Bagian dan kontainer komposisi adalah blok penyusun dasar aplikasi MEF. Bagian adalah objek apa pun yang mengimpor atau mengekspor nilai, hingga dan termasuk dirinya sendiri. Katalog menyediakan kumpulan bagian dari sumber tertentu. Kontainer komposisi menggunakan bagian yang disediakan oleh katalog untuk melakukan komposisi, pengikatan impor ke ekspor.

  • Impor dan ekspor

    Impor dan ekspor adalah cara komponen berkomunikasi. Dengan impor, komponen menentukan kebutuhan akan nilai atau objek tertentu, dan dengan ekspor, komponen menentukan ketersediaan nilai. Setiap impor dicocokkan dengan daftar ekspor melalui kontraknya.

Langkah berikutnya

Untuk mengunduh kode lengkap untuk contoh ini, lihat sampel SimpleCalculator (Visual Basic).

Untuk informasi selengkapnya dan contoh kode, lihat Kerangka Kerja Ekstensibilitas Terkelola. Untuk daftar jenis MEF, lihat System.ComponentModel.Composition namespace layanan.