Managed Extensibility Framework (MEF)

Artikel
02/21/2023

In dit onderwerp vindt u een overzicht van de Managed Extensibility Framework die is geïntroduceerd in de .NET Framework 4.

Wat is MEF?

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

Het probleem van uitbreidbaarheid

Imagine 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 acceptabel kan zijn in bijvoorbeeld een webtoepassing, maar niet werkt in een clienttoepassing. Net zo problematisch, hebt u mogelijk geen toegang tot de broncode voor de onderdelen, omdat deze mogelijk door derden worden ontwikkeld en om dezelfde reden kunt u hen geen toegang geven tot uw onderdelen.

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 deze 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 heeft om onderdelen te detecteren, moet deze 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 ervoor zorgen dat de onderdelen juist zijn, een onderhoudsprobleem wordt, met name als het de eindgebruiker is en niet de ontwikkelaar die naar verwachting de update moet uitvoeren.

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 te gebruiken in meer dan één toepassing 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, specificeert declaratief zowel de afhankelijkheden (ook wel import genoemd) als de mogelijkheden ( ook wel exports genoemd) die beschikbaar worden gesteld. Wanneer een onderdeel wordt gemaakt, voldoet de MEF-samenstellingsmotor aan de invoer ervan 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 wordt gevuld. Dit maakt communicatie tussen onderdelen niet alleen mogelijk, maar eenvoudig en maakt goede factoring van code mogelijk. Services die voor veel onderdelen worden gebruikt, kunnen bijvoorbeeld worden meegenomen in een afzonderlijk onderdeel en eenvoudig worden gewijzigd of vervangen.

Omdat voor het MEF-model geen harde afhankelijkheid van een bepaalde toepassingsassembly is 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 extensieonderdeel 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 de .NET Framework 4 en is beschikbaar waar de .NET Framework wordt gebruikt. U kunt MEF gebruiken in uw clienttoepassingen, ongeacht of ze gebruikmaken van Windows Forms, WPF of andere technologie, of in servertoepassingen die gebruikmaken van ASP.NET.

MEF en MAF

In eerdere versies van het .NET Framework MAF (Managed Add-in Framework) geïntroduceerd, ontworpen om toepassingen toe te staan extensies te isoleren en te beheren. De focus van MAF is iets hoger dan MEF, waarbij aandacht wordt besteed aan extensie-isolatie en montagebelasting en het lossen, terwijl MEF zich richt op detectie, 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 om een consoletoepassing te maken 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.

Notitie

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 baat zouden hebben bij de kracht van MEF zijn complexer dan SimpleCalculator. Zie de Managed Extensibility Framework op GitHub voor uitgebreidere voorbeelden.

Als u wilt beginnen, maakt u in Visual Studio een nieuw consoletoepassingsproject en noemt u hetSimpleCalculator.
Voeg een verwijzing naar de System.ComponentModel.Composition assembly toe, waar MEF zich bevindt.
Open Module1.vb of Program.cs en voeg Imports of using instructies 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.

Samenstellingscontainer en catalogi

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 CompositionContaineren 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 worden gedetecteerd uit een bepaalde bron. 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 van andere bronnen te ontdekken, 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 aanroep om ComposeParts de samenstellingscontainer te vertellen dat er een specifieke set onderdelen moet worden samengesteld, in dit geval het huidige exemplaar van Program. Op dit moment gebeurt er echter niets, omdat Program er geen invoer is om te vullen.

Importeren en exporteren met kenmerken

Eerst hebt Program u een rekenmachine geïmporteerd. Hierdoor kan de scheiding van problemen met de gebruikersinterface, zoals de invoer en uitvoer van de console, Programworden gescheiden van de logica van de rekenmachine.

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 ingericht met het ImportAttribute kenmerk. Dit kenmerk declareert iets om een import te zijn; Dat wil gezegd, het wordt gevuld door de samenstellingsengine wanneer het object is samengesteld.

Elke import heeft een contract, waarmee wordt bepaald met welke export deze wordt vergeleken. 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 object calculator in feite ICalculatoris, dit niet vereist is. Het contract is onafhankelijk van het type importobject. (In dit geval kunt u de typeof(ICalculator). MEF gaat er automatisch van uit dat het contract is gebaseerd op het type import, tenzij u dit 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 deze 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 een typeof(MySimpleCalculator) overeenkomst zou niet overeenkomen en de import zou niet worden ingevuld; 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 het uitvoeren van samenstellingen op het Program object wordt uitgevoerd, wordt de import gevuld met een MySimpleCalculator object dat voor dat 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 aan de Main methode toe:

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 gewoon een regel invoer gelezen en wordt de Calculate functie van ICalculator het resultaat aangeroepen, die wordt teruggeschreven naar de console. Dat is alle code die u nodig hebt.Program Alle rest van het werk vindt plaats in de onderdelen.

Import- en ImportMany-kenmerken

Om SimpleCalculator uit te kunnen breidbaar te maken, moet deze een lijst met bewerkingen importeren. Een gewoon ImportAttribute kenmerk wordt gevuld door één en slechts één ExportAttribute. Als er meer dan één beschikbaar is, produceert de samenstellingsengine een fout. Als u een import wilt maken die door een willekeurig aantal exports kan worden gevuld, 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 de export te bewaren. Hier krijgt u naast het geëxporteerde object zelf ook exportmetagegevens of informatie die het geëxporteerde object beschrijft. Elk Lazy<T,TMetadata> object bevat een IOperation object, dat een werkelijke bewerking vertegenwoordigt en een IOperationData object, 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. Als u de optelbewerking beschikbaar wilt 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 functioneert zoals voorheen. Het ExportMetadataAttribute kenmerk koppelt metagegevens, in de vorm van een naam-waardepaar, aan die export. Hoewel de Add klasse wordt geïmplementeerd IOperation, wordt een klasse die wordt geïmplementeerd IOperationData 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, op zijn beurt importeert u een verzameling IOperation objecten en die import wordt opgevuld wanneer MySimpleCalculator deze wordt gemaakt, op hetzelfde moment als de invoer van Program. Als de Add klasse een verdere import heeft gedeclareerd, moet dat ook worden gevuld, 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

Met deze onderdelen blijft de rekenmachinelogica zelf aanwezig. 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 operanden links en rechts 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 het geëxporteerde object kunnen respectievelijk worden geopend met de Metadata eigenschap en de Value eigenschap. Als in dit geval de Symbol eigenschap van het IOperationData object wordt ontdekt dat het een overeenkomst is, roept de calculator de Operate methode van het IOperation object aan en retourneert het resultaat.

Als u de rekenmachine 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. Controleer in Visual Basic of u het Public trefwoord hebt toegevoegd aan Module1. Typ in het consolevenster een optelbewerking, zoals '5+3', en de calculator retourneert de resultaten. Een andere operator resulteert in het bericht 'Bewerking niet gevonden'.

SimpleCalculator uitbreiden met behulp van 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 buiten de eigen bron van een toepassing te zoeken voor onderdelen. Om dit te demonstreren, moet u SimpleCalculator wijzigen om een map te doorzoeken, evenals een eigen assembly, voor onderdelen door een DirectoryCatalog.

Voeg een nieuwe map toe met de naam Extensions van 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 de Project Properties Designer voor het extendedOperations-project en klik op het tabblad Compileren of opbouwen. Wijzig het uitvoerpad of het uitvoerpad bouwen zodat deze verwijst naar de map Extensies 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.) De DirectoryCatalog functie voegt nu onderdelen toe die zijn gevonden in assembly's in de map Extensies aan de samenstellingscontainer.

Voeg in het project ExtendedOperations verwijzingen toe aan SimpleCalculator en System.ComponentModel.Composition. Voeg in het klassebestand ExtendedOperations een Imports 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 het ExportAttribute kenmerk hetzelfde type moet hebben als het ImportAttribute.

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

Conclusie

Dit onderwerp heeft betrekking op de basisconcepten van MEF.

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 uit een bepaalde bron. De samenstellingscontainer maakt gebruik van de onderdelen die door een catalogus worden geleverd om samenstelling uit te voeren, de binding van de invoer naar uitvoer.
Import en export

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

Volgende stappen