Kerangka Kerja Ekstensibilitas Terkelola (MEF)

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

Apa itu MEF?

Managed Extensibility Framework (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 terpenting, Anda tidak dapat menambahkan komponen baru tanpa memodifikasi kode sumber, batasan 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 untuk 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 masih harus 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 benar menjadi masalah pemeliharaan, terutama jika itu adalah pengguna akhir dan bukan pengembang yang diharapkan untuk melakukan pembaruan.

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

Akhirnya, pengembang komponen harus menerima dependensi keras pada rakitan 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 sebuah bagian dibuat, mesin pembentukan MEF memenuhi impornya dengan apa yang tersedia dari bagian lain.

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

Selain ekspor yang telah ditentukan, sebuah komponen dapat menentukan impornya, yang akan dipenuhi oleh komponen lain. Ini membuat komunikasi antarbagian tidak hanya mungkin, tetapi mudah, dan memungkinkan pengorganisasian 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 membolehkan ekstensi digunakan kembali dari aplikasi ke aplikasi. Ini juga memudahkan untuk mengembangkan kerangka uji yang terpisah dari aplikasi, untuk menguji komponen tambahan.

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 mendeklarasikan 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 Windows Forms, WPF, atau teknologi lainnya, atau di 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 tingkatnya daripada MEF, dengan konsentrasi pada isolasi ekstensi serta pemuatan dan bongkar muat rakitan, sementara fokus MEF adalah pada kemampuan penemuan, ekstensibilitas, dan kemudahan portabilitas. Kedua kerangka kerja beroperasi dengan lancar, dan satu aplikasi dapat memanfaatkan keduanya.

SimpleCalculator: Aplikasi contoh

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).

Nota

Tujuan SimpleCalculator adalah untuk menunjukkan konsep dan sintaks MEF, daripada harus memberikan skenario realistis untuk penggunaannya. Banyak aplikasi yang akan mendapat manfaat paling besar 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 arahan untuk System.ComponentModel.Composition dan System.ComponentModel.Composition.Hosting. Kedua namespace ini berisi jenis MEF, Anda harus mengembangkan aplikasi yang dapat diperluas.
Jika Anda menggunakan Visual Basic, tambahkan Public kata kunci ke baris yang mendeklarasikan Module1 modul.

Susunan kontainer dan katalog-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 menyediakan bagian-bagian yang ditemukan dari beberapa sumber. MEF menyediakan katalog untuk menemukan bagian dari jenis yang disediakan, perakitan, 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 ke ComposeParts memberitahu kontainer komposisi untuk menyusun sekumpulan bagian tertentu, dalam hal ini instans saat ini dari Program. Namun, pada titik ini, tidak akan terjadi apapun, karena Program tidak memiliki data impor untuk diisi.

Impor dan Ekspor dengan atribut

Pertama, Anda perlu 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 objek calculator tidak biasa, tetapi dihiasi dengan atribut ImportAttribute. Atribut ini menyatakan sesuatu bersifat sebagai diekspor; artinya, atribut ini akan diisi oleh mesin komposisi ketika objek tersebut selesai disusun.

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 kebutuhan impor ini. Perhatikan bahwa, meskipun jenis objek calculator sebenarnya adalah ICalculator, ini tidak diperlukan. Kontrak independen dari jenis objek impor. (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:

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.

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

End Class

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

}

Ekspor berikut akan sesuai dengan impor di Program. Agar ekspor sesuai dengan impor, ekspor harus memiliki kontrak yang sama. Mengekspor berdasarkan kontrak typeof(MySimpleCalculator) akan menghasilkan ketidakcocokan, dan impor tidak akan diisi; kontrak harus cocok sepenuhnya.

Karena kontainer komposisi akan diisi dengan semua bagian yang tersedia dalam perakitan ini, bagian MySimpleCalculator akan tersedia. Ketika konstruktor untuk Program melakukan komposisi pada objek Program, impor dari objek tersebut akan diisi dengan objek MySimpleCalculator, yang akan dibuat untuk tujuan tersebut.

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

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 satu baris input dan memanggil fungsi Calculate pada hasil ICalculator, yang kemudian ditulis kembali ke konsol. Itu saja kode yang Anda butuhkan di Program. Semua pekerjaan lainnya akan dilakukan di bagian-bagian.

Atribut "Imports" dan "ImportMany"

Agar SimpleCalculator dapat diperluas, 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 atribut ImportManyAttribute.

Tambahkan properti operasi berikut ke MySimpleCalculator kelas :

<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, mewakili operasi aktual, dan IOperationData objek, mewakili metadatanya.

Tambahkan antarmuka sederhana berikut ke modul atau SimpleCalculator namespace.

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:

<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 Add kelas mengimplementasikan IOperation, kelas yang mengimplementasikan IOperationData tidak ditentukan secara eksplisit. Sebaliknya, kelas dibuat secara implisit oleh MEF dengan properti berdasarkan nama metadata yang disediakan. (Ini adalah salah satu dari beberapa cara untuk mengakses metadata di MEF.)

Komposisi dalam MEF 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, hal itu juga perlu diisi, dan sebagainya. Impor apa pun 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, semua yang tersisa adalah 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 memisahkan string input menjadi operand kiri, operand 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 metode pembantu berikut ke MySimpleCalculator kelas :

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. Di Visual Basic, pastikan Anda menambahkan kata kunci ke PublicModule1. Di jendela konsol, ketik operasi penambahan, seperti "5+3", dan kalkulator mengembalikan hasilnya. Operator lainnya akan menghasilkan pesan "Operasi Tidak Ditemukan!".

Memperluas SimpleCalculator menggunakan kelas baru

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

<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 di luar sumber aplikasi sendiri untuk beberapa bagian. 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 di tingkat solusi. Kemudian tambahkan proyek Pustaka Kelas baru ke solusi, bernama ExtendedOperations. Proyek baru akan dikompilasi menjadi rakitan terpisah.

Buka Perancang Properti Proyek 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. ExtendedOperations Dalam file kelas, tambahkan Imports atau arahan using untuk System.ComponentModel.Composition. Di Visual Basic, tambahkan juga pernyataan untuk ImportsSimpleCalculator. Kemudian tambahkan kelas berikut ke ExtendedOperations file kelas:

<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 wadah komposisi

Bagian dan kontainer komposisi adalah blok penyusun dasar aplikasi MEF. Bagian adalah objek apa pun yang mengimpor atau mengekspor nilai, termasuk dirinya sendiri. Katalog menyediakan kumpulan bagian dari sumber tertentu. Kontainer komposisi menggunakan bagian-bagian yang disediakan oleh katalog untuk melakukan proses komposisi, yaitu mengaitkan impor dengan 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 selanjutnya