> ## 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.

# InitializeEngine-Funktion

> InitializeEngine-Funktion in der ABBYY FineReader Engine API — Diese Funktion wird verwendet, um einen Zeiger auf die IEngine-Schnittstelle abzurufen.

Diese Funktion dient dazu, einen Zeiger auf die IEngine-Schnittstelle abzurufen. Als Eingabeparameter wird die Customer Project ID-Nummer übergeben, eine alphanumerische Zeichenfolge, die für alle von Ihrem Projekt verwendeten Developer- und Runtime-Lizenzen identisch ist.

<Note>
  Für Linux- und Windows-Benutzer ermöglicht diese Funktion bei Bedarf einen einfachen Zugriff auf die Online-Lizenzierung. Außerdem können Sie bei der Initialisierung einige zusätzliche Parameter angeben.
</Note>

<div id="syntax">
  ## Syntax
</div>

<div id="c">
  ### C++
</div>

```csharp theme={null}
HRESULT __stdcall InitializeEngine(
  BSTR CustomerProjectID,
  BSTR LicensePath,
  BSTR LicensePassword,
  BSTR FREngineDataFolder,
  BSTR FREngineTempFolder,
  VARIANT_BOOL IsSharedCPUCoresMode,
  IEngine** Engine
);
```

### C\#

```csharp theme={null}
int InitializeEngine(
  string CustomerProjectID,
  string LicensePath,
  string LicensePassword,
  string FREngineDataFolder,
  string FREngineTempFolder,
  bool IsSharedCPUCoresMode,
  ref IEngine Engine
);
```

<div id="visual-basic-net">
  ### Visual Basic .NET
</div>

```csharp theme={null}
Private Declare Function InitializeEngine Lib "FREngine.dll" ( _
  CustomerProjectID As String, _
  LicensePath As String, _
  LicensePassword As String, _
  FREngineDataFolder As String, _
  FREngineTempFolder As String, _
  IsSharedCPUCoresMode As Boolean, _
  ByRef Engine As FREngine.IEngine) _
As Integer
```

<div id="parameters">
  ## Parameter
</div>

**CustomerProjectID**

\[in] Ein string mit der Customer Project ID.

<Note>
  Während der Initialisierung der Bibliothek wird die Liste aller verfügbaren Lizenzen nach einer Developer- oder Runtime-Lizenz durchsucht, die dieser Customer Project ID entspricht. Wird keine entsprechende Lizenz gefunden, tritt ein Fehler für die zuletzt geprüfte Lizenz auf. Sie können für diesen Parameter jedoch auch 0 übergeben und die Lizenz später auswählen, indem Sie vor allen anderen Bibliotheksmethoden die Methode [IEngine::SetCurrentLicense](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/setcurrentlicense-method) aufrufen.
</Note>

**LicensePath**

\[in] Der vollständige Dateiname der Online-Lizenzdatei. Wenn Sie keine Online-Lizenz verwenden, übergeben Sie stattdessen eine leere Zeichenfolge "" oder einen Nullzeiger. Es ist also eine leere Zeichenfolge "" oder ein Nullzeiger zu übergeben.

Für macOS-Benutzer: Dieser Parameter ist für die zukünftige Verwendung reserviert.

**LicensePassword**

\[in] Das Kennwort der Online-Lizenz. Wenn Sie keine Online-Lizenz verwenden, übergeben Sie stattdessen eine leere Zeichenfolge "" oder einen Nullzeiger.

Für macOS-Benutzer: Dieser Parameter ist für die zukünftige Verwendung reserviert.

**FREngineDataFolder**

\[in] Enthält den Pfad zu dem Ordner, in dem ABBYY FineReader Engine benutzerspezifische Daten speichern soll.

Standardmäßig bei automatischer Installation:

> %ProgramData%\ABBYY\SDK\12\FineReader Engine for auxiliary engine data

> Zusätzlich für Linux und Windows:

> %ProgramData%\ABBYY\SDK\12\Licenses for license data

> Wenn Sie den Wert für FREngineDataFolder festlegen, werden alle zusätzlichen Informationen in einen neuen Datenordner geschrieben.

Möglicherweise müssen Sie den Standardwert ändern, zum Beispiel wenn die Spracheinstellungen der Benutzeroberfläche Ihrer Anwendung von denen anderer Anwendungen abweichen müssen, die FineReader Engine verwenden. Nachdem Sie den Standardwert geändert haben, stellen Sie sicher, dass Sie Vollzugriffsberechtigungen für den neuen Datenordner haben.

**FREngineTempFolder**

\[in] Enthält den Pfad zu dem Ordner für temporäre Dateien von ABBYY FineReader Engine. Standardmäßig ist dies der Ordner %TEMP%\ABBYY FineReader Engine 12.

**IsSharedCPUCoresMode**

\[in] Gibt an, ob die CPU-Kerne im gemeinsamen Modus verwendet werden sollen. Es gibt zwei Modi für die Nutzung der CPU-Kerne: getrennt und gemeinsam. Im getrennten Modus verwendet ABBYY FineReader Engine nicht mehr Prozesse, als durch die Lizenz zulässig sind. Im gemeinsamen Modus kann eine beliebige Anzahl von Prozessen ausgeführt werden, aber all diese Prozesse verwenden nur die CPU-Kerne, die durch die Eigenschaft [IMultiProcessingParams::SharedCPUCoresMask](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams#sharedcpucoresmask) angegeben sind.

<Note>
  Dieser Parameter wird in ABBYY FineReader Engine für Windows ignoriert.
</Note>

**Engine**

\[out, retval] Ein Zeiger auf eine IEngine\*-Zeigervariable, die den Schnittstellenzeiger auf das resultierende [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt empfängt.

<div id="return-values">
  ## Rückgabewerte
</div>

Die Funktion kann die [standardmäßigen Rückgabewerte der ABBYY FineReader Engine-Funktionen](/de/fine-reader/engine/api-reference/return-codes) zurückgeben.

<div id="remarks">
  ## Hinweise
</div>

Mit dieser Funktion kann in einer einzelnen Instanz der Anwendung, die ABBYY FineReader Engine verwendet, nur ein [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt erstellt werden. Wiederholte Versuche, das Engine-Objekt zu erstellen, geben dasselbe Objekt zurück.

<Warning>
  Das Erstellen des Engine-Objekts kann merklich Zeit in Anspruch nehmen. Während der Initialisierung lädt die Engine die unten aufgeführte Hauptbibliothek sowie eine große Anzahl zusätzlicher dynamischer Bibliotheken:
</Warning>

* Linux: libFREngine.so
* macOS: libFREngine.dylib
* Windows: FREngine.dll

<Note>
  Bei Verwendung einer Netzwerklizenz kann die Initialisierung unter Linux und Windows aufgrund der Kommunikation mit dem Lizenzserver ebenfalls länger dauern. Stellen Sie sicher, dass die Netzwerkverbindung die erforderliche Leistung erbringt; für einen zuverlässigen Betrieb mit einer Netzwerklizenz wird eine Bandbreite von mindestens 100 Kb/s empfohlen.
</Note>

Das Engine-Objekt kann auf einem Mehrprozessorsystem erstellt und ausgeführt werden, jedoch kann in jedem Prozess nur ein Engine-Objekt vorhanden sein. Ein zweiter Aufruf von InitializeEngine innerhalb desselben Prozesses gibt die Referenz auf das vorhandene Objekt zurück. Daher sollten Sie für jeden Prozess ein separates Engine-Objekt erstellen, indem Sie die Funktion InitializeEngine aufrufen.

<Note>
  Für ABBYY FineReader Engine für Windows-Implementierungen mit Mehrprozessorsystemen können [andere Methoden](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) zum Laden des Engine-Objekts hilfreich sein.
</Note>

<Warning>
  Initialisieren und deinitialisieren Sie ABBYY FineReader Engine nicht an den Einstiegspunkten anderer dynamischer Bibliotheken sowie nicht in Konstruktoren und Destruktoren von statischen und globalen Objekten, die in dynamischen Bibliotheken implementiert sind, da diese an den Einstiegspunkten der dynamischen Bibliothek aufgerufen werden.
</Warning>

ABBYY FineReader Engine sollte an anderer Stelle initialisiert und deinitialisiert werden – beispielsweise in der main- oder WinMain-Funktion eines ausführbaren Moduls.

<Note>
  Unter Windows ist diese Einschränkung darauf zurückzuführen, dass die Win32-Funktionen LoadLibrary und FreeLibrary nicht re-entrant sind.
</Note>

Während der Initialisierung setzt ABBYY FineReader Engine die LC\_CTYPE-Einstellung auf die Standardwerte des Betriebssystems zurück. Dies sollte berücksichtigt werden, wenn Ihre Anwendung von gebietsschemaabhängigen Diensten abhängt (insbesondere msvcrt.dll unter Windows).

Windows-Entwickler, die .NET verwenden, müssen sicherstellen, dass \[STAThread] (Single-Thread-Apartment-Modell) als Attribut für die Hauptfunktion der Anwendung angegeben wird; andernfalls kann ein Fehler auftreten:

```
[STAThread]
public static void Main()
{
  ...
}
```

Sie sollten eine gültige Customer Project ID als Eingabeparameter übergeben. Sie können jedoch auch festlegen, welche Lizenz für die Verarbeitung verwendet werden soll, indem Sie vor allen Verarbeitungsmethoden die [SetCurrentLicense](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/setcurrentlicense-method)-Methode des Engine-Objekts aufrufen. Verwenden Sie die [GetAvailableLicenses](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/getavailablelicenses-method)-Methode, um die Liste der verfügbaren aktivierten Lizenzen einzusehen, die Sie verwenden können, und die [CurrentLicense](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/properties)-Eigenschaft des Engine-Objekts, um zu prüfen, welche Lizenz aktuell ausgewählt ist.

<div id="samples">
  ## Beispiele
</div>

<Accordion title="C++ (COM)-Code">
  ```cpp theme={null}
  // Initialisieren Sie diese Variablen mit dem Pfad zu FREngine.dll, Ihrer FineReader Engine Customer Project ID
  // und gegebenenfalls mit dem Pfad zum Online-Lizenz-Token und zum Kennwort der Online-Lizenz
  wchar_t* FreDllPath;
  wchar_t* CustomerProjectId;
  wchar_t* LicensePath;  // wenn Sie keine Online-Lizenz verwenden, weisen Sie diesen Variablen leere Zeichenfolgen zu
  wchar_t* LicensePassword;
  // HANDLE für FREngine.dll
  static HMODULE libraryHandle = 0;
  // Globales FineReader Engine-Objekt.
  FREngine::IEnginePtr Engine;
  void LoadFREngine()
  {
      if( Engine != 0 ) {
      // Bereits geladen
      return;
      }
      // Erster Schritt: FREngine.dll laden
      if( libraryHandle == 0 ) {
          libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
          if( libraryHandle == 0 ) {
              throw L"Fehler beim Laden von ABBYY FineReader Engine";
          }
      }
      // Zweiter Schritt: das Engine-Objekt abrufen
      typedef HRESULT ( STDAPICALLTYPE* InitializeEngineFunc )( BSTR, BSTR, BSTR, BSTR, 
          BSTR, VARIANT_BOOL, FREngine::IEngine** );
      InitializeEngineFunc pInitializeEngine =
      ( InitializeEngineFunc )GetProcAddress( libraryHandle, "InitializeEngine" );
      if( pInitializeEngine == 0 || pInitializeEngine( CustomerProjectId, LicensePath, 
          LicensePassword, L"", L"", VARIANT_FALSE, &Engine ) != S_OK ) {
      UnloadFREngine();
      throw L"Fehler beim Laden von ABBYY FineReader Engine";
      }
  }
  ```
</Accordion>

<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
          // sowie ggf. mit dem Pfad zu Ihrer Online-Lizenz-Token-Datei und 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 Delegates konvertieren
              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-Lizenzdatei sowie 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;
              // Vor dem Aufruf von FreeLibrary alle Objekte 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>

Die Funktion wird in allen [Codebeispielen](/de/fine-reader/engine/guided-tour/samples) mit Ausnahme von [EnginesPool](/de/fine-reader/engine/guided-tour/samples#enginespool) (Win) verwendet.

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

[Lizenzierung](/de/fine-reader/engine/licensing)

[Module](/de/fine-reader/engine/licensing/modules)

[DeinitializeEngine](/de/fine-reader/engine/api-reference/functions/deinitializeengine-function)

[Verschiedene Möglichkeiten zum Laden des Engine-Objekts](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) (Win)