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

# Fonction DeinitializeEngine

> Fonction DeinitializeEngine dans l’API ABBYY FineReader Engine — Cette fonction désinitialise ABBYY FineReader Engine.

Cette fonction désinitialise ABBYY FineReader Engine. Elle doit être appelée pour désinitialiser l’objet Engine obtenu à l’aide de la fonction [InitializeEngine](/fr/fine-reader/engine/api-reference/functions/initializeengine-function). Avant la désinitialisation, vous devez libérer toutes les références aux objets FineReader Engine.

<div id="syntax">
  ## Syntaxe
</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">
  ## Valeurs de retour
</div>

Cette fonction renvoie E\_FAIL si tous les objets n’ont pas été libérés. Dans ce cas, vous pouvez obtenir la liste des objets qui n’ont pas été libérés à l’aide de la méthode [IEngine::StartLogging](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/startlogging-method). La fonction peut également renvoyer les [valeurs de retour standard des fonctions ABBYY FineReader Engine](/fr/fine-reader/engine/api-reference/return-codes).

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

<Warning>
  N’initialisez pas et ne désinitialisez pas ABBYY FineReader Engine dans les points d’entrée d’autres bibliothèques dynamiques, ni dans les constructeurs et destructeurs d’objets statiques et globaux implémentés dans des bibliothèques dynamiques, car ceux-ci sont appelés aux points d’entrée des bibliothèques dynamiques.
</Warning>

L’utilisateur doit initialiser et désinitialiser ABBYY FineReader Engine ailleurs. Par exemple, dans la fonction main ou WinMain d’un module exécutable.

<Note>
  Sous Windows, cette restriction est due au fait que les fonctions Win32 LoadLibrary et FreeLibrary ne sont pas réentrantes.
</Note>

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

<Accordion title="Code C++ (COM)">
  ```cpp theme={null}
  IEngine* FineReaderEngine = 0;
  HMODULE EngineLibraryHandle = 0;
  static HRESULT deinitializeEngine()
  {
   // Libérer l’objet Engine
   if( FineReaderEngine != 0 ) {
    FineReaderEngine->Release();
    FineReaderEngine = 0;
   }
   // Appel de DeinitializeEngine
   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="Code C#">
  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      // Décharger FineReader Engine
      public void Dispose()
      {
          if (engine == null)
          {
              // L’objet Engine n’a pas été chargé
              return;
          }
          engine = null;
          // Supprimer tous les objets avant l’appel à FreeLibrary
          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;
          // lever une exception après le nettoyage
          Marshal.ThrowExceptionForHR(hresult);
      }
      // Fonctions de 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);
      // Fonctions de FREngine.dll
      [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();
      // variables privées
      private FREngine.IEngine engine = null;
      // Handle de FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

La fonction est utilisée dans tous les [exemples de code](/fr/fine-reader/engine/guided-tour/samples), à l’exception de l’exemple Windows [EnginesPool](/fr/fine-reader/engine/guided-tour/samples#enginespool).

<div id="see-also">
  ## Voir aussi
</div>

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

[Différentes façons de charger l'objet Engine](/fr/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine)