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

# Método AddImageFileFromMemory del objeto FRDocument

> Método AddImageFileFromMemory del objeto FRDocument en la API de ABBYY FineReader Engine: abre un archivo de imagen desde la memoria global (cargado previamente por el usuario) y añade sus páginas al documento.

Este método abre un archivo de imagen desde la memoria global, donde el usuario lo había cargado previamente, y añade al documento las páginas correspondientes al archivo abierto.

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

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

Linux y macOS

```cpp theme={null}
HRESULT  AddImageFileFromMemory(
  void*                   DataPtr,
  __int64                 DataSize,
  IImagePasswordCallback* Callback,
  IPrepareImageMode*      PrepareMode,
  IIntsCollection*        PageIndices,
  BSTR                    FileName
);
```

Windows

```cpp theme={null}
HRESULT  AddImageFileFromMemory(
  __int64                 HGlobal,
  IImagePasswordCallback* Callback,
  IPrepareImageMode*      PrepareMode,
  IIntsCollection*        PageIndices,
  BSTR                    FileName
);
```

### C\#

```csharp theme={null}
void AddImageFileFromMemory(
  Int64                  HGlobal,
  IImagePasswordCallback Callback,
  IPrepareImageMode       PrepareMode,
  IIntsCollection         PageIndices,
  string                 FileName
);
```

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

```vb theme={null}
Sub AddImageFileFromMemory( _
  HGlobal As Int64, _
  Callback As IImagePasswordCallback, _
  [PrepareMode As IPrepareImageMode = Nothing], _
  [PageIndices As IIntsCollection = Nothing], _
  [FileName As String = "0"] _
)
```

<div id="parameters">
  ## Parámetros
</div>

DataPtr

\[in] Linux: Especifica la dirección del bloque de memoria que contiene el archivo de imagen.

DataSize

\[in] Linux: Especifica el tamaño de la imagen cargada en memoria.

HGlobal

\[in] macOS y Windows: Especifica el handle HGLOBAL del bloque de memoria que contiene el archivo de imagen. El handle se pasa como [\_\_int64](/es/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/working-with-properties). Este handle debe ser válido.

Callback

\[in] Esta variable hace referencia a la interfaz del objeto implementado por el usuario del tipo [ImagePasswordCallback](/es/fine-reader/engine/api-reference/image-related-objects/iimagepasswordcallback), que se utiliza para atender posibles solicitudes de contraseña para acceder a imágenes en formato PDF. Este parámetro es opcional y puede ser 0; en ese caso, no se podrán procesar archivos protegidos con contraseña.

PrepareMode

\[in] Hace referencia al objeto [PrepareImageMode](/es/fine-reader/engine/api-reference/image-related-objects/prepareimagemode), que especifica cómo se preprocesará una imagen al abrirla. Este parámetro es opcional y puede ser 0; en ese caso, se utilizan los parámetros predeterminados o, si se ha cargado un [perfil](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles), los parámetros establecidos por ese perfil.

PageIndices

\[in] Este parámetro hace referencia al objeto [IntsCollection](/es/fine-reader/engine/api-reference/supplementary-objects-and-methods/intscollection), que especifica los índices de las páginas que deben añadirse al documento. Tenga en cuenta que no se permiten índices repetidos. Para añadir la misma página varias veces, llame a este método varias veces.<br />Este parámetro es opcional y puede ser 0; en ese caso, se añadirán al documento todas las páginas del archivo abierto.

FileName

\[in] Especifica el nombre del archivo de imagen. Esta información se utiliza para determinar el formato del archivo, si no se especifica explícitamente, y para los mensajes de error. Este parámetro es opcional y puede ser 0.

Para abrir formatos ofimáticos (solo en Linux y Windows), pase el nombre del documento con su extensión.

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

Este método no tiene valores de retorno específicos. Devuelve 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>

* Los archivos en formato SVG no se pueden abrir desde memoria.

* Al abrir un archivo PDF Portfolio con este método, su portada siempre se incluye en el archivo de salida.

* Este método puede notificar eventos a los listeners asociados a la interfaz IConnectionPointContainer del objeto [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument).

* Para Linux y Windows:
  * Si su licencia incluye el módulo [Office Formats Opening](/es/fine-reader/engine/licensing/modules#officeformatsopening), también puede usar este método para abrir documentos digitales en [formatos compatibles](/es/fine-reader/engine/specifications/supported-digital-document-input-formats).
  * Este método no funciona si el Engine se carga como un servidor fuera del proceso en Linux o si el objeto se crea mediante el objeto [OutprocLoader](/es/fine-reader/engine/api-reference/engine-loaders/outprocloader) en Windows. En ese caso, considere usar el método [AddImageFileFromStream](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilefromstream-method) (Win).
  * Según el valor de la propiedad [IEngine::MultiProcessingParams](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#multiprocessingparams), ABBYY FineReader Engine puede distribuir la apertura de documentos de varias páginas entre los núcleos de CPU.

* En Windows, este método no admite la apertura de archivos compatibles con WIC.

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

<Accordion title="Código C#">
  ```csharp theme={null}
  // Este ejemplo muestra cómo cargar un archivo de imagen en memoria
  // y luego agregarlo a FineReader Engine para su procesamiento
  ...
  // En este ejemplo de código, usamos el espacio de nombres System.IO para trabajar con un archivo en memoria
  using System.IO;
  // y el espacio de nombres System.Runtime.InteropServices para trabajar con bloques de memoria
  using System.Runtime.InteropServices;
  ...
  // Suponemos que ya hemos creado el objeto Engine
  // Crear documento
  FREngine.IFRDocument document = engine.CreateFRDocument();
  // Imagen de origen
  string imagePath = "D:\\Demo.tif";
  FileInfo file = new FileInfo(imagePath);
  // Tamaño de la imagen de origen
  long len = file.Length;
  // Abrir la imagen
  BinaryReader br = new BinaryReader(File.Open(imagePath, FileMode.Open));
  // Leer el número especificado de bytes del flujo actual y guardarlo en una matriz de bytes
  byte[] byteArray = br.ReadBytes((int)len);
  // Asignar un bloque de memoria
  IntPtr handle = Marshal.AllocHGlobal((int)len);
  // Copiar datos desde un puntero de memoria no administrada a una matriz administrada de enteros con signo de 32 bits
  Marshal.Copy(byteArray, 0, handle, (int)len);
  // Agregar una imagen desde la memoria al documento
  document.AddImageFileFromMemory((Int64)handle, null, null, null, "Demo.tif");
  // Liberar la memoria previamente asignada de la memoria no administrada del proceso
  Marshal.FreeHGlobal(handle);
  // Reconocer el documento
  document.Process(null);
  ```
</Accordion>

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

[FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument)