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

# Función DeinitializeEngine

> Función DeinitializeEngine en la API de ABBYY FineReader Engine — Esta función desinicializa ABBYY FineReader Engine.

Esta función desinicializa ABBYY FineReader Engine. Se debe llamar a esta función para desinicializar el objeto Engine obtenido mediante la función [InitializeEngine](/es/fine-reader/engine/api-reference/functions/initializeengine-function). Antes de la desinicialización, debe liberar todas las referencias a los objetos de ABBYY FineReader Engine.

<div id="syntax">
  ## Sintaxis
</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">
  ## Valores de retorno
</div>

Esta función devuelve E\_FAIL si no se han liberado todos los objetos. En ese caso, puede obtener la lista de los objetos no liberados mediante el método [IEngine::StartLogging](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/startlogging-method). La función puede devolver los [valores de retorno estándar de las funciones de ABBYY FineReader Engine](/es/fine-reader/engine/api-reference/return-codes).

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

<Warning>
  No inicialice ni desinicialice ABBYY FineReader Engine en los puntos de entrada de otras bibliotecas dinámicas, ni tampoco en los constructores y destructores de objetos estáticos y globales implementados en bibliotecas dinámicas, ya que se ejecutan en los puntos de entrada de estas bibliotecas.
</Warning>

El usuario debe inicializar y desinicializar ABBYY FineReader Engine en otro punto. Por ejemplo, en la función `main` o `WinMain` de un módulo ejecutable.

<Note>
  En Windows, esta restricción se debe a que las funciones `LoadLibrary` y `FreeLibrary` de Win32 no son reentrantes.
</Note>

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

<Accordion title="Código C++ (COM)">
  ```cpp theme={null}
  IEngine* FineReaderEngine = 0;
  HMODULE EngineLibraryHandle = 0;
  static HRESULT deinitializeEngine()
  {
   // Liberar el objeto Engine
   if( FineReaderEngine != 0 ) {
    FineReaderEngine->Release();
    FineReaderEngine = 0;
   }
   // Llamar a DeinitializeEngine
   typedef HRESULT (STDAPICALLTYPE* DeinitializeEngineFunc)();
   DeinitializeEngineFunc pDeinitializeEngine =
    (DeinitializeEngineFunc)GetProcAddress( EngineLibraryHandle, "DeinitializeEngine" );
   if( pDeinitializeEngine == 0 || FAILED( pDeinitializeEngine() ) ) {
    setLastErrorInfo( L"No se puede descargar FineReader Engine." );
    return E_UNEXPECTED;
   }
   return S_OK;
  }
  ```
</Accordion>

<Accordion title="Código C#">
  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      // Descargar FineReader Engine
      public void Dispose()
      {
          if (engine == null)
          {
              // Engine no se cargó
              return;
          }
          engine = null;
          // Eliminar todos los objetos antes de llamar a 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;
          // Generar una excepción después de la limpieza
          Marshal.ThrowExceptionForHR(hresult);
      }
      // Funciones 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);
      // Funciones 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 privadas
      private FREngine.IEngine engine = null;
      // Identificador de FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

La función se usa en todos los [ejemplos de código](/es/fine-reader/engine/guided-tour/samples) excepto en el ejemplo de Windows [EnginesPool](/es/fine-reader/engine/guided-tour/samples#enginespool).

<div id="see-also">
  ## Consulte también
</div>

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

[Diferentes formas de cargar el objeto Engine](/es/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine)