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

# Verschiedene Möglichkeiten zum Laden des Engine-Objekts

> Drei Möglichkeiten zum Laden des ABBYY FineReader Engine-Objekts unter Windows: direkt über FREngine.dll, per COM im Prozess über InprocLoader oder außerhalb des Prozesses über OutprocLoader für Serverszenarien.

<Note>
  Dieses Thema gilt für FRE unter Windows.
</Note>

Es gibt drei Möglichkeiten, das [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt in ABBYY FineReader Engine 12 zu laden. Jede dieser Methoden hat ihre eigenen Besonderheiten, die sich je nach Einsatzszenario auf die Verwendung des Objekts auswirken. Die ersten beiden Methoden eignen sich am besten für interaktive Anwendungen, die nicht für die gleichzeitige Verarbeitung mehrerer Anfragen ausgelegt sind. Die dritte Methode eignet sich am besten für Serverlösungen.

<div id="loading-frenginedll-manually-and-working-with-naked-interfaces">
  ## FREngine.dll manuell laden und mit „nackten“ Schnittstellen arbeiten
</div>

Dies ist die Standardmethode zum Laden des Engine-Objekts. Um eine Referenz auf das Engine-Objekt zu erhalten, rufen Sie die Funktion [InitializeEngine](/de/fine-reader/engine/api-reference/functions/initializeengine-function) auf.

<table><thead><tr><th><p>Vorteile</p></th><th><p>Einschränkungen</p></th></tr></thead><tbody><tr><td><ul><li>Bietet maximale Leistung.</li><li>Erfordert keine Registrierung von FREngine.dll.</li></ul></td><td><ul><li>Schränkt die Arbeit mit Multithread-Anwendungen ein (siehe <a href="/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/using-in-server-applications">Verwenden von ABBYY FineReader Engine in Multithread-Serveranwendungen</a>).</li><li>Bei der Arbeit mit höheren Programmiersprachen (z. B. .NET) müssen Low-Level-Methoden verwendet werden, um dynamische Bibliotheken zu laden und die darin exportierten Funktionen aufzurufen.</li></ul></td></tr></tbody></table>

<Accordion title="C#-Code">
  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      public EngineLoader()
      {
          // Initialisieren Sie diese Variablen mit dem vollständigen Pfad zu FREngine.dll, Ihrer Customer Project ID
          // und gegebenenfalls dem Pfad zu Ihrer Online-Lizenz-Token-Datei sowie dem Kennwort der Online-Lizenz
          string enginePath = "";
          string customerProjectId = "";
          string licensePath = "";
          string licensePassword = "";
          // Die Bibliothek FREngine.dll laden
          dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
             
          try
          {
              if (dllHandle == IntPtr.Zero)
              {
                  throw new Exception("Can't load " + enginePath);
              }
              IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
              if (initializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find InitializeEngine function");
              }
              IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
              if (deinitializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find DeinitializeEngine function");
              }
              IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
              if (dllCanUnloadNowPtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find DllCanUnloadNow function");
              }
              // Zeiger in Delegaten umwandeln
              initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  initializeEnginePtr, typeof(InitializeEngine));
              deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  deinitializeEnginePtr, typeof(DeinitializeEngine));
              dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                  dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
              // Die Funktion InitializeEngine aufrufen 
              // und dabei den Pfad zur Online-Lizenz-Datei und das Kennwort der Online-Lizenz übergeben
              int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                  "", "", false, ref engine);
              Marshal.ThrowExceptionForHR(hresult);
          }
          catch (Exception)
          {
              // Die Bibliothek FREngine.dll freigeben
              engine = null;
              // Alle Objekte vor dem Aufruf von FreeLibrary löschen
              GC.Collect();
              GC.WaitForPendingFinalizers();
              GC.Collect();
              FreeLibrary(dllHandle);
              dllHandle = IntPtr.Zero;
              initializeEngine = null;
              deinitializeEngine = null;
              dllCanUnloadNow = null;
              throw;
          }
      }
      // Funktionen aus Kernel32.dll
      [DllImport("kernel32.dll")]
      private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
      private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
      [DllImport("kernel32.dll")]
      private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
      [DllImport("kernel32.dll")]
      private static extern bool FreeLibrary(IntPtr hModule);
      // Funktionen aus FREngine.dll
      [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
      private delegate int InitializeEngine(string customerProjectId, string licensePath, 
          string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, 
          ref FREngine.IEngine engine);
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DeinitializeEngine();
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DllCanUnloadNow();
      // Private Variablen
      private FREngine.IEngine engine = null;
      // Handle für FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

<div id="loading-the-engine-object-by-means-of-com-into-the-current-process">
  ## Laden des Engine-Objekts per COM in den aktuellen Prozess
</div>

Die Engine wird als In-Process-Server in denselben Prozess geladen, in dem die Anwendung ausgeführt wird. Das Engine-Objekt wird über das Objekt [InprocLoader](/de/fine-reader/engine/api-reference/engine-loaders/inprocloader) geladen, das die Schnittstelle [IEngineLoader](/de/fine-reader/engine/api-reference/engine-loaders/iengineloader) implementiert.

<table><thead><tr><th><p>Vorteile</p></th><th><p>Einschränkungen</p></th></tr></thead><tbody><tr><td><ul><li>Alle Objekte von ABBYY FineReader Engine sind vollständig thread-sicher und können in verschiedenen Threads erstellt und verwendet werden.</li><li>Bei der Arbeit aus dem Main-STA-Apartment entspricht die Leistung der Arbeit mit den nackten Schnittstellen. Beim Zugriff aus verschiedenen Threads kann Marshalling-Overhead auftreten, dieser ist in den meisten Szenarien jedoch vernachlässigbar.</li></ul></td><td><ul><li>Bei der Installation der fertigen Anwendung auf dem Computer eines Endbenutzers muss FREngine.dll registriert werden.</li></ul></td></tr></tbody></table>

<Accordion title="C#-Code">
  ```csharp theme={null}
  IEngineLoader engineLoader = new FREngine.InprocLoader();
  IEngine engine = engineLoader.InitializeEngine( customerProjectId, licensePath, licensePassword, "", "", false );
  try {
   ...
  } finally {
   engineLoader.ExplicitlyUnload();
  }
  ```
</Accordion>

<Note>
  Um FREngine.dll bei der Installation Ihrer Anwendung auf dem Computer eines Endbenutzers zu registrieren, verwenden Sie das Dienstprogramm regsvr32. Wenn Sie ein 64-Bit-Betriebssystem verwenden, wird standardmäßig die 64-Bit-Version von regsvr32 ausgeführt. Verwenden Sie die folgende Befehlszeile:
</Note>

```csharp theme={null}
regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FREngine.dll>"
```

<div id="loading-the-engine-object-by-means-of-com-into-a-separate-process">
  ## Laden des Engine-Objekts mithilfe von COM in einen separaten Prozess
</div>

Die Engine wird als Out-of-Process-Server in einen separaten Prozess geladen. Das Engine-Objekt wird mithilfe des Objekts [OutprocLoader](/de/fine-reader/engine/api-reference/engine-loaders/outprocloader) geladen, das die Schnittstelle [IEngineLoader](/de/fine-reader/engine/api-reference/engine-loaders/iengineloader) implementiert.

<table><thead><tr><th><p>Vorteile</p></th><th><p>Einschränkungen</p></th></tr></thead><tbody><tr><td><ul><li>Alle Objekte von ABBYY FineReader Engine sind vollständig threadsicher. Jede Instanz der Engine wird parallel zu den anderen in einem separaten Prozess ausgeführt.</li><li>Es kann ein Pool von Prozessoren eingerichtet werden, um die CPU-Leistung des Computers vollständig auszuschöpfen.</li></ul></td><td><ul><li>Es entsteht ein geringer Marshalling-Overhead.</li><li>Bei der Installation der fertigen Anwendung auf dem Computer eines Endbenutzers muss FREngine.dll registriert werden.</li><li>Bei der Arbeit unter Konten mit eingeschränkten Berechtigungen müssen die erforderlichen Berechtigungen erteilt werden.</li><li>Es ist nicht möglich, auf ein Seitenbild als HBITMAP zuzugreifen.</li><li>Kann nicht mit Visual Components verwendet werden, da diese nicht mit mehreren Prozessen funktionieren.</li></ul></td></tr></tbody></table>

<Accordion title="C#-Code">
  ```csharp theme={null}
  IEngineLoader engineLoader = new FREngine.OutprocLoader();
  IEngine engine = engineLoader.InitializeEngine( customerProjectId, licensePath, licensePassword, "", "", false);
  try {
   ...
  } finally {
   engineLoader.ExplicitlyUnload();
  }
  ```
</Accordion>

Diese Art, das Engine-Objekt zu laden, wird insbesondere im Codebeispiel [EnginesPool](/de/fine-reader/engine/guided-tour/samples#enginespool) verwendet, das eine wiederverwendbare Lösung für Multithreading-Anwendungen bietet.

* Kontoberechtigungen können mit dem Dienstprogramm DCOM Config eingerichtet werden (geben Sie entweder DCOMCNFG in der Befehlszeile ein oder wählen Sie Control Panel > Administrative Tools > Component Services). Suchen Sie in der Konsolenstruktur den Ordner Component Services > Computers > My Computer > DCOM Config, klicken Sie mit der rechten Maustaste auf ABBYY FineReader Engine 12.5 Loader (Local Server), und klicken Sie auf Properties. Ein Dialogfeld wird geöffnet. Klicken Sie auf die Registerkarte Security. Klicken Sie unter Launch Permissions auf Customize und dann auf Edit, um die Konten anzugeben, die die Anwendung starten dürfen.

<Note>
  Beachten Sie, dass auf einem 64-Bit-Betriebssystem die registrierte DCOM-Anwendung in der 32-Bit-MMC-Konsole verfügbar ist, die mit der folgenden Befehlszeile ausgeführt werden kann:
</Note>

```
"mmc comexp.msc /32"
```

* Um FREngine.dll bei der Installation Ihrer Anwendung auf dem Computer des Endbenutzers zu registrieren, verwenden Sie das Tool regsvr32. Wenn Sie ein 64-Bit-Betriebssystem verwenden, wird standardmäßig die 64-Bit-Version von regsvr32 ausgeführt. Verwenden Sie die folgende Befehlszeile:

```csharp theme={null}
regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FREngine.dll>"
```

* Wir empfehlen, zum Debuggen und Ausführen Ihrer Serveranwendung eine Netzwerklizenz zu verwenden.

Außerdem können Sie über die Schnittstelle [IHostProcessControl](/de/fine-reader/engine/api-reference/engine-loaders/ihostprocesscontrol) die Priorität eines Hostprozesses festlegen und steuern, ob er ausgeführt wird.

<div id="comparison-table">
  ## Vergleichstabelle
</div>

Die folgende Tabelle fasst die Merkmale der drei Lademethoden zusammen:

| Eigenschaften                                                                    | Naked Interfaces        | In-Process-Server       | Out-of-Process-Server |
| -------------------------------------------------------------------------------- | ----------------------- | ----------------------- | --------------------- |
| Funktioniert ohne Proxy (kein Marshalling-Overhead)                              | Ja                      | Es gibt Einschränkungen | Nein                  |
| Funktioniert in Anwendungen mit mehreren Threads                                 | Es gibt Einschränkungen | Ja                      | Ja                    |
| Parallele Prozesse sind möglich (für Serverlösungen)                             | Nein                    | Nein                    | Ja                    |
| Keine Registrierung von FREngine.dll erforderlich                                | Ja                      | Nein                    | Nein                  |
| Es müssen keine Ausführungsberechtigungen konfiguriert werden                    | Ja                      | Ja                      | Nein                  |
| Objekte können mit dem `new`-Operator erstellt werden. Funktioniert in Skripten. | Nein                    | Ja                      | Ja                    |
| Möglichkeit, auf ein Seitenbild als HBITMAP zuzugreifen                          | Ja                      | Ja                      | Nein                  |
| Funktioniert in einem separaten Prozess (ausfallsicher, Recycling)               | Nein                    | Nein                    | Ja                    |
| Kann mit Visual Components verwendet werden                                      | Ja                      | Ja                      | Nein                  |

<div id="see-also">
  ## Siehe auch
</div>

[Einsatz von ABBYY FineReader Engine in Multithread-Serveranwendungen](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/using-in-server-applications)