Managed Extensibility Framework (MEF) - Beheerde uitbreidbaarheidsstructuur (MEF)

Dit artikel bevat een overzicht van het Managed Extensibility Framework dat is geïntroduceerd in .NET Framework 4.

Wat is MEF?

Het Managed Extensibility Framework (MEF) is een bibliotheek voor het maken van lichtgewicht en uitbreidbare toepassingen. Hiermee kunnen ontwikkelaars van toepassingen extensies detecteren en gebruiken zonder configuratie vereist. Ook kunnen extensieontwikkelaars eenvoudig code inkapselen en kwetsbare harde afhankelijkheden voorkomen. MET MEF kunnen extensies niet alleen opnieuw worden gebruikt binnen toepassingen, maar ook in toepassingen.

Het probleem van uitbreidbaarheid

Stel dat u de architect bent van een grote toepassing die ondersteuning moet bieden voor uitbreidbaarheid. Uw toepassing moet een potentieel groot aantal kleinere onderdelen bevatten en is verantwoordelijk voor het maken en uitvoeren ervan.

De eenvoudigste benadering van het probleem is het opnemen van de onderdelen als broncode in uw toepassing en deze rechtstreeks vanuit uw code aanroepen. Dit heeft een aantal voor de hand liggende nadelen. Het belangrijkste is dat u geen nieuwe onderdelen kunt toevoegen zonder de broncode te wijzigen, een beperking die mogelijk acceptabel is in bijvoorbeeld een webtoepassing, maar niet kan worden bewerkt in een clienttoepassing. Net zo problematisch, hebt u mogelijk geen toegang tot de broncode voor de onderdelen, omdat ze mogelijk door derden worden ontwikkeld en om dezelfde reden kunt u hen geen toegang geven tot die van u.

Een iets geavanceerdere benadering is om een uitbreidingspunt of interface te bieden, om ontkoppeling tussen de toepassing en de bijbehorende onderdelen mogelijk te maken. Onder dit model kunt u een interface bieden die een onderdeel kan implementeren en een API waarmee het kan communiceren met uw toepassing. Dit lost het probleem op van het vereisen van broncodetoegang, maar heeft nog steeds zijn eigen problemen.

Omdat de toepassing zelf geen capaciteit voor het detecteren van onderdelen heeft, moet de toepassing nog steeds expliciet worden verteld welke onderdelen beschikbaar zijn en moeten worden geladen. Dit wordt meestal bereikt door de beschikbare onderdelen in een configuratiebestand expliciet te registreren. Dit betekent dat het garanderen dat de onderdelen correct zijn een onderhoudsprobleem wordt, met name als het de eindgebruiker is en niet de ontwikkelaar die verwacht de update uit te voeren.

Bovendien kunnen onderdelen niet met elkaar communiceren, behalve via de strikt gedefinieerde kanalen van de toepassing zelf. Als de toepassingsarchitect niet heeft verwacht dat een bepaalde communicatie nodig is, is het meestal onmogelijk.

Ten slotte moeten de onderdeelontwikkelaars een harde afhankelijkheid accepteren van welke assembly de interface bevat die ze implementeren. Dit maakt het lastig om een onderdeel in meer dan één toepassing te gebruiken en kan ook problemen veroorzaken wanneer u een testframework voor onderdelen maakt.

Wat MEF biedt

In plaats van deze expliciete registratie van beschikbare onderdelen biedt MEF een manier om ze impliciet te ontdekken, via samenstelling. Een MEF-onderdeel, een onderdeel genoemd, geeft declaratief de afhankelijkheden (ook wel import genoemd) aan en welke mogelijkheden (ook wel exports genoemd) beschikbaar worden gesteld. Wanneer een onderdeel wordt gemaakt, voldoet de samenstellingsmotor van de MEF aan zijn invoer met wat beschikbaar is uit andere onderdelen.

Deze aanpak lost de problemen op die in de vorige sectie zijn besproken. Omdat MEF-onderdelen declaratief hun mogelijkheden opgeven, kunnen ze tijdens runtime worden gedetecteerd. Dit betekent dat een toepassing onderdelen kan gebruiken zonder in code vastgelegde verwijzingen of kwetsbare configuratiebestanden. MET MEF kunnen toepassingen onderdelen detecteren en onderzoeken op basis van hun metagegevens, zonder ze te instantiëren of zelfs hun assembly's te laden. Als gevolg hiervan hoeft u niet zorgvuldig op te geven wanneer en hoe extensies moeten worden geladen.

Naast de geleverde uitvoer kan een deel de invoer opgeven, die door andere delen zal worden gevuld. Dit maakt communicatie tussen onderdelen niet alleen mogelijk, maar eenvoudig, en maakt het mogelijk om code goed te factoreren. Services die voor veel onderdelen worden gebruikt, kunnen bijvoorbeeld worden meegenomen in een afzonderlijk onderdeel en eenvoudig kunnen worden gewijzigd of vervangen.

Omdat het MEF-model geen harde afhankelijkheid van een bepaalde toepassingsassembly vereist, kunnen extensies van toepassing naar toepassing opnieuw worden gebruikt. Dit maakt het ook eenvoudig om een testharnas te ontwikkelen, onafhankelijk van de toepassing, om extensieonderdelen te testen.

Een uitbreidbare toepassing die is geschreven met behulp van MEF declareert een import die kan worden gevuld door extensieonderdelen en kan ook export declareren om toepassingsservices beschikbaar te maken voor extensies. Elk uitbreidingsonderdeel declareert een export en kan ook import declareren. Op deze manier worden extensieonderdelen zelf automatisch uitbreidbaar.

Waar MEF beschikbaar is

MEF is een integraal onderdeel van .NET Framework 4 en is beschikbaar waar .NET Framework ook wordt gebruikt. U kunt MEF gebruiken in uw clienttoepassingen, ongeacht of ze Windows Forms, WPF of andere technologie gebruiken, of in servertoepassingen die gebruikmaken van ASP.NET.

MEF en MAF

In eerdere versies van .NET Framework is het Beheerde invoegtoepassingsframework (MAF) geïntroduceerd, ontworpen om toepassingen toe te staan extensies te isoleren en te beheren. De focus van MAF is iets hoger dan MEF, waarbij de nadruk ligt op uitbreidingsisolatie en het laden en lossen van assembly's, terwijl MEF zich richt op vindbaarheid, uitbreidbaarheid en draagbaarheid. De twee frameworks werken soepel en één toepassing kan profiteren van beide.

SimpleCalculator: een voorbeeldtoepassing

De eenvoudigste manier om te zien wat MEF kan doen, is door een eenvoudige MEF-toepassing te bouwen. In dit voorbeeld bouwt u een zeer eenvoudige rekenmachine met de naam SimpleCalculator. Het doel van SimpleCalculator is het maken van een consoletoepassing die eenvoudige rekenkundige opdrachten accepteert, in de vorm '5+3' of '6-2', en de juiste antwoorden retourneert. Met MEF kunt u nieuwe operators toevoegen zonder de toepassingscode te wijzigen.

Zie het SimpleCalculator-voorbeeld (Visual Basic) om de volledige code voor dit voorbeeld te downloaden.

Opmerking

Het doel van SimpleCalculator is om de concepten en syntaxis van MEF te demonstreren, in plaats van noodzakelijkerwijs een realistisch scenario te bieden voor het gebruik ervan. Veel van de toepassingen die het meeste voordeel zouden hebben van de kracht van MEF zijn complexer dan SimpleCalculator. Zie het Managed Extensibility Framework op GitHub voor uitgebreidere voorbeelden.

Als u wilt beginnen, maakt u in Visual Studio een nieuw consoletoepassingsproject en noemt u het SimpleCalculator.
Voeg een verwijzing toe naar de System.ComponentModel.Composition assembly, waar MEF zich bevindt.
Open Module1.vb of Program.cs en voeg richtlijnen Imports of using toe voor System.ComponentModel.Composition en System.ComponentModel.Composition.Hosting. Deze twee naamruimten bevatten MEF-typen die u nodig hebt om een uitbreidbare toepassing te ontwikkelen.
Als u Visual Basic gebruikt, voegt u het Public trefwoord toe aan de regel die de Module1 module declareert.

Compositiecontainer en catalogus

De kern van het MEF-samenstellingsmodel is de samenstellingscontainer, die alle beschikbare onderdelen bevat en composities uitvoert. Samenstelling is de afstemming van de invoer op de uitvoer. Het meest voorkomende type samenstellingscontainer is CompositionContainer, en u gebruikt dit voor SimpleCalculator.

Als u Visual Basic gebruikt, voegt u een openbare klasse toe met de naam ProgramModule1.vb.

Voeg de volgende regel toe aan de Program klasse in Module1.vb of Program.cs:

Dim _container As CompositionContainer

private CompositionContainer _container;

Om de beschikbare onderdelen te ontdekken, maken de samenstellingscontainers gebruik van een catalogus. Een catalogus is een object waarmee beschikbare onderdelen uit een bepaalde bron worden gedetecteerd. MEF biedt catalogi voor het detecteren van onderdelen van een opgegeven type, een assembly of een map. Ontwikkelaars van toepassingen kunnen eenvoudig nieuwe catalogi maken om onderdelen uit andere bronnen te detecteren, zoals een webservice.

Voeg de volgende constructor toe aan de Program klasse:

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

De oproep naar de compositiecontainer via ComposeParts om een specifieke set onderdelen samen te stellen, in dit geval de huidige instantie van Program. Op dit punt zal er echter niets gebeuren, omdat Program geen invoer heeft om te vullen.

Importeren en exporteren met kenmerken

U heeft eerst Program een rekenmachine geïmporteerd. Hierdoor kan er een scheiding worden gemaakt tussen aspecten van de gebruikersinterface, zoals de invoer en uitvoer van de console, en de logica van de calculator.

Voeg de volgende code toe aan de klasse Program:

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

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

U ziet dat de declaratie van het calculator object niet ongebruikelijk is, maar dat het is versierd met het ImportAttribute kenmerk. Dit kenmerk declareert iets als een import; Dat wil gezegd, het wordt gevuld door de samenstellingsengine wanneer het object is samengesteld.

Elke import heeft een contract, waarmee wordt bepaald met welke exports het overeenkomt. Het contract kan een expliciet opgegeven tekenreeks zijn of kan automatisch worden gegenereerd door MEF van een bepaald type, in dit geval de interface ICalculator. Elke export die is gedeclareerd met een overeenkomend contract, voldoet aan deze import. Houd er rekening mee dat hoewel het type van het calculator object in feite ICalculatoris, dit niet vereist is. Het contract is onafhankelijk van het type importobject. (In dit geval kunt u de typeof(ICalculator) weglaten. MEF veronderstelt automatisch dat het contract is gebaseerd op het type import, tenzij u het expliciet opgeeft.)

Voeg deze zeer eenvoudige interface toe aan de module of SimpleCalculator naamruimte:

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

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

Nu u hebt gedefinieerd ICalculator, hebt u een klasse nodig waarmee deze wordt geïmplementeerd. Voeg de volgende klasse toe aan de module of SimpleCalculator naamruimte:

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

End Class

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

}

Hier volgt de export die overeenkomt met de import in Program. Als u wilt dat de export overeenkomt met de import, moet de export hetzelfde contract hebben. Exporteren onder een contract op basis van typeof(MySimpleCalculator) zou tot een mismatch leiden, en de import zou niet plaatsvinden; het contract moet exact overeenkomen.

Omdat de samenstellingscontainer wordt gevuld met alle onderdelen die beschikbaar zijn in deze assembly, is het MySimpleCalculator onderdeel beschikbaar. Wanneer de constructor voor Program samenstelling op het Program object uitvoert, wordt de import hiervan gevuld met een MySimpleCalculator object dat voor dit doel wordt gemaakt.

De gebruikersinterfacelaag (Program) hoeft niets anders te weten. U kunt daarom de rest van de logica van de gebruikersinterface invullen in de Main methode.

Voeg de volgende code toe aan de methode 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));
    }
}

Met deze code wordt een regel invoer gelezen en wordt de Calculate functie van ICalculator op het resultaat aangeroepen, wat terug wordt geschreven naar de console. Dat is alle code die u nodig hebt in Program. De rest van het werk vindt plaats in de onderdelen.

Import- en ImportMany-kenmerken

Om SimpleCalculator uit te kunnen breidbaar te maken, moet er een lijst met bewerkingen worden geïmporteerd. Een gewoon ImportAttribute kenmerk wordt gevuld met één en slechts één ExportAttribute. Als er meer dan één beschikbaar is, produceert de samenstellingsengine een fout. Als u een import wilt maken die kan worden ingevuld door een willekeurig aantal exports, kunt u het ImportManyAttribute kenmerk gebruiken.

Voeg de volgende bewerkingseigenschap toe aan de MySimpleCalculator klasse:

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

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

Lazy<T,TMetadata> is een type dat door MEF wordt verstrekt om indirecte verwijzingen naar export te bewaren. Naast het geëxporteerde object zelf krijgt u ook exportmetagegevens of informatie over het geëxporteerde object. Elk Lazy<T,TMetadata> object bevat een IOperation object, dat een werkelijke bewerking en een IOperationData object vertegenwoordigt, dat de metagegevens vertegenwoordigt.

Voeg de volgende eenvoudige interfaces toe aan de module of SimpleCalculator naamruimte:

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

In dit geval zijn de metagegevens voor elke bewerking het symbool dat deze bewerking vertegenwoordigt, zoals +, -, *, enzovoort. Om de optelbewerking mogelijk te maken, voegt u de volgende klasse toe aan de module of SimpleCalculator naamruimte:

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

Het ExportAttribute kenmerk werkt zoals voorheen. Het ExportMetadataAttribute kenmerk koppelt metagegevens, in de vorm van een naam-waardepaar, aan die export. Hoewel de klasse AddIOperation implementeert, wordt een klasse die IOperationData implementeert niet expliciet gedefinieerd. In plaats daarvan wordt een klasse impliciet gemaakt door MEF met eigenschappen op basis van de namen van de opgegeven metagegevens. (Dit is een van de verschillende manieren om toegang te krijgen tot metagegevens in MEF.)

Samenstelling in MEF is recursief. U hebt het Program object expliciet samengesteld, dat een ICalculator object heeft geïmporteerd dat van het type MySimpleCalculatorbleek te zijn. MySimpleCalculator importeert op zijn beurt een verzameling IOperation-objecten, en die invoer wordt gevuld wanneer MySimpleCalculator wordt gemaakt, tezelfdertijd als de invoer van Program. Als de Add klasse een verdere import heeft gedeclareerd, moet dat ook worden ingevuld, enzovoort. Elke import die niet is ingevuld, resulteert in een samenstellingsfout. (Het is echter mogelijk om invoer optioneel te declareren of om ze standaardwaarden toe te wijzen.)

Rekenmachinelogica

Nu deze onderdelen aanwezig zijn, is alles wat overblijft de rekenmachinelogica zelf. Voeg de volgende code toe in de MySimpleCalculator klasse om de Calculate methode te implementeren:

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

De eerste stappen parseren de invoertekenreeks in linker- en rechteroperanden en een operatorteken. In de foreach lus wordt elk lid van de operations verzameling onderzocht. Deze objecten zijn van het type Lazy<T,TMetadata>en de bijbehorende metagegevenswaarden en geëxporteerd object kunnen worden geopend met respectievelijk de Metadata eigenschap en de Value eigenschap. Als de Symbol eigenschap van het IOperationData object in dit geval een overeenkomst is, roept de calculator de Operate methode van het IOperation object aan en retourneert het resultaat.

Als u de calculator wilt voltooien, hebt u ook een helpermethode nodig waarmee de positie van het eerste niet-cijferige teken in een tekenreeks wordt geretourneerd. Voeg de volgende helpermethode toe aan de MySimpleCalculator klasse:

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

U moet nu het project kunnen compileren en uitvoeren. Zorg ervoor dat u in Visual Basic het Public trefwoord hebt toegevoegd aan Module1. Typ in het consolevenster een optellingsbewerking, zoals '5+3', en de calculator retourneert de resultaten. Elke andere operator resulteert in het bericht "Bewerking niet gevonden".

SimpleCalculator uitbreiden met een nieuwe klasse

Nu de rekenmachine werkt, is het toevoegen van een nieuwe bewerking eenvoudig. Voeg de volgende klasse toe aan de module of SimpleCalculator naamruimte:

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

Compileer het project en voer het uit. Typ een aftrekkingsbewerking, zoals '5-3'. De calculator ondersteunt nu aftrekken en optellen.

SimpleCalculator uitbreiden met behulp van een nieuwe assembly

Het toevoegen van klassen aan de broncode is eenvoudig genoeg, maar MEF biedt de mogelijkheid om te kijken buiten de eigen bron van een toepassing voor onderdelen. Om dit te laten zien, moet u SimpleCalculator wijzigen zodat het een map en de eigen assembly doorzoekt naar onderdelen, door een DirectoryCatalog toe te voegen.

Voeg een nieuwe map toe met de naam Extensions aan het SimpleCalculator-project. Zorg ervoor dat u deze toevoegt op projectniveau en niet op oplossingsniveau. Voeg vervolgens een nieuw class library-project toe aan de oplossing met de naam ExtendedOperations. Het nieuwe project wordt gecompileerd in een afzonderlijke assembly.

Open projecteigenschappenontwerper voor het project ExtendedOperations en klik op het tabblad Compileren of Bouwen . Wijzig het pad voor de build-uitvoer of het uitvoerpad zodat deze verwijst naar de map Extensions in de projectmap SimpleCalculator (.. \SimpleCalculator\Extensions\).

Voeg in Module1.vb of Program.cs de volgende regel toe aan de Program constructor:

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

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

Vervang het voorbeeldpad door het pad naar de map Extensies. (Dit absolute pad is alleen bedoeld voor foutopsporing. In een productietoepassing gebruikt u een relatief pad.) Hiermee DirectoryCatalog worden alle onderdelen in alle assembly's in de map Extensions toegevoegd aan de samenstellingscontainer.

Voeg in het ExtendedOperations project verwijzingen toe aan SimpleCalculator en System.ComponentModel.Composition. In het ExtendedOperations klassebestand voegt u een Imports-instructie of een using-instructie toe voor System.ComponentModel.Composition. Voeg in Visual Basic ook een Imports instructie toe voor SimpleCalculator. Voeg vervolgens de volgende klasse toe aan het ExtendedOperations klassebestand:

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

Houd er rekening mee dat, opdat het contract overeenkomt, het ExportAttribute kenmerk hetzelfde type moet hebben als het ImportAttribute.

Compileer het project en voer het uit. Test de nieuwe mod-operator (%).

Conclusie

In dit onderwerp zijn de basisconcepten van MEF besproken.

Onderdelen, catalogi en de samenstellingscontainer

Onderdelen en de samenstellingscontainer zijn de basisbouwstenen van een MEF-toepassing. Een onderdeel is een object dat een waarde importeert of exporteert, tot en met zichzelf. Een catalogus biedt een verzameling onderdelen van een bepaalde bron. De compositiecontainer gebruikt de onderdelen die door een catalogus worden aangeboden voor compositie, het koppelen van imports aan exports.
Import en exporten

Import en export zijn de manier waarop onderdelen communiceren. Bij een import geeft het onderdeel een behoefte aan een bepaalde waarde of een bepaald object op en met een export geeft het de beschikbaarheid van een waarde op. Elke import wordt vergeleken met een lijst met exporten aan de hand van het contract.

Volgende stappen