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

# Objeto BatchProcessor (interfaz IBatchProcessor)

> Objeto BatchProcessor (interfaz IBatchProcessor) en la API de ABBYY FineReader Engine — Este es un objeto procesador que convierte imágenes de entrada en páginas reconocidas (objetos FRPage).

<Note>
  Este objeto está implementado en FRE para Linux y Windows.
</Note>

Este objeto procesador convierte imágenes de entrada en páginas reconocidas (objetos [FRPage](/es/fine-reader/engine/api-reference/document-related-objects/frpage)).

Cuando se inicializa el procesador, se invocan y configuran procesos de reconocimiento asíncronos. A continuación, el procesador toma archivos de imagen de un origen de imágenes personalizado. Para cada página del archivo de imagen, se crea una nueva tarea de procesamiento y esta tarea se asigna a uno de los procesos de reconocimiento. Si todas las tareas de un archivo ya se han enviado a procesamiento, pero no todos los procesos de reconocimiento están ocupados, se toma el siguiente archivo de imagen de la cola de imágenes del origen y se envía a procesamiento. Esto continúa hasta que la primera página de imagen se ha convertido y entregado al usuario. Las páginas se devuelven al usuario en el mismo orden en que se obtuvieron del origen de imágenes.

Para organizar el procesamiento con Batch Processor, haga lo siguiente:

1. Implemente las interfaces [IImageSource](/es/fine-reader/engine/api-reference/batch-processor/iimagesource) e [IFileAdapter](/es/fine-reader/engine/api-reference/batch-processor/ifileadapter), que proporcionan acceso al origen de imágenes y a los archivos que contiene.
2. \[opcional] Implemente la interfaz [IAsyncProcessingCallback](/es/fine-reader/engine/api-reference/batch-processor/iasyncprocessingcallback) para gestionar el procesamiento. Los métodos de esta interfaz le permiten controlar errores y/o cancelar el procesamiento.
3. Llame al método [CreateBatchProcessor](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) del objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface) para obtener el objeto BatchProcessor.
4. Use la propiedad PageFlushingPolicy para establecer el modo de trabajo con las páginas del documento en memoria.
5. Llame al método Start para inicializar el procesador e invocar procesos de reconocimiento asíncronos. En este método, puede especificar el origen de las imágenes y la configuración de procesamiento.

* El objeto BatchProcessor no puede reutilizarse. Las llamadas repetidas al método Start provocarán errores.
* No cree ni use varios Batch Processors simultáneamente, ya que esto puede causar confusión en el procesamiento de páginas.

6. Llame al método GetNextProcessedPage en un bucle hasta que el método devuelva 0, lo que significa que ya no quedan más imágenes en el origen y que todas las imágenes procesadas ya se han devuelto al usuario.

<Warning>
  La página devuelta por el método GetNextProcessedPage existe hasta la siguiente llamada a este método. Por lo tanto, si quiere guardar esta página, debe hacerlo mediante los métodos del objeto [FRPage](/es/fine-reader/engine/api-reference/document-related-objects/frpage) o añadirla a un documento existente mediante el método [IFRDocument::AddPage](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addpage-method) ANTES de la siguiente llamada al método GetNextProcessedPage.
</Warning>

<div id="properties">
  ## Propiedades
</div>

| Nombre             | Tipo                                                                                                                                                                                                                      | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Application        | [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface), [de solo lectura](/es/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/working-with-properties#readonly_properties) | Devuelve el objeto Engine.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| PageFlushingPolicy | [PageFlushingPolicyEnum](/es/fine-reader/engine/api-reference/enumerations/pageflushingpolicyenum)                                                                                                                        | Especifica si los objetos [ImageDocument](/es/fine-reader/engine/api-reference/image-related-objects/imagedocument) y [Layout](/es/fine-reader/engine/api-reference/layout-related-objects/layout) de las páginas correspondientes deben descargarse y guardarse en disco si no existen referencias a ellos. <Note> En Linux, cuando el valor de esta propiedad se establece en PFP\_KeepInMemory, los documentos de imagen y los layouts de las páginas no utilizadas no se guardan en disco. </Note> <Note> En Windows, para descargar y guardar en disco los objetos ImageDocument y Layout de páginas individuales del documento, use el método [IFRPage::Flush](/es/fine-reader/engine/api-reference/document-related-objects/frpage/flush-method) para las páginas correspondientes. </Note> De forma predeterminada, esta propiedad es PFP\_Auto. |

<div id="methods">
  ## Métodos
</div>

| Nombre                                                                                                                  | Descripción                                                                                                                                                               |
| ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [GetNextProcessedPage](/es/fine-reader/engine/api-reference/batch-processor/batchprocessor/getnextprocessedpage-method) | Continúa el procesamiento en segundo plano hasta que esté disponible la siguiente imagen reconocida.                                                                      |
| [ProcessPageAsync](/es/fine-reader/engine/api-reference/batch-processor/batchprocessor/processpageasync-method)         | Le permite repetir el procesamiento de una página con otros parámetros. La página puede colocarse al principio o al final de la cola de procesamiento.                    |
| [Start](/es/fine-reader/engine/api-reference/batch-processor/batchprocessor/start-method)                               | Prepara el Batch Processor para su uso. El método invoca procesos de reconocimiento asíncronos, especifica el origen de las imágenes y la configuración de procesamiento. |

<div id="output-parameter">
  ## Parámetro de salida
</div>

Este objeto es el parámetro de salida del método [CreateBatchProcessor](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) del objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface).

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

<Accordion title="Código C#">
  ```csharp theme={null}
  // Crear el Batch Processor
  FREngine.IBatchProcessor batchProcessor = engine.CreateBatchProcessor();
  FREngine.IFRDocument document = engine.CreateFRDocument();
  // Inicializar el procesador
  FREngine.IImageSource imageSource = new CImageSource; // el usuario implementa la clase
  batchProcessor.PageFlushingPolicy = FREngine.PageFlushingPolicyEnum.PFP_KeepInMemory;
  batchProcessor.Start( imageSource, null, null, null );
  // Iniciar el procesamiento
  while( true ) {
   FREngine.IFRPage page = batchProcessor.GetNextProcessedPage();
   if( page == null ) {
    break; // no hay más páginas; fin del proceso
   }
   // hacer algo con la página
   ...
   document.AddPage( page );
  }
  ```
</Accordion>

Este objeto se utiliza en los siguientes ejemplos de código: [BatchProcessing](/es/fine-reader/engine/guided-tour/samples#batchprocessing) y en las siguientes herramientas de demostración: [BatchProcessingRecognition](/es/fine-reader/engine/guided-tour/samples#batchprocessingrecognition).

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

[Procesamiento en paralelo con ABBYY FineReader Engine](/es/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing)

[IImageSource](/es/fine-reader/engine/api-reference/batch-processor/iimagesource)