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

# DeinitializeEngine-Funktion

> DeinitializeEngine-Funktion in der API von ABBYY FineReader Engine — Diese Funktion deinitialisiert ABBYY FineReader Engine.

Diese Funktion deinitialisiert ABBYY FineReader Engine. Sie muss zum Deinitialisieren des mit der Funktion [InitializeEngine](/de/fine-reader/engine/api-reference/functions/initializeengine-function) abgerufenen Engine-Objekts aufgerufen werden. Vor der Deinitialisierung müssen Sie alle Referenzen auf FineReader Engine-Objekte freigeben.

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

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

```cpp theme={null}
HRESULT __stdcall DeinitializeEngine();
```

### C\#

```csharp theme={null}
int DeinitializeEngine();
```

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

```csharp theme={null}
Private Declare Function DeinitializeEngine Lib "FREngine.dll" () As Integer
```

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

Diese Funktion gibt E\_FAIL zurück, wenn nicht alle Objekte freigegeben sind. In diesem Fall können Sie mit der Methode [IEngine::StartLogging](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/startlogging-method) die Liste der nicht freigegebenen Objekte abrufen. Die Funktion kann die [Standard-Rückgabewerte von ABBYY FineReader Engine-Funktionen](/de/fine-reader/engine/api-reference/return-codes) zurückgeben.

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

<Warning>
  Initialisieren und deinitialisieren Sie ABBYY FineReader Engine weder an den Einstiegspunkten anderer dynamischer Bibliotheken noch in Konstruktoren und Destruktoren statischer und globaler Objekte, die in dynamischen Bibliotheken implementiert sind, da diese an den Einstiegspunkten der dynamischen Bibliotheken aufgerufen werden.
</Warning>

ABBYY FineReader Engine sollte an anderer Stelle initialisiert und deinitialisiert werden, zum Beispiel in der Funktion `main` oder `WinMain` eines ausführbaren Moduls.

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

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

<Accordion title="C++ (COM)-Code">
  ```cpp theme={null}
  IEngine* FineReaderEngine = 0;
  HMODULE EngineLibraryHandle = 0;
  static HRESULT deinitializeEngine()
  {
   // Engine-Objekt freigeben
   if( FineReaderEngine != 0 ) {
    FineReaderEngine->Release();
    FineReaderEngine = 0;
   }
   // DeinitializeEngine aufrufen
   typedef HRESULT (STDAPICALLTYPE* DeinitializeEngineFunc)();
   DeinitializeEngineFunc pDeinitializeEngine =
    (DeinitializeEngineFunc)GetProcAddress( EngineLibraryHandle, "DeinitializeEngine" );
   if( pDeinitializeEngine == 0 || FAILED( pDeinitializeEngine() ) ) {
    setLastErrorInfo( L"Can't unload FineReader Engine." );
    return E_UNEXPECTED;
   }
   return S_OK;
  }
  ```
</Accordion>

<Accordion title="C#-Code">
  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      // FineReader Engine entladen
      public void Dispose()
      {
          if (engine == null)
          {
              // Engine wurde nicht geladen
              return;
          }
          engine = null;
          // Alle Objekte vor dem FreeLibrary-Aufruf löschen
          GC.Collect();
          GC.WaitForPendingFinalizers();
          GC.Collect();
          int hresult = deinitializeEngine();
   
          hresult = dllCanUnloadNow();
          if (hresult == 0)
          {
              FreeLibrary(dllHandle);
          }
          dllHandle = IntPtr.Zero;
          initializeEngine = null;
          deinitializeEngine = null;
          dllCanUnloadNow = null;
          // Ausnahme nach der Bereinigung auslösen
          Marshal.ThrowExceptionForHR(hresult);
      }
      // Kernel32.dll-Funktionen
      [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);
      // FREngine.dll-Funktionen
      [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
      private delegate int InitializeEngine( string customerProjectId, string LicensePath, string LicensePassword, , , , 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 zu 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) außer dem Windows-Beispiel [EnginesPool](/de/fine-reader/engine/guided-tour/samples#enginespool) verwendet.

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

[InitializeEngine](/de/fine-reader/engine/api-reference/functions/initializeengine-function)

[Different Ways to Load the Engine Object](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine)