> ## Documentation Index
> Fetch the complete documentation index at: https://developer.jtl-software.com/llms.txt
> Use this file to discover all available pages before exploring further.

# JTLwawiExtern.dll einbinden

In diesem Abschnitt finden Sie eine Erklärung zur Einbindung der `JTLwawiExtern.dll`. Im Beispielprojekt können Sie sich das gesamte Projekt anschauen.

<Steps>
  <Step title="Projekt öffnen">
    Öffnen Sie Ihr Projekt in Ihrem Visual Studio.
  </Step>

  <Step title="Verweis hinzufügen">
    Klicken Sie mit rechts auf **Verweise** und anschließend auf **Verweis hinzufügen**.
  </Step>

  <Step title="DLL auswählen">
    Klicken Sie nun auf der linken Seite auf **Durchsuchen** und anschließend auf den Durchsuchen-Button unten am Dialog-Fensterrand.

    Suchen Sie nun die `JTLwawiExtern.dll` in dem JTL-Software Verzeichnis. Klicken Sie anschließend auf **OK**.

    * **Standardpfad (x64-System):** `C:\Program Files (x86)\JTL-Software`
    * **Standardpfad (x86-System):** `C:\Program Files\JTL-Software`
  </Step>

  <Step title="Lokale Kopie deaktivieren">
    Nun müssen Sie in den Eigenschaften des Verweis für die `JTLwawiExtern.dll` die **Lokale Kopie** auf **False** setzen, was standardmäßig auf **True** gesetzt ist.

    Dies ist für die nächsten Schritte notwendig, da nur über das Einbinden des Verweis nicht alle von der `JTLwawiExtern.dll` benötigten Verweise nachgeladen werden können, da das Projekt nur im Projektverzeichnis oder im Global Assembly Cache nach den DLLs sucht und nicht dort, wo sich die DLL lokal auf dem Rechner befindet.
  </Step>

  <Step title="Installationspfad ermitteln">
    Zusätzlich muss die DLL dynamisch zur Laufzeit eingebunden werden. Dazu müssen Sie die folgenden Methoden verwenden, welche die Registry nach dem Installationspfad der Wawi durchsuchen.

    Die Methode `FindInstallLocation()` übergibt der Methode `FindUninstallSubkey()` den Basis-Registry-Zweig für 32-Bit oder 64-Bit Systeme.

    In der Methode `FindUninstallSubkey()` wird im übergebenen Registryzweig nach dem Pfad zur Installation der Wawi gesucht und falls dieser gefunden wird, wird er zurückgegeben.

    ```csharp theme={null}
    private string FindInstallLocation()
    {
        var cLocation = FindUninstallSubkey(@"Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall");
        return !string.IsNullOrEmpty(cLocation) ? cLocation : FindUninstallSubkey(@"Software\Microsoft\Windows\CurrentVersion\Uninstall");
    }

    private string FindUninstallSubkey(string baseKey)
    {
        var oKey = Registry.LocalMachine.OpenSubKey(baseKey);
        if (oKey == null)
            return null;
        return oKey.GetSubKeyNames()
            .Select(oKey.OpenSubKey)
            .Where(oSubKey => Equals("JTL-Wawi", oSubKey.GetValue("DisplayName")))
            .Select(oSubKey => Convert.ToString(oSubKey.GetValue("InstallLocation")))
            .FirstOrDefault();
    }
    ```
  </Step>

  <Step title="Versionsprüfung">
    Des Weiteren sollten Sie prüfen, ob die Versionsnummer der lokal gefundenen `JTLwawiExtern.dll` mindestens genau so groß ist, wie die der über Verweise eingebundenen `JTLwawiExtern.dll`. Dies ist notwendig, da man nicht davon ausgehen kann, dass in einer kleineren Version die gleichen Methoden enthalten sind.

    Allerdings muss die Version der über Verweise eingebundenen `JTLwawiExtern.dll` per Hand angegeben werden. Die Version findet man unter den Eigenschaften der eingebundenen DLL.

    ```csharp theme={null}
    private bool ValidExternDllVersion()
    {
        var externDllPath = Path.Combine(this._wawiPath, "JTLwawiExtern.dll");
        var externDllVersion = new Version(FileVersionInfo.GetVersionInfo(externDllPath).FileVersion);
        var eingebundeneExternDllVersion = new Version(1, 1, 0, 9);
        return externDllVersion >= eingebundeneExternDllVersion;
    }
    ```
  </Step>

  <Step title="Resolver abonnieren">
    Mittels der folgenden Programmzeile müssen Sie ein Event für den Resolver abonnieren, welches es ermöglicht die benötigten DLLs zur Laufzeit nachzuladen.

    <Warning>
      Das Abonnieren des Events im Resolver muss zwingend vor dem Ausführen von Code, der auf die `JTLwawiExtern.dll` zugreift, stattfinden, da es ansonsten zu Laufzeitfehlern kommen kann. Falls kein Installationspfad gefunden werden kann oder die Versionsprüfung aus Schritt 6 fehlschlägt, sollte das Programm beendet werden, da man nicht auf die DLLs zugreifen kann.
    </Warning>

    ```csharp theme={null}
    AppDomain.CurrentDomain.AssemblyResolve += this.LoadAssemblys;
    ```

    Das Event `LoadAssemblys()` lädt dann aus dem Installationspfad der Wawi, hier im Feld `_wawiPath` gespeichert, die benötigten DLLs nach, sofern diese existieren.

    ```csharp theme={null}
    private Assembly LoadAssemblys(object sender, ResolveEventArgs args)
    {
        var folderPath = Path.GetDirectoryName(this._wawiPath);
        var assemblyPath = Path.Combine(folderPath ?? throw new InvalidOperationException(), $"{new AssemblyName(args.Name).Name}.dll");
        if (!File.Exists(assemblyPath))
            return null;
        var assembly = Assembly.LoadFrom(assemblyPath);
        return assembly;
    }
    ```
  </Step>

  <Step title="using-Directive hinzufügen">
    Nun müssen Sie in Ihrer Klasse die **using-Directive** für die `JTLwawiExtern.dll` hinzufügen.
  </Step>

  <Step title="CJTLwawiExtern-Objekt erstellen">
    Nun müssen Sie ein Objekt der Klasse `CJTLwawiExtern` erstellen, das Ihnen ermöglicht die Methoden der `JTLwawiExtern.dll` zu nutzen.

    ```csharp theme={null}
    private readonly CJTLwawiExtern _wawiExtern;

    public Worker()
    {
        this._wawiExtern = new CJTLwawiExtern();
    }
    ```
  </Step>
</Steps>