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

> Función InitializeEngine en la API de ABBYY FineReader Engine — Esta función se utiliza para obtener un puntero a la interfaz IEngine.

Esta función se utiliza para obtener un puntero a la interfaz IEngine. Toma como parámetro de entrada el número Customer Project ID, que es una cadena alfanumérica común a todas las licencias Developer y Runtime que utiliza su proyecto.

<Note>
  Para los usuarios de Linux y Windows, esta función facilita el acceso al licenciamiento en línea, si es necesario, y también permite especificar algunos parámetros adicionales durante la inicialización.
</Note>

<div id="syntax">
  ## Sintaxis
</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">
  ## Parámetros
</div>

**CustomerProjectID**

\[in] Una cadena que contiene el Customer Project ID.

<Note>
  Durante la inicialización de la biblioteca, se busca en la lista de todas las licencias disponibles una licencia de Developer o Runtime que corresponda a este Customer Project ID. Si no se encuentra ninguna licencia correspondiente, se producirá un error para la última licencia comprobada. No obstante, puede pasar 0 para este parámetro y seleccionar la licencia más adelante, llamando al método [IEngine::SetCurrentLicense](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/setcurrentlicense-method) antes de cualquier otro método de la biblioteca.
</Note>

**LicensePath**

\[in] El nombre completo del archivo de la licencia en línea. Si no usa una licencia en línea, pase una cadena vacía "" o un puntero Null. Debe pasarse una cadena vacía "" o un puntero Null.

Para los usuarios de macOS: Este parámetro está reservado para uso futuro.

**LicensePassword**

\[in] La contraseña de la licencia en línea. Si no usa una licencia en línea, pase una cadena vacía "" o un puntero Null.

Para los usuarios de macOS: Este parámetro está reservado para uso futuro.

**FREngineDataFolder**

\[in] Contiene la ruta a la carpeta en la que ABBYY FineReader Engine debe almacenar los datos específicos del usuario.

De forma predeterminada, para la instalación automática:

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

> Además, para Linux y Windows:

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

> Si establece el valor de FREngineDataFolder, toda la información auxiliar se escribirá en una nueva carpeta de datos.

Puede que necesite cambiar el valor predeterminado, por ejemplo, si la configuración del idioma de la interfaz de su aplicación debe ser distinta de la de otras aplicaciones que usan FineReader Engine. Después de cambiar el valor predeterminado, asegúrese de tener permisos de control total sobre la nueva carpeta de datos.

**FREngineTempFolder**

\[in] Contiene la ruta a la carpeta para los archivos temporales de ABBYY FineReader Engine. De forma predeterminada, es la carpeta %TEMP%\ABBYY FineReader Engine 12.

**IsSharedCPUCoresMode**

\[in] Especifica si los núcleos de CPU deben usarse en modo compartido. Hay dos modos de uso de los núcleos de CPU: separado y compartido. En el modo separado, ABBYY FineReader Engine no usa más procesos de los permitidos por la licencia. En el modo compartido, puede ejecutarse cualquier número de procesos, pero todos estos procesos usarán solo los núcleos de CPU especificados por la propiedad [IMultiProcessingParams::SharedCPUCoresMask](/es/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams#sharedcpucoresmask).

<Note>
  Este parámetro se omite en ABBYY FineReader Engine for Windows.
</Note>

**Engine**

\[out, retval] Un puntero a una variable de puntero IEngine\* que recibe el puntero de interfaz al objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface) resultante.

<div id="return-values">
  ## Valores de retorno
</div>

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>

Solo se puede crear un objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface) con esta función en una única instancia de la aplicación que usa ABBYY FineReader Engine. Los intentos posteriores de crear el objeto Engine devolverán el mismo objeto.

<Warning>
  La creación del objeto Engine puede llevar un tiempo considerable. Durante la inicialización, el motor carga la biblioteca principal que se indica a continuación, junto con un gran número de bibliotecas dinámicas adicionales:
</Warning>

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

<Note>
  Cuando se usa una licencia de red, la inicialización en Linux y Windows también puede tardar más debido a la comunicación con el servidor de licencias. Asegúrese de que la conexión de red cumpla los requisitos de rendimiento; se recomienda un ancho de banda de al menos 100 Kb/s para un funcionamiento fiable con una licencia de red.
</Note>

Es posible crear y ejecutar el objeto Engine en un sistema multiprocesador, pero solo puede haber un objeto Engine por proceso. Una segunda llamada a InitializeEngine dentro del mismo proceso devolverá una referencia al objeto existente. Por lo tanto, debe crear un objeto Engine independiente para cada proceso llamando a la función InitializeEngine.

<Note>
  En implementaciones de ABBYY FineReader Engine for Windows que impliquen sistemas multiprocesador, puede resultarle útil consultar [otros métodos](/es/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) para cargar el objeto Engine.
</Note>

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

El usuario debe inicializar y desinicializar ABBYY FineReader Engine en otro lugar. 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 Win32 LoadLibrary y FreeLibrary no son reentrantes.
</Note>

Durante la inicialización, ABBYY FineReader Engine restablecerá la configuración de LC\_CTYPE a los valores predeterminados del sistema operativo. Esto debe tenerse en cuenta si la aplicación depende de servicios dependientes de la configuración regional (en concreto, msvcrt.dll en Windows).

Los desarrolladores de Windows que usan .NET deben asegurarse de especificar \[STAThread] (modelo de apartamento de un solo hilo) como atributo en la función principal de la aplicación; de lo contrario, puede producirse un error:

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

Debe proporcionar un número de Customer Project ID válido como parámetro de entrada. No obstante, puede elegir la licencia que se utilizará para el procesamiento llamando al método [SetCurrentLicense](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/setcurrentlicense-method) del objeto Engine antes de cualquiera de los métodos de procesamiento. Use el método [GetAvailableLicenses](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/getavailablelicenses-method) para consultar la lista de licencias activadas disponibles que puede usar, y la propiedad [CurrentLicense](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/properties) del objeto Engine para comprobar qué licencia está seleccionada actualmente para su uso.

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

<Accordion title="Código C++ (COM)">
  ```cpp theme={null}
  // Inicialice estas variables con la ruta de acceso a FREngine.dll, el Customer Project ID de FineReader Engine
  // y, si corresponde, la ruta al token de la licencia en línea y la contraseña de la licencia en línea
  wchar_t* FreDllPath;
  wchar_t* CustomerProjectId;
  wchar_t* LicensePath;  // si no usa una licencia en línea, asigne cadenas vacías a estas variables
  wchar_t* LicensePassword;
  // HANDLE de FREngine.dll
  static HMODULE libraryHandle = 0;
  // Objeto global de FineReader Engine.
  FREngine::IEnginePtr Engine;
  void LoadFREngine()
  {
      if( Engine != 0 ) {
      // Ya se cargó
      return;
      }
      // Primer paso: cargar FREngine.dll
      if( libraryHandle == 0 ) {
          libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
          if( libraryHandle == 0 ) {
              throw L"Error al cargar ABBYY FineReader Engine";
          }
      }
      // Segundo paso: obtener el objeto Engine
      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"Error al cargar ABBYY FineReader Engine";
      }
  }
  ```
</Accordion>

<Accordion title="Código C#">
  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      public EngineLoader()
      {
          // Inicialice estas variables con la ruta completa a FREngine.dll, su Customer Project ID
          // y, si corresponde, la ruta al archivo de token de la licencia en línea y la contraseña de la licencia en línea
          string enginePath = "";
          string customerProjectId = "";
          string licensePath = "";
          string licensePassword = "";
          // Cargue la biblioteca FREngine.dll
          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");
              }
              // Convierta los punteros en delegados
              initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  initializeEnginePtr, typeof(InitializeEngine));
              deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  deinitializeEnginePtr, typeof(DeinitializeEngine));
              dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                  dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
              // Llame a la función InitializeEngine 
              // y pase la ruta al archivo de licencia en línea y la contraseña de la licencia en línea
              int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                  "", "", false, ref engine);
              Marshal.ThrowExceptionForHR(hresult);
          }
          catch (Exception)
          {
              // Libere la biblioteca FREngine.dll
              engine = null;
              // Elimine todos los objetos antes de llamar a FreeLibrary
              GC.Collect();
              GC.WaitForPendingFinalizers();
              GC.Collect();
              FreeLibrary(dllHandle);
              dllHandle = IntPtr.Zero;
              initializeEngine = null;
              deinitializeEngine = null;
              dllCanUnloadNow = null;
              throw;
          }
      }
      // 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, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, 
          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;
      // Handle 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 [EnginesPool](/es/fine-reader/engine/guided-tour/samples#enginespool) (Win).

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

[Gestión de licencias](/es/fine-reader/engine/licensing)

[Módulos](/es/fine-reader/engine/licensing/modules)

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

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