Erweitern Sie Ihre .NET-Anwendungen mit Add-Ons

German (Deutsch) translation by Nikol Angelowa (you can also view the original English article)

Ihrer Anwendung fehlt eine coole Whizbang-Funktion? Lassen Sie andere interessierte Entwickler Ihre Anwendung durch Add-Ons erweitern. Indem Sie Ihre App später für zusätzliche Funktionen öffnen, können Sie eine florierende Community rund um Ihre Anwendung aufbauen, möglicherweise sogar einen Marktplatz!

Im heutigen Tutorial werden wir genau das lernen!

Schritt 0 - Unser Spielplan

Abhängig von der verwendeten Version von Visual Studio und der Version des Frameworks, auf das Sie abzielen, sehen einige Screenshots möglicherweise etwas anders aus.

Wir werden eine Proof-of-Concept-Anwendung erstellen, die beim Start Add-Ons lädt, die in einem ihrer Unterverzeichnisse gefunden werden. Diese Add-Ons sind .NET-Assemblys, die mindestens eine Klasse enthalten, die eine bestimmte von uns definierte Schnittstelle implementiert. Die Konzepte in diesem Lernprogramm sollten ohne großen Aufwand problemlos in Ihre vorhandenen Anwendungen übertragen werden können. Dann sehen wir uns ein vollständigeres Beispiel an, bei dem UI-Komponenten verwendet werden, die von einem Add-On geladen wurden.

Dieses Tutorial wurde mit Microsoft Visual Studio 2010 in VB.NET für .NET Framework 4.0 erstellt. Die wichtigsten Konzepte dieses Tutorials sollten in anderen CLR-Sprachen ab .NET Framework 1.1 funktionieren. Es gibt einige kleinere Funktionen, die in anderen CLR-Sprachen nicht funktionieren - aber sehr einfach zu portieren sein sollten - und einige Konzepte wie Generika, die in .NET 1.1 usw. offensichtlich nicht funktionieren.

Hinweis: Das ist ein Tutorial auf Expertenebene für Benutzer, die mit der Konvertierung von Code zwischen verschiedenen CLR-Sprachen und Versionen des .NET-Frameworks zufrieden sind. Es ist mehr "Ersetzen Ihres Automotors" als "Fahren".

Schritt 1 - Erste Implementierung im kleinen Maßstab

Hinweis: Ihre Referenzen können je nach der Version von .NET Framework, auf die Sie abzielen, unterschiedlich sein.

Beginnen wir mit der Implementierung einer kleinen Version unserer Anwendung. Wir werden drei Projekte in unserer Lösung benötigen:

ConsoleAppA: Eine Konsolenanwendung
ClassLibA: Eine Klassenbibliothek
AddonA: Eine Klassenbibliothek, die als unser Add-On fungiert

Fügen Sie ClassLibA eine Referenz von ConsoleAppA und AddonA hinzu. Der Lösungs-Explorer sollte so aussehen:

Erstellung von der Add-On-Schnittstelle

Damit eine kompilierte Klasse als kompatibel angesehen werden kann, muss jedes Add-On für unsere Anwendung eine bestimmte Schnittstelle implementieren. Diese Schnittstelle definiert die erforderlichen Eigenschaften und Operationen, über die die Klasse verfügen muss, damit unsere Anwendung problemlos mit dem Add-On interagieren kann. Wir könnten auch eine abstract/MustInherit-Klasse als Basis für Add-Ons verwenden, aber in diesem Beispiel verwenden wir eine Schnittstelle.

Hier ist der Code für unsere Schnittstelle, der in einer Datei namens IApplicationModule in der ClassLibA-Klassenbibliothek abgelegt werden sollte.

Public Interface IApplicationModule

    ReadOnly Property Id As Guid
    ReadOnly Property Name As String

    Sub Initialise()

End Interface

Die Eigenschaften und Methoden, die Sie in der Schnittstelle definieren, sind beliebig. In diesem Fall habe ich zwei Eigenschaften und eine Methode definiert, aber in der Praxis können und sollten Sie sie nach Bedarf ändern.

In unserem ersten Beispiel werden die Eigenschaften Id oder Name nicht verwendet, aber sie sind nützliche Eigenschaften, die implementiert werden müssen. Wenn Sie Add-Ons in der Produktion verwenden, möchten Sie sie vorhanden haben.

Add-On erstellen

Jetzt erstellen wir das eigentliche Add-On. Damit eine Klasse als Add-On für unsere Anwendung betrachtet werden kann, muss sie unsere Schnittstelle - IApplicationModule - implementieren.

Hier ist der Code für unser Basis-Add-On, der in einer Datei namens MyAddonClass in der AddonA-Klassenbibliothek abgelegt werden sollte.

Imports ClassLibA

Public Class MyAddonClass
    Implements IApplicationModule

    Public ReadOnly Property Id As System.Guid Implements ClassLibA.IApplicationModule.Id
        Get
            Return New Guid("adb86b53-2207-488e-b0f3-ecd13eae4042")
        End Get
    End Property

    Public Sub Initialise() Implements ClassLibA.IApplicationModule.Initialise
        Console.WriteLine("MyAddonClass is starting up ...")
        'Perform start-up initialisation here ...
    End Sub

    Public ReadOnly Property Name As String Implements ClassLibA.IApplicationModule.Name
        Get
            Return "My first test add-on"
        End Get
    End Property
End Class

Schritt 2 - Suchen von Add-Ons zur Laufzeit

Dann benötigen wir eine Möglichkeit, Add-Ons für unsere Anwendung zu finden. In diesem Beispiel wird davon ausgegangen, dass im Verzeichnis der ausführbaren Datei ein Addons-Ordner erstellt wurde. Wenn Sie dies in Visual Studio testen, berücksichtigen Sie das Standard-Projektausgabeverzeichnis für Projekte, nämlich ./bin/debug/, sodass Sie ein ./bin/debug/Addons/-Verzeichnis benötigen.

Zeit zum Nachdenken

Platzieren Sie die TryLoadAssemblyReference-Methode unten in Module1 von ConsoleAppA. Wir untersuchen die beladene Baugruppe mithilfe von Reflection. Eine Pseudo-Code-exemplarische Vorgehensweise für die Funktionalität lautet wie folgt:

Versuchen Sie, den angegebenen dllFilePath als .NET-Assembly zu laden
Wenn wir die Assembly erfolgreich geladen haben, fahren Sie fort
Für jedes Modul in der geladenen Baugruppe
Für jeden Typ in diesem Modul
Für jede von diesem Typ implementierte Schnittstelle
Wenn diese Schnittstelle unsere Add-On-Schnittstelle (IApplicationModule) ist, dann
Führen Sie Aufzeichnungen über diesen Typ. Beenden Sie die Suche.
Geben Sie zum Schluss alle gefundenen gültigen Typen zurück

    Private Function TryLoadAssemblyReference(ByVal dllFilePath As String) As List(Of System.Type)
        Dim loadedAssembly As Assembly
        Dim listOfModules As New List(Of System.Type)
        Try
            loadedAssembly = Assembly.LoadFile(dllFilePath)
        Catch ex As Exception
        End Try
        If loadedAssembly IsNot Nothing Then
            For Each assemblyModule In loadedAssembly.GetModules
                For Each moduleType In assemblyModule.GetTypes()
                    For Each interfaceImplemented In moduleType.GetInterfaces()
                        If interfaceImplemented.FullName = "ClassLibA.IApplicationModule" Then
                            listOfModules.Add(moduleType)
                        End If
                    Next
                Next
            Next
        End If
        Return listOfModules
    End Function

Starten Sie unsere Add-Ons

Schließlich können wir jetzt eine kompilierte Klasse laden, die unsere Schnittstelle in den Speicher implementiert. Wir haben jedoch keinen Code, um diese Klassen zu finden, zu instanziieren oder Methodenaufrufe durchzuführen. Als nächstes werden wir einen Code zusammenstellen, der genau das tut.

Der erste Teil besteht darin, alle Dateien zu finden, bei denen es sich möglicherweise um Add-Ons handelt (siehe unten). Der Code führt eine relativ einfache Dateisuche durch und versucht für jede gefundene DLL-Datei, alle gültigen Typen aus dieser Assembly zu laden. DLLs, die im Ordner "Addons" gefunden wurden, sind nicht unbedingt Add-Ons. Sie können lediglich zusätzliche Funktionen enthalten, die für ein Add-On erforderlich sind, sind jedoch an sich kein Add-On.

        Dim currentApplicationDirectory As String = My.Application.Info.DirectoryPath
        Dim addonsRootDirectory As String = currentApplicationDirectory & "\Addons\"
        Dim addonsLoaded As New List(Of System.Type)

        If My.Computer.FileSystem.DirectoryExists(addonsRootDirectory) Then
            Dim dllFilesFound = My.Computer.FileSystem.GetFiles(addonsRootDirectory, Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories, "*.dll")
            For Each dllFile In dllFilesFound
                Dim modulesFound = TryLoadAssemblyReference(dllFile)
                addonsLoaded.AddRange(modulesFound)
            Next
        End If

Dann müssen wir für jeden gültigen Typ, den wir gefunden haben, etwas tun. Der folgende Code erstellt eine neue Instanz des Typs, gibt den Typ ein, ruft die Initialise()-Methode auf (dies ist nur eine beliebige Methode, die wir in unserer Schnittstelle definiert haben) und behält dann einen Verweis auf diesen instanziierten Typ in einer Liste auf Modulebene bei .

        If addonsLoaded.Count > 0 Then
            For Each addonToInstantiate In addonsLoaded
                Dim thisInstance = Activator.CreateInstance(addonToInstantiate)
                Dim thisTypedInstance = CType(thisInstance, ClassLibA.IApplicationModule)
                thisTypedInstance.Initialise()
                m_addonInstances.Add(thisInstance)
            Next
        End If

Alles in allem sollte unsere Konsolenanwendung ungefähr so aussehen:

Imports System.Reflection

Module Module1

    Private m_addonInstances As New List(Of ClassLibA.IApplicationModule)

    Sub Main()
        LoadAdditionalModules()

        Console.WriteLine('Finished loading modules ...')
        Console.ReadLine()
    End Sub

    Private Sub LoadAdditionalModules()
        Dim currentApplicationDirectory As String = My.Application.Info.DirectoryPath
        Dim addonsRootDirectory As String = currentApplicationDirectory & '\Addons\'
        Dim addonsLoaded As New List(Of System.Type)

        If My.Computer.FileSystem.DirectoryExists(addonsRootDirectory) Then
            Dim dllFilesFound = My.Computer.FileSystem.GetFiles(addonsRootDirectory, Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories, "*.dll")
            For Each dllFile In dllFilesFound
                Dim modulesFound = TryLoadAssemblyReference(dllFile)
                addonsLoaded.AddRange(modulesFound)
            Next
        End If

        If addonsLoaded.Count > 0 Then
            For Each addonToInstantiate In addonsLoaded
                Dim thisInstance = Activator.CreateInstance(addonToInstantiate)
                Dim thisTypedInstance = CType(thisInstance, ClassLibA.IApplicationModule)
                thisTypedInstance.Initialise()
                m_addonInstances.Add(thisInstance)
            Next
        End If
    End Sub

    Private Function TryLoadAssemblyReference(ByVal dllFilePath As String) As List(Of System.Type)
        Dim loadedAssembly As Assembly
        Dim listOfModules As New List(Of System.Type)
        Try
            loadedAssembly = Assembly.LoadFile(dllFilePath)            
        Catch ex As Exception
        End Try
        If loadedAssembly IsNot Nothing Then
            For Each assemblyModule In loadedAssembly.GetModules
                For Each moduleType In assemblyModule.GetTypes()
                    For Each interfaceImplemented In moduleType.GetInterfaces()
                        If interfaceImplemented.FullName = 'ClassLibA.IApplicationModule' Then
                            listOfModules.Add(moduleType)
                        End If
                    Next
                Next
            Next
        End If
        Return listOfModules
    End Function
End Module

Probelauf

Zu diesem Zeitpunkt sollten wir in der Lage sein, einen vollständigen Build unserer Lösung durchzuführen. Wenn Ihre Dateien erstellt wurden, kopieren Sie die kompilierte Assembly-Ausgabe des AddonA-Projekts in den Addons-Ordner von ConsoleAppA. Der Addons-Ordner sollte unter dem Ordner /bin/debug/ erstellt werden. Auf meinem Computer mit Visual Studio 2010, Standardprojektspeicherorten und einer Lösung namens "DotNetAddons" befindet sich der Ordner hier:

C:\Users\jplenderleith\Documents\Visual Studio 2010\Projects\DotNetAddons\ConsoleAppA\bin\Debug\Addons

Wir sollten die folgende Ausgabe sehen, wenn wir den Code ausführen:

1	MyAddonClass is starting up ...
2	Finished loading modules ...

So wie es aussieht, ist es nicht auffällig oder beeindruckend, aber es zeigt eine wichtige Funktionalität, nämlich, dass wir zur Laufzeit eine Assembly abrufen und Code innerhalb dieser Assembly ausführen können, ohne über vorhandene Kenntnisse über diese Assembly zu verfügen. Dies ist die Grundlage für die Erstellung komplexerer Add-Ons.

Schritt 3 - Integration in eine Benutzeroberfläche

Als Nächstes werden einige Add-Ons erstellt, um zusätzliche Funktionen in einer Windows Forms-Anwendung bereitzustellen.

Erstellen Sie ähnlich wie bei der vorhandenen Lösung eine neue Lösung mit den folgenden Projekten:

WinFormsAppA: Eine Windows Forms-Anwendung
ClassLibA: Eine Klassenbibliothek
UIAddonA: Eine Klassenbibliothek, die einige Add-Ons mit UI-Komponenten enthält

Ähnlich wie bei unserer vorherigen Lösung sollten sowohl die WinFormsAppA- als auch die UIAddonA-Projekte Verweise auf die ClassLibA enthalten. Das UIAddonA-Projekt benötigt außerdem einen Verweis auf System.Windows.Forms, um auf Funktionen zugreifen zu können.

Die Windows Forms-Anwendung

Wir erstellen eine schnelle und einfache Benutzeroberfläche für unsere Anwendung, die aus einem MenuStrip und einem DataGridView besteht. Das MenuStrip-Steuerelement sollte drei MenuItems haben

Datei
Add-Ons
Hilfe

Docken Sie die DataGridView an ihren übergeordneten Container an - das Formular selbst. Wir werden einen Code zusammenstellen, um einige Scheindaten in unserem Raster anzuzeigen. Das Add-Ons-Menüelement wird mit allen Add-Ons gefüllt, die beim Start der Anwendung geladen wurden.

Hier ist ein Screenshot der Anwendung zu diesem Zeitpunkt:

Schreiben wir einen Code, um der Hauptform von WinFormsAppA einige Funktionen zu geben. Wenn das Formular geladen wird, wird die derzeit leere LoadAddons()-Methode aufgerufen - wir werden dies später ausfüllen. Anschließend generieren wir einige Beispieldaten von Mitarbeitern, an die wir unser DataGridView binden.

Public Class Form1

    Private m_testDataSource As DataSet
    Private m_graphicalAddons As List(Of System.Type)

    Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        LoadAddons()
        m_testDataSource = GenerateTestDataSet()
        With DataGridView1
            .AutoGenerateColumns = True
            .AutoResizeColumns()
            .DataSource = m_testDataSource.Tables(0)
        End With
    End Sub

    Private Sub LoadAddons()        

    End Sub

    Private Function GenerateTestDataSet() As DataSet
        Dim newDataSet As New DataSet
        Dim newDataTable As New DataTable
        Dim firstNames = {"Mary", "John", "Paul", "Justyna", "Michelle", "Andrew", "Michael"}
        Dim lastNames = {"O'Reilly", "Murphy", "Simons", "Kelly", "Gates", "Power"}
        Dim deptNames = {"Marketing", "Sales", "Technical", "Secretarial", "Security"}

        With newDataTable
            .Columns.Add("EmployeeId", GetType(Integer))
            .Columns.Add("Name", GetType(String))
            .Columns.Add("IsManager", GetType(Boolean))
            .Columns.Add("Department", GetType(String))
        End With

        For i = 1 To 100
            Dim newDataRow As DataRow = newDataTable.NewRow()
            With newDataRow
                .Item("EmployeeId") = i
                .Item("Name") = firstNames(i Mod firstNames.Count) & " " & lastNames(i Mod lastNames.Count)
                .Item("IsManager") = ((i Mod 20) = 0)
                .Item("Department") = deptNames(i Mod deptNames.Count)
            End With
            newDataTable.Rows.Add(newDataRow)
        Next

        newDataSet.Tables.Add(newDataTable)
        Return newDataSet
    End Function

End Class

Wenn wir die Anwendung ausführen, sollte sie folgendermaßen aussehen:

Nachdem wir die Add-On-Schnittstellen definiert haben, kehren wir zu unseren leeren LoadAddons() zurück.

Add-On-Schnittstelle

Definieren wir unsere Add-On-Oberfläche. UI-Komponenten werden unter Add-ons MenuStrip aufgelistet und öffnen ein Windows-Formular, das Zugriff auf die Daten hat, an die unser DataGrid gebunden ist. Fügen Sie dem ClassLibA-Projekt eine neue Schnittstellendatei mit dem Namen IGraphicalAddon hinzu und fügen Sie den folgenden Code in die Datei ein:

Public Interface IGraphicalAddon

    ReadOnly Property Name As String
    WriteOnly Property DataSource As DataSet
    Sub OnClick(ByVal sender As Object, ByVal e As System.EventArgs)

End Interface

Wir haben eine Name-Eigenschaft, die ziemlich selbsterklärend ist.
Die DataSource wird ordnungsgemäß verwendet, um Daten an dieses Add-On weiterzuleiten.
Die OnClick-Methode, die als Handler verwendet wird, wenn Benutzer auf den Eintrag unseres Add-Ons im Menü Addons klicken.

Laden der Add-Ons

Fügen Sie dem ClassLibA-Assemblyprojekt eine Klassenbibliothek mit dem Namen AddonLoader mit dem folgenden Code hinzu:

Imports System.Reflection

Public Class AddonLoader
    Public Enum AddonType
        IGraphicalAddon = 10
        ISomeOtherAddonType2 = 20
        ISomeOtherAddonType3 = 30
    End Enum

    Public Function GetAddonsByType(ByVal addonType As AddonType) As List(Of System.Type)
        Dim currentApplicationDirectory As String = My.Application.Info.DirectoryPath
        Dim addonsRootDirectory As String = currentApplicationDirectory & "\Addons\"
        Dim loadedAssembly As Assembly
        Dim listOfModules As New List(Of System.Type)

        If My.Computer.FileSystem.DirectoryExists(addonsRootDirectory) Then
            Dim dllFilesFound = My.Computer.FileSystem.GetFiles(addonsRootDirectory, Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories, "*.dll")
            For Each dllFile In dllFilesFound

                Try
                    loadedAssembly = Assembly.LoadFile(dllFile)
                Catch ex As Exception
                End Try
                If loadedAssembly IsNot Nothing Then
                    For Each assemblyModule In loadedAssembly.GetModules
                        For Each moduleType In assemblyModule.GetTypes()
                            For Each interfaceImplemented In moduleType.GetInterfaces()
                                If interfaceImplemented.Name = addonType.ToString Then
                                    listOfModules.Add(moduleType)
                                End If
                            Next
                        Next
                    Next
                End If

            Next
        End If

        Return listOfModules
    End Function
End Class

Sie können ähnlichen Code verwenden, um Add-On-Entwickler darauf zu beschränken, nur bestimmte Arten von Add-Ons zu erstellen

In dieser Klasse haben wir eine Möglichkeit bereitgestellt, verschiedene Arten von Add-Ons zu laden. Sie können ähnlichen Code verwenden, um Add-On-Entwickler darauf zu beschränken, nur bestimmte Arten von Add-Ons zu erstellen oder sie zumindest zu kategorisieren. In unserem Beispiel verwenden wir nur den ersten deklarierten Add-On-Typ, nämlich IGraphicalAddon.

Wenn wir andere Add-On-Typen in unserem Projekt hatten, um beispielsweise die Berichtsfunktionalität zu verbessern oder einige nützliche Tastaturkürzel bereitzustellen, möchten wir nicht, dass diese in unserem Add-On-Menü aufgeführt werden, da es keinen Sinn macht, dass jemand darauf klicken kann auf diesem Add-On.

Allerdings kann es wünschenswert sein, in einer Menüleiste einen Verweis auf alle Add-Ons hinzuzufügen. Klicken Sie auf, um das Optionsformular des Add-Ons anzuzeigen. Dies würde jedoch den Rahmen dieses Tutorials sprengen.

Das grafische Add-On

Lassen Sie uns das eigentliche UI-Add-On erstellen. Fügen Sie dem UIAddonA-Assemblyprojekt die folgenden zwei Dateien hinzu. eine Klasse namens UIReportAddon1 und ein Windows-Formular namens UIReportAddon1Form. Die UIReportAddon1-Klasse enthält den folgenden Code:

Imports ClassLibA

Public Class UIReportAddon1
    Implements ClassLibA.IGraphicalAddon

    Private _dataSource As DataSet
    Public WriteOnly Property DataSource As System.Data.DataSet Implements IGraphicalAddon.DataSource
        Set(ByVal value As System.Data.DataSet)
            _dataSource = value
        End Set
    End Property

    Public ReadOnly Property Name As String Implements IGraphicalAddon.Name
        Get
            Return "Managers Report"
        End Get
    End Property

    Public Sub OnClick(ByVal sender As Object, ByVal e As System.EventArgs) Implements IGraphicalAddon.OnClick
        Dim newUiReportingAddonForm As New UIReportAddon1Form
        newUiReportingAddonForm.SetData(_dataSource)
        newUiReportingAddonForm.ShowDialog()
    End Sub
End Class

Fügen Sie UIReportAddon1Form eine DataGridView hinzu, die in ihrem übergeordneten Container angedockt ist. Fügen Sie dann den folgenden Code hinzu:

Public Class UIReportAddon1Form

    Private m_providedDataSource As DataSet

    Public Sub SetData(ByVal DataSource As System.Data.DataSet)
        m_providedDataSource = DataSource
        FilterAndShowData()
    End Sub

    Private Sub FilterAndShowData()
        Dim managers = m_providedDataSource.Tables(0).Select("IsManager = True")
        Dim newDataTable = m_providedDataSource.Tables(0).Clone
        For Each dr In managers
            newDataTable.ImportRow(dr)
        Next
        DataGridView1.DataSource = newDataTable
    End Sub

    Private Sub UIReportAddon1Form_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        Text = "List of managers"
    End Sub
End Class

Wir bieten lediglich die Möglichkeit, Daten an das Formular zu senden und es dann entscheiden zu lassen, was mit diesen Daten geschehen soll. In diesem Fall führen wir Select() für eine DataTable aus und rufen eine Liste aller Mitarbeiter ab, die Manager sind.

Zurück zu unserer Hauptbenutzeroberfläche

Jetzt ist es Zeit, unsere unvollendete LoadAddons()-Methode in unserem WinFormsAppA-Projekt abzuschließen. Dieser Code weist die GetAddonsByType-Methode von ClassLibA.AddonLoader an, einen bestimmten Add-On-Typ zu finden - in diesem Fall IGraphicalAddon-Add-Ons.

Für jedes gefundene Add-On werden die folgenden Aktionen ausgeführt

Erstellen Sie eine neue Instanz des Add-Ons
Geben Sie die Add-On-Instanz zu IGraphicalAddon ein
Füllen Sie die DataSource-Eigenschaft aus
Fügen Sie das Add-On zum Menüpunkt Add-Ons hinzu
Fügen Sie einen Handler für das Click-Ereignis dieses Menüelements hinzu

    Private Sub LoadAddons()
        Dim loader As New ClassLibA.AddonLoader
        Dim addonsLoaded = loader.GetAddonsByType(ClassLibA.AddonLoader.AddonType.IGraphicalAddon)

        For Each graphicalAddon In addonsLoaded
            Dim thisInstance = Activator.CreateInstance(graphicalAddon)
            Dim typedAddon = CType(thisInstance, ClassLibA.IGraphicalAddon)
            typedAddon.DataSource = m_testDataSource
            Dim newlyAddedToolstripItem = AddonsToolStripMenuItem.DropDownItems.Add(typedAddon.Name)
            AddHandler newlyAddedToolstripItem.Click, AddressOf typedAddon.OnClick
        Next
    End Sub

Testen unserer Benutzeroberfläche

Stellen Sie sicher, dass Sie eine vollständige erfolgreiche Kompilierung der Lösung durchführen können. Kopieren Sie die Datei UIAddonA.dll aus dem Ausgabe-Debug-Ordner des UIAddonA-Projekts in den Ordner /bin/debug/Addons/ des WinFormsAppA-Projekts. Wenn Sie das Projekt ausführen, sollten Sie, wie zuvor, ein Datenraster sehen. Wenn Sie jedoch in das Menü Add-Ons klicken, sollte jetzt ein Verweis auf das neu erstellte Add-On angezeigt werden.

Wenn wir auf den Menüpunkt Managerbericht klicken, wird ein Methodenaufruf für die in unserem Add-On implementierte OnClick-Methode ausgeführt, wodurch UIReportAddon1Form so angezeigt wird.

Abschluss

Wir haben zwei Beispiele für die Erstellung einer Anwendung gesehen, mit der Add-Ons nach Bedarf abgerufen und ausgeführt werden können. Wie bereits erwähnt, sollte es einfach genug sein, diese Art von Funktionalität in vorhandene Anwendungen zu integrieren. Die Frage, wie viel Kontrolle Sie benötigen (oder wollen), um Entwicklern von Drittanbietern zu geben, ist eine ganz andere Frage.

Ich hoffe Sie haben Spaß mit diesem Tutorial! Vielen Dank fürs Lesen!