Megosztás a következőn keresztül:

Felügyelt bővíthetőségi keretrendszer (MEF)

Ez a cikk áttekintést nyújt a .NET-keretrendszer 4-ben bevezetett felügyelt bővíthetőségi keretrendszerről.

Mi az a MEF?

A Felügyelt bővíthetőségi keretrendszer (MEF) egy egyszerű és bővíthető alkalmazások létrehozására szolgáló kódtár. Lehetővé teszi az alkalmazásfejlesztők számára, hogy konfiguráció nélkül fedezzék fel és használják a bővítményeket. Emellett lehetővé teszi a bővítményfejlesztők számára a kód beágyazását és a törékeny, kemény függőségek elkerülését. A MEF nem csak az alkalmazásokon belül, hanem az alkalmazásokban is lehetővé teszi a bővítmények újrafelhasználását.

A bővíthetőség problémája

Tegyük fel, hogy Ön egy olyan nagy alkalmazás tervezője, amely támogatnia kell a bővíthetőséget. Az alkalmazásnak valószínűleg nagy számú kisebb összetevőt kell tartalmaznia, és ezek létrehozásáért és futtatásáért felelős.

A probléma legegyszerűbb megközelítése az, ha az összetevőket forráskódként tartalmazza az alkalmazásban, és közvetlenül a kódból hívja meg őket. Ennek számos nyilvánvaló hátránya van. A legfontosabb, hogy nem adhat hozzá új összetevőket a forráskód módosítása nélkül, ami egy olyan korlátozás, amely elfogadható lehet például egy webalkalmazásban, de egy ügyfélalkalmazásban nem használható. Ugyanilyen problémás lehet, hogy nem fér hozzá az összetevők forráskódjához, mert előfordulhat, hogy harmadik felek fejlesztik őket, és ugyanezen okból nem engedélyezheti számukra az Ön hozzáférését.

Egy kissé kifinomultabb megközelítés egy bővítőpont vagy interfész biztosítása, amely lehetővé teszi az alkalmazás és összetevői közötti szétválasztást. Ebben a modellben megadhat egy felületet, amelyet egy összetevő implementálhat, és egy API-t, amely lehetővé teszi az alkalmazással való interakciót. Ez megoldja a forráskód-hozzáférés megkövetelésének problémáját, de továbbra is saját nehézségei vannak.

Mivel az alkalmazás nem képes önállóan felderíteni az összetevőket, még mindig explicit módon kell megadni, hogy mely összetevők érhetők el, és mely összetevőket kell betölteni. Ez általában úgy érhető el, hogy explicit módon regisztrálja az elérhető összetevőket egy konfigurációs fájlban. Ez azt jelenti, hogy annak biztosítása, hogy az összetevők helyesek legyenek, karbantartási problémává válik, különösen akkor, ha a végfelhasználó, és nem a fejlesztő végzi el a frissítést.

Ezenkívül az összetevők nem képesek kommunikálni egymással, kivéve magát az alkalmazás mereven meghatározott csatornáit. Ha az alkalmazástervező nem számított arra, hogy szükség van egy adott kommunikációra, általában lehetetlen.

Végül az összetevő fejlesztőinek kemény függőséget kell elfogadniuk az általuk implementálandó felületet tartalmazó szerelvényen. Ez megnehezíti egy összetevő több alkalmazásban való használatát, és problémákat is okozhat az összetevők tesztelési keretrendszerének létrehozásakor.

A MEF által biztosított lehetőségek

Az elérhető összetevők ezen explicit regisztrációja helyett a MEF lehetővé teszi, hogy implicit módon, összetételen keresztül felderítse őket. A MEF-összetevő, az úgynevezett rész deklaratív módon határozza meg a függőségeit (más néven importálásokat) és az általa elérhető képességeket (más néven exportokat). Egy alkatrész létrehozásakor a MEF kompozíciós motor a más alkatrészekből elérhető elemekkel teljesíti az importokat.

Ez a megközelítés az előző szakaszban tárgyalt problémákat oldja meg. Mivel a MEF-alkatrészek deklaratív módon határozzák meg a képességeiket, futtatáskor felderíthetők, ami azt jelenti, hogy az alkalmazások nem használhatnak olyan alkatrészeket, amelyek nem tartalmaznak szigorúan kódolt hivatkozásokat vagy törékeny konfigurációs fájlokat. A MEF lehetővé teszi az alkalmazások számára, hogy metaadataik alapján derítsék fel és vizsgálják meg az alkatrészeket anélkül, hogy példányosítanák őket, vagy akár betöltenék a szerelvényeket. Ennek eredményeképpen nem kell gondosan meghatározni, hogy mikor és hogyan kell betölteni a bővítményeket.

A megadott exporton kívül egy rész megadhatja az importját, amelyet más részek is kitöltenek. Így a részek közötti kommunikáció nem csak lehetséges, hanem egyszerű is, és lehetővé teszi a kód jó faktorálását. A számos összetevőhöz gyakran használt szolgáltatások például külön részre bonthatók, és könnyen módosíthatók vagy lecserélhetők.

Mivel a MEF-modell nem igényel szigorú függőséget egy adott alkalmazásszerelvénytől, lehetővé teszi a bővítmények alkalmazásról alkalmazásra való újrafelhasználását. Így az alkalmazástól függetlenül könnyen fejleszthet egy teszthámot a bővítmény összetevőinek teszteléséhez.

A MEF használatával írt bővíthető alkalmazások olyan importálást deklarálnak, amely bővítményösszetevők által kitölthető, és exportot is deklarálhat annak érdekében, hogy az alkalmazásszolgáltatásokat bővítményeknek tegye elérhetővé. Minden bővítményösszetevő exportot deklarál, és importot is deklarálhat. Ily módon maguk a bővítményösszetevők automatikusan bővíthetők.

Ahol a MEF elérhető

A MEF a .NET-keretrendszer 4 szerves része, és mindenhol elérhető, ahol a .NET-keretrendszert használják. A MEF-et használhatja az ügyfélalkalmazásokban, függetlenül attól, hogy Windows Formst, WPF-t vagy bármilyen más technológiát használnak, vagy ASP.NET használó kiszolgálóalkalmazásokban.

MEF és MAF

A .NET-keretrendszer korábbi verziói bevezették a felügyelt bővítmény-keretrendszert (MAF), amely lehetővé teszi az alkalmazások számára a bővítmények elkülönítését és kezelését. A MAF fókusza valamivel magasabb, mint a MEF, a bővítmények elkülönítésére, a szerelvények be- és kirakodására koncentrál, míg a MEF a felderíthetőségre, a bővíthetőségre és a hordozhatóságra összpontosít. A két keretrendszer zökkenőmentesen működik együtt, és egyetlen alkalmazás mindkét lehetőséget kihasználhatja.

SimpleCalculator: Példaalkalmazás

A legegyszerűbb módja annak, hogy lássa, mire képes a MEF egy egyszerű MEF-alkalmazás létrehozása. Ebben a példában egy SimpleCalculator nevű, nagyon egyszerű számológépet hoz létre. A SimpleCalculator célja egy olyan konzolalkalmazás létrehozása, amely elfogadja az alapszintű számtani parancsokat "5+3" vagy "6-2" formában, és a helyes válaszokat adja vissza. A MEF használatával új operátorokat adhat hozzá az alkalmazáskód módosítása nélkül.

A példához tartozó teljes kód letöltéséhez tekintse meg a SimpleCalculator-mintát (Visual Basic).

Megjegyzés:

A SimpleCalculator célja a MEF fogalmainak és szintaxisának bemutatása ahelyett, hogy szükségképpen reális forgatókönyvet biztosítanának annak használatára. A MEF előnyeiből leginkább hasznos alkalmazások közül sok összetettebb, mint a SimpleCalculator. Részletesebb példákért tekintse meg a GitHub felügyelt bővíthetőségi keretrendszerét .

  • Első lépésként hozzon létre egy új konzolalkalmazás-projektet a Visual Studióban, és nevezze el.SimpleCalculator

  • Adjon hozzá egy hivatkozást a System.ComponentModel.Composition szerelvényhez, ahol a MEF található.

  • Nyissa meg a Module1.vb vagy a Program.cs fájlt, és adjon hozzá Imports vagy using irányelveket a System.ComponentModel.Composition és System.ComponentModel.Composition.Hosting részére. Ez a két névtér olyan MEF-típusokat tartalmaz, amelyekhez bővíthető alkalmazást kell fejlesztenie.

  • Ha Visual Basicet használ, adja hozzá a Public kulcsszót a modult deklaráló Module1 sorhoz.

Kompozíciós tároló és katalógusok

A MEF-összeállítási modell magja a kompozíciós tároló, amely tartalmazza az összes rendelkezésre álló alkatrészt, és elvégzi a kompozíciót. Az összetétel a behozatal exporthoz való egyeztetése. Az összeállítási tároló leggyakoribb típusa a CompositionContainer, és ezt fogja használni a SimpleCalculator esetében.

Ha Visual Basicet használ, adjon hozzá egy nyilvános osztályt ProgramModule1.vb.

Adja hozzá a következő sort az osztályhoz Module1.vb ProgramvagyProgram.cs:

Dim _container As CompositionContainer

private CompositionContainer _container;

A rendelkezésre álló alkatrészek felderítése érdekében a kompozíciós tárolók katalógust használnak. A katalógus olyan objektum, amely bizonyos forrásból felderített alkatrészeket tesz elérhetővé. A MEF katalógusokat biztosít a megadott típusból, szerelvényből vagy könyvtárból származó alkatrészek felderítéséhez. Az alkalmazásfejlesztők egyszerűen létrehozhatnak új katalógusokat, hogy más forrásokból, például egy webszolgáltatásból származó alkatrészeket fedezhessenek fel.

Adja hozzá a következő konstruktort az Program osztályhoz:

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 ComposeParts hívás arra utasítja a kompozíciós tárolót, hogy komponáljon egy adott részhalmazt, amely ebben az esetben az aktuális Program példány. Ezen a ponton azonban semmi sem fog történni, mivel Program nincs betöltendő import.

Importálás és exportálás attribútumokkal

Először is importálni kell Program egy számológépet. Ez lehetővé teszi a felhasználói felülettel kapcsolatos problémák, például a konzol bemenetének és kimenetének Programelkülönítését a számológép logikájától.

Adja hozzá a következő kódot az Program osztályhoz:

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

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

Figyelje meg, hogy az calculator objektum deklarációja nem szokatlan, de az ImportAttribute attribútummal van ellátva. Ez az attribútum deklarál valamit importálásnak; vagyis az objektum összeállításakor a kompozíciós motor tölti ki.

Minden import rendelkezik egy szerződéssel, amely meghatározza, hogy milyen exportálással lesz megfeleltetve. A szerződés lehet egy explicit módon megadott sztring, vagy a MEF automatikusan létrehozhatja azt egy adott típusból, ebben az esetben az interfész ICalculator. Az egyező szerződéssel deklarált exportok teljesítik ezt az importot. Vegye figyelembe, hogy bár az calculator objektum típusa valójában ICalculator, ez nem kötelező. A szerződés független az importáló objektum típusától. (Ebben az esetben kihagyhatja a typeof(ICalculator). A MEF automatikusan feltételezi, hogy a szerződés az importálás típusán alapul, hacsak ön nem adja meg kifejezetten.)

Adja hozzá ezt a nagyon egyszerű felületet a modulhoz vagy SimpleCalculator a névtérhez:

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

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

Most, hogy definiálta ICalculator, szüksége lesz egy olyan osztályra, amely megvalósítja azt. Adja hozzá a következő osztályt a modulhoz vagy SimpleCalculator névtérhez:

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

End Class

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

}

Itt található az exportálás, amely megfelel az importálásnak a következőben Program: . Ahhoz, hogy az export megfeleljen az importnak, az exportnak azonos szerződéssel kell rendelkeznie. Az typeof(MySimpleCalculator) alapú szerződés szerinti exportálás nem megfelelő eredményhez vezetne, és nem került sor az importálásra; pontos egyezés szükséges a szerződésben.

Mivel az összeállítási tároló az ebben a szerelvényben elérhető összes alkatrészrel fel lesz töltve, a MySimpleCalculator rész elérhető lesz. Amikor a Program konstruktor kompozíciót végez az Program objektumon, az import egy MySimpleCalculator objektummal lesz feltöltve, amelyet erre a célra hoznak létre.

A felhasználói felület rétegének (Program) nem kell mást tudnia. Ezért kitöltheti a felhasználói felület többi logikáját a Main metódusban.

Adja hozzá a következő kódot a Main metódushoz:

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

Ez a kód egyszerűen beolvassa a bemeneti sort, és meghívja az CalculateICalculator függvényét a kapott eredményen, az eredményt pedig visszaírja a konzolra. Ez az összes szükséges Programkód. A többi munka a részekben fog zajlani.

Importok és ImportMany attribútumok

Ahhoz, hogy a SimpleCalculator bővíthető legyen, importálnia kell a műveletek listáját. A szokásos ImportAttribute attribútumokat egy és csak egy ExportAttributetölti ki. Ha több is elérhető, a kompozíciós motor hibát okoz. Tetszőleges számú exportálással kitölthető importálás létrehozásához használhatja az ImportManyAttribute attribútumot.

Adja hozzá a következő műveleti tulajdonságot az MySimpleCalculator osztályhoz:

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

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

Lazy<T,TMetadata> a MEF által az exportra mutató közvetett hivatkozások tárolására szolgáló típus. Itt az exportált objektum mellett az exportált objektumot leíró metaadatokat vagy információkat is megkapja. Mindegyik Lazy<T,TMetadata> tartalmaz egy IOperation objektumot, amely egy tényleges műveletet jelöl, és egy IOperationData objektumot, amely a metaadatait jelöli.

Adja hozzá a következő egyszerű interfészeket a modulhoz vagy SimpleCalculator a névtérhez:

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

Ebben az esetben az egyes műveletek metaadatai az adott műveletet jelképező szimbólumok, például +, -, *stb. A hozzáadási művelet elérhetővé tétele érdekében adja hozzá a következő osztályt a modulhoz vagy SimpleCalculator a névtérhez:

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

Az ExportAttribute attribútum ugyanúgy működik, mint korábban. Az ExportMetadataAttribute attribútum a metaadatokat név-érték pár formájában csatolja az exportáláshoz. Míg az Add osztály implementál IOperation, a megvalósító IOperationData osztály nincs explicit módon definiálva. Ehelyett a MEF implicit módon hoz létre egy osztályt, amely a megadott metaadatok neve alapján rendelkezik tulajdonságokkal. (Ez az egyik módszer a metaadatok MEF-ben való elérésére.)

A MEF összetétele rekurzív. Kifejezetten Ön állította össze az Program objektumot, amely egy ICalculator importált, és amelyről kiderült, hogy MySimpleCalculator típusú. MySimpleCalculator viszont egy IOperation objektumgyűjteményt importál, és az importálás akkor lesz kitöltve, amikor MySimpleCalculator létrejön, azzal egy időben, mint a Program importálása. Ha az Add osztály további importálást deklarált, azt is ki kell tölteni, és így tovább. A be nem töltött importálások összeállítási hibát eredményeznek. (Deklarálható azonban, hogy az importálás nem kötelező, vagy az alapértelmezett értékeket rendelheti hozzájuk.)

Számológép logikája

Ezek a részek a helyén maradnak, csak maga a számológép logikája marad. Adja hozzá a következő kódot az MySimpleCalculator osztályhoz a Calculate metódus implementálásához:

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

Az első lépések során a bemeneti sztringet bal és jobb operandusokra és egy operátor karakterre elemzik. A foreach ciklusban a operations gyűjtemény minden tagját megvizsgáljuk. Ezek az objektumok Lazy<T,TMetadata> típusúak, és metaadat-értékeik, valamint exportált objektumaik elérhetők a Metadata tulajdonsággal és a Value tulajdonsággal. Ebben az esetben, ha az SymbolIOperationData objektum tulajdonsága egyezésnek minősül, a számológép meghívja az OperateIOperation objektum metódusát, és visszaadja az eredményt.

A számológép elvégzéséhez egy segédmetódusra is szükség van, amely visszaadja a sztring első nem számjegyű karakterének pozícióját. Adja hozzá a következő segédmetódust az MySimpleCalculator osztályhoz:

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

Most már képesnek kell lennie a projekt fordítására és futtatására. A Visual Basicben győződjön meg arról, hogy hozzáadta a Public kulcsszót a Module1-hez. A konzolablakban írjon be egy összeadási műveletet( például "5+3"), és a számológép visszaadja az eredményeket. Bármely más operátor a "Művelet nem található!" üzenetet eredményezi.

A SimpleCalculator kiterjesztése új osztály használatával

Most, hogy a számológép működik, egyszerűen hozzáadhat egy új műveletet. Adja hozzá a következő osztályt a modulhoz vagy SimpleCalculator névtérhez:

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

Állítsa össze és futtassa a projektet. Írjon be egy kivonási műveletet, például "5-3". A számológép mostantól támogatja a kivonást és az összeadást is.

A SimpleCalculator kiterjesztése új szerelvény használatával

Az osztályok hozzáadása a forráskódhoz viszonylag egyszerű, de a MEF lehetővé teszi, hogy az alkalmazás saját forrásán kívül keressen alkatrészeket. Ennek szemléltetéséhez módosítania kell a SimpleCalculatort, hogy egy könyvtárban, valamint a saját összeállításában keressen alkatrészeket a DirectoryCatalog hozzáadásával.

Adjon hozzá egy új könyvtárat Extensions a SimpleCalculator projekthez. Ne a megoldás szintjén adja hozzá, hanem a projekt szintjén. Ezután adjon hozzá egy új Osztálytár-projektet a megoldáshoz.ExtendedOperations Az új projekt egy külön összeállításba fog fordulni.

Nyissa meg az ExtendedOperations projekthez tartozó Project Properties Designer eszközt, és kattintson a Fordítás vagy Build fülre. Módosítsa a Build kimeneti elérési útvonalát vagy a Kimeneti elérési útvonalat, hogy a SimpleCalculator projektkönyvtárban lévő Extensions könyvtárra mutasson (..\SimpleCalculator\Extensions\).

Module1.vb vagyProgram.cs adja hozzá a következő sort a Program konstruktorhoz:

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

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

Cserélje le a példa elérési útját a Bővítmények könyvtár elérési útjára. (Ez az abszolút elérési út csak hibakeresési célokra szolgál. Egy éles alkalmazásban relatív elérési utat használna.) A DirectoryCatalog rendszer mostantól hozzáadja a Bővítmények könyvtárban található szerelvényekben található alkatrészeket a kompozíciós tárolóhoz.

A ExtendedOperations projektben adjon hozzá hivatkozásokat SimpleCalculator és System.ComponentModel.Composition. Az ExtendedOperations osztályfájlban adjon hozzá egy Imports vagy egy using direktívát a System.ComponentModel.Composition számára. A Visual Basicben adjon hozzá egy Imports utasítást a SimpleCalculator-hez is. Ezután adja hozzá a következő osztályt az ExtendedOperations osztályfájlhoz:

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

Vegye figyelembe, hogy ahhoz, hogy a szerződés egyezni tudjon, az ExportAttribute attribútumnak ugyanazzal a típussal kell rendelkeznie, mint a ImportAttribute.

Állítsa össze és futtassa a projektet. Tesztelje az új Mod (%) operátort.

Következtetés

Ez a témakör a MEF alapfogalmait ismerteti.

  • Alkatrészek, katalógusok és a kompozíciós tároló

    Az alkatrészek és a kompozíciós tároló a MEF-alkalmazások alapvető építőelemei. A rész bármely olyan objektum, amely egy értéket importál vagy exportál, akár önmagában. A katalógus egy adott forrásból származó alkatrészek gyűjteményét biztosítja. A kompozíciós tároló a katalógus által biztosított alkatrészeket használja az összeállítás elvégzéséhez, az import exporthoz kötését.

  • Import és export

    Az import és az export az összetevők kommunikációjának módja. Importálás esetén az összetevő egy adott érték vagy objektum szükségességét határozza meg, az exportálással pedig egy érték rendelkezésre állását határozza meg. Az egyes importálásokat a szerződésük alapján egy exportálási listával párosítják.

Következő lépések

A példához tartozó teljes kód letöltéséhez tekintse meg a SimpleCalculator-mintát (Visual Basic).

További információ és példakód: Felügyelt bővíthetőségi keretrendszer. A MEF-típusok listáját a System.ComponentModel.Composition névtérben találja.