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

# Scripts de ejemplo para la exportación

> Scripts de ejemplo de exportación para ABBYY FlexiCapture: leer valores de campos durante la exportación, guardar imágenes de páginas, exportar tablas y escribir controladores de resultados de exportación.

Los siguientes ejemplos muestran tareas habituales de exportación en ABBYY FlexiCapture, como leer valores de campos, guardar imágenes de páginas, exportar tablas y gestionar resultados de exportación. La mayoría de los ejemplos se proporcionan tanto en VBScript como en JScript, y algunos incluyen un componente externo escrito en Visual Basic o C#.

<div id="get-field-values-during-export">
  ## Obtener valores de campo durante la exportación
</div>

Este ejemplo obtiene el valor de un campo durante la exportación. Puede usar este valor para dar nombre a los archivos en los que se exportan las imágenes o los datos. Si el documento no contiene el campo, se produce un error.

La estructura del documento que se va a exportar:

```text theme={null}
Section 1
    Field1
    …
    Group1
        Field2
        …
    …
    FieldN
Section 2
    Field1
    …
    FieldK
```

El siguiente ejemplo de VBScript obtiene los valores de los campos:

```vb theme={null}
Dim field1Value, field2Value

' Obtiene el valor de Field1 en Section 1
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
    field1Value = me.Field( "Section 1\Field1" ).Value
end if

' Obtiene el valor de Field2 en Group1 en Section 1
if Not IsNull( me.FIELD( "Section 1\Group1\Field2" ).Value ) then
    field2Value = me.Field( "Section 1\Group1\Field2" ).Value
end if

' Obtiene el valor de Field1 en Section 1 si la sección tiene múltiples instancias
if Not me.Field( "Section 1" ).Items Is Nothing then
    dim curPage
    for each curPage in me.Field( "Section 1" ).Items
        if Not curPage.Children Is Nothing then
            dim curField
            for each curField in curPage.Children
                if curField.Name = "Field1" And Not IsNull( curField.Value )  then
                    field1Value = curField.Value
                    exit for
                end if
            next
        end if
    next
end if
```

El siguiente ejemplo de JScript hace lo mismo:

```javascript theme={null}
// Obtiene el valor de Field1 en Section 1
if( Field("Section 1\\Field1").Value != null ) {
    var field1Value = Field("Section 1\\Field1").Value;
}

// Obtiene el valor de Field2 en Group1 en Section 1
if( Field("Section 1\\Group1\\Field2").Value != null ) {
    var field2Value = Field("Section 1\\Group1\\Field2").Value;
}

// Obtiene el valor de Field1 en Section 1 si la sección tiene múltiples instancias
if( Field( "Section 1" ).Items != null ) {
    var i, j;
    for( i = 0; i < Field( "Section 1" ).Items.Count; i++ ) {
        var curPage = Field( "Section 1" ).Items.Item( i );
        if( curPage.Children != null ) {
            for( j = 0; j < curPage.Children.Count; j++ ) {
                var curField = curPage.Children.Item( j );
                if( curField.Name == "Field1" && curField.Value != null ) {
                    var field1Value  = curField.Value;
                    break;
                }
            }
        }
    }
}
```

<div id="export-page-images">
  ## Exportar imágenes de páginas
</div>

Este ejemplo exporta imágenes de todas las páginas del documento con el formato de archivo, el esquema de color y la resolución elegidos. Cada página se guarda en un archivo independiente.

Los archivos de este ejemplo se llaman `page1.tif`, `page2.tif`, etcétera. Puede cambiar la forma de asignar nombres a los archivos; por ejemplo, basar los nombres de archivo en el valor de un campo.

El siguiente ejemplo de VBScript exporta las imágenes de las páginas:

```vb theme={null}
dim fso, folderName
set fso = CreateObject("Scripting.FileSystemObject")
folderName = "d:\ExportImages"

if Not fso.FolderExists( folderName ) then
    fso.CreateFolder folderName
end if

dim imageOptions
set imageOptions = FCTools.NewImageSavingOptions
imageOptions.Format = "tif"
imageOptions.ColorType = "BlackAndWhite"
imageOptions.Resolution = 600
dim i

for i = 0 to me.Pages.Count - 1
    dim fileName
    ' Establece el nombre y la extensión deseados para el archivo según el formato seleccionado
    fileName = fso.BuildPath( folderName, "page" & (i+1) & ".tif" )
    me.Pages.Item(i).SaveAs fileName, imageOptions
next
```

El siguiente ejemplo de JScript hace lo mismo:

```javascript theme={null}
var fso = new ActiveXObject("Scripting.FileSystemObject");
var folderName = "d:\\ExportImages";

if( !fso.FolderExists( folderName ) ) {
    fso.CreateFolder( folderName );
}

var imageOptions = FCTools.NewImageSavingOptions();
imageOptions.Format = "tif";
imageOptions.ColorType = "BlackAndWhite";
imageOptions.Resolution = 600;
var i;

for( i = 0; i < Pages.Count; i++ ) {
    // Establece el nombre y la extensión deseados para el archivo según el formato seleccionado
    var fileName = fso.BuildPath( folderName, "page" + (i+1) + ".tif" );
    Pages.Item(i).SaveAs( fileName, imageOptions );
}
```

<div id="export-a-table">
  ## Exportar una tabla
</div>

Este ejemplo exporta una tabla a un archivo de texto `*.txt`.

El siguiente ejemplo de VBScript exporta la tabla:

```vb theme={null}
dim fso, txtFile, fileName
set fso = CreateObject("Scripting.FileSystemObject")
fileName = "d:\TestExportTable.txt"

set txtFile = fso.CreateTextFile( fileName, true )
txtFile.WriteLine "Table"
dim table, row, cell, rowNumber

set table = me.Field("Page 1\Table")
rowNumber = 1

for each row in table.Items
    txtFile.WriteLine "RowNumber = " & rowNumber
    for each cell in row.Children
        txtFile.Write cell.Value & "   "
    next
    txtFile.WriteBlankLines 1
    rowNumber = rowNumber + 1
next

txtFile.Close
set txtFile = nothing
set fso = nothing
```

El siguiente ejemplo en JScript hace lo mismo:

```javascript theme={null}
var fso, txtFile, fileName;
fso = new ActiveXObject("Scripting.FileSystemObject");
fileName = "d:\\TestExportTable1.txt";

txtFile = fso.CreateTextFile( fileName, true );
txtFile.WriteLine( "Table" );

var table, i, j;
table = Field("Page 1\\Table");
var rows = table.Items;

for( i = 0; i < rows.Count; i++ ) {
    txtFile.WriteLine( "RowNumber = " + ( i+1 ) );
    var cells = rows.Item(i).Children;
    for( j = 0; j < cells.Count; j++ ) {
        txtFile.Write( cells.Item(j).Value + "   " );
    }
    txtFile.WriteBlankLines(1);
}
txtFile.Close();
```

<div id="export-a-document-of-any-nesting-level">
  ## Exportar un documento con cualquier nivel de anidamiento
</div>

Este ejemplo exporta campos de un documento con cualquier nivel de anidamiento mediante funciones personalizadas del módulo de exportación global. Para exportar campos de documento con anidamiento variable, utilice un componente COM externo, como se muestra en el siguiente ejemplo.

<div id="core-export-code">
  ### Código principal de exportación
</div>

Añade esta llamada al script de exportación del documento.

El siguiente VBScript llama a la función de exportación:

```vb theme={null}
Export.ExportDocument me, FCTools
```

La llamada equivalente de JScript:

```javascript theme={null}
Export.ExportDocument( this, FCTools );
```

<div id="global-export-module-functions">
  ### Funciones del módulo de exportación global
</div>

El módulo de exportación global define las siguientes funciones.

La implementación en VBScript:

```vb theme={null}
' El procedimiento realiza la exportación: crea una carpeta de exportación y
' guarda en ella los archivos de imagen de página, el archivo de texto con los campos del documento
' e información sobre el documento
Sub ExportDocument(ByRef docObj, ByRef FCTools)
    Dim folderName
    Dim txtFile, fileName
    Dim fso

    On Error Resume Next
    set fso = CreateObject("Scripting.FileSystemObject")
    ' creación de la carpeta de exportación
    folderName = CreateExportFolder(docObj.DefinitionName, fso)

    if Err.Number <> 0 then
        docObj.Action.Succeeded = false
        docObj.Action.ErrorMessage = "Error during create export folder: " + Err.Description
        Err.Clear
        Exit Subub
    End if

    ' exportación de imágenes
    ExportImages docObj, FCTools, folderName, fso
    if Err.Number <> 0 then
        docObj.Action.Succeeded = false
        docObj.Action.ErrorMessage = "Error during export images: " + Err.Description
        Err.Clear
        Exit Sub
    End if

    ' creación del archivo de texto
    fileName = fso.BuildPath(folderName, "doc.txt")
    Set txtFile = fso.CreateTextFile(fileName, True)

    ' exportación de información sobre el documento
    ExportDocInfo docObj, txtFile

    ' exportación de campos
    txtFile.WriteLine "Fields:"
    ExportFields docObj.Children, txtFile, ""
    txtFile.Close

    if Err.Number <> 0 then
        docObj.Action.Succeeded = false
        docObj.Action.ErrorMessage = "Error during export data: " + Err.Description
        Err.Clear
        Exit Sub
    End if

    Set txtFile = Nothing
    Set fso = Nothing
End Sub

' Función de exportación de imágenes
Function ExportImages( ByRef docObj, ByRef FCTools, ByVal exportFolder, ByRef fso )
    Dim pages, page, imageOptions
    Dim fileName, pageNum

    ' especificación de la configuración de exportación
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "bmp"
    imageOptions.ColorType = "FullColor"
    imageOptions.Resolution = 100

    ' exportación página por página
    Set pages = docObj.Pages
    pageNum = 1

    For Each page In pageses
        fileName = fso.BuildPath(exportFolder, "page" & pageNum & ".bmp")
        page.SaveAs fileName, imageOptions
        pageNum = pageNum + 1
    Next
End Function

' El procedimiento que exporta información sobre el documento
Sub ExportDocInfo(ByRef docObj, ByRef txtFile)
    txtFile.WriteLine "Doc info:"
    txtFile.WriteLine ("DocumentId " & docObj.Id)
    txtFile.WriteLine ("IsAssembled " & docObj.IsAssembled)
    txtFile.WriteLine ("IsVerified " & docObj.IsVerified)
    txtFile.WriteLine ("IsExported " & docObj.IsExported)
    txtFile.WriteLine ("ProcessingErrors " & docObj.ProcessingErrors)
    txtFile.WriteLine ("ProcessingWarnings " & docObj.ProcessingWarnings)
    txtFile.WriteLine ("TotalSymbolsCount " & docObj.TotalSymbolsCount)
    txtFile.WriteLine ("RecognizedSymbolsCount " & docObj.RecognizedSymbolsCount)
    txtFile.WriteLine ("UncertainSymbolsCount " & docObj.UncertainSymbolsCount)
    txtFile.WriteLine
End Sub

' El procedimiento que exporta campos de la colección de campos
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
    Dim curField
    For Each curField In fields
        ExportField curField, txtFile, indent
    Next
End Sub

' Comprueba si el valor de los campos es nulo
' Si el valor del campo no es válido, cualquier intento de acceder a este campo (incluso
' para comprobar si es nulo) puede provocar una excepción
Function IsNullFieldValue( ByRef field )
    on error resume next
    IsNullFieldValue = IsNull( field.Value )
    if Err.Number <> 0 then
        IsNullFieldValue = True
        Err.Clear
    End if
End Function

' Procedimiento de exportación de campos
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)
    ' guardado del nombre del campo
    txtFile.Write (indent & field.Name)

    ' guardado del valor del campo si se puede acceder a él
    If IsNullFieldValue(field) Then
        txtFile.WriteLine
    Else
        txtFile.WriteLine ("    " & field.Text)
    End If

    If Not field.Children Is Nothing Then
        ' exportación de campos secundarios
        ExportFields field.Children, txtFile, indent & "    "
    ElseIf Not field.Items Is Nothing Then
        ' exportación de instancias de campo
        ExportFields field.Items, txtFile, indent & "    "
    End If
End Sub

' La función crea una carpeta de exportación y devuelve la ruta completa a dicha carpeta
Function CreateExportFolder(ByVal definitionName, ByRef fso)
    Dim docFolder, folderName

    ' carpeta principal
    exportFolder = "d:\ScriptExport"

    If fso.FolderExists(exportFolder) = False Then
        fso.CreateFolder (exportFolder)
    End If

    ' la carpeta de la Definición de Document especificada
    docFolder = fso.BuildPath(exportFolder, definitionName)

    If fso.FolderExists(docFolder) = False Then
        fso.CreateFolder (docFolder)
    End If

    ' la carpeta del documento exportado
    Dim i
    i = 1
    folderName = fso.BuildPath(docFolder, i)

    While fso.FolderExists(folderName)
        i = i + 1
        folderName = fso.BuildPath(docFolder, i)
    Wend

    fso.CreateFolder (folderName)
    CreateExportFolder = folderName
End Function
```

La implementación de JScript:

```javascript theme={null}
// La función realiza la exportación: crea una carpeta de exportación y
// guarda en ella los archivos de imagen de página, el archivo de texto con los campos del documento
// e información sobre el documento
function ExportDocument(docObj, exportImageTools)
{
    var folderName
    var txtFile, fileName
    var fso

    fso = new ActiveXObject("Scripting.FileSystemObject");
    // creación de carpetas de exportación
    try {
        folderName = CreateExportFolder(docObj.DefinitionName, fso);
    } catch( e ) {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during create export folder: " + e.description;
        return;n;
    }

    // exportación de imágenes
    try {
        ExportImages(docObj, exportImageTools, folderName, fso);
    } catch( e ) {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during export images: " + e.description;
        return;
    }

    // creación del archivo de texto
    fileName = fso.BuildPath(folderName, "doc.txt");
    txtFile = fso.CreateTextFile(fileName, true);

    // exportación de información sobre el documento
    ExportDocInfo( docObj, txtFile );

    // exportación de campos
    txtFile.WriteLine( "Fields:" );
    try {
        ExportFields( docObj.Children, txtFile, "" );
    } catch( e ) { {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during export data: " + e.description;
        txtFile.Close();
        return;
    }

    txtFile.Close();
    txtFile = 0;
    fso = 0;
}

// Función de exportación de imágenes. Si se produce un error al exportar imágenes,
// devuelve un mensaje sobre el error; de lo contrario, devuelve una cadena vacía
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{
    // especificación de la configuración de exportación
    var imageOptions = exportImageTools.NewImageSavingOptions();
    imageOptions.Format = "bmp";
    imageOptions.ColorType = "FullColor";
    imageOptions.Resolution = 100;

    // exportación página por página
    var pages = docObj.Pages;
    var i
    for( i = 0; i < pages.Count; i++ ) {
        var fileName = fso.BuildPath( exportFolder, "page" + (i+1) + ".bmp" );
        pages.Item(i).SaveAs( fileName, imageOptions );
    }
}

// Procedimiento que exporta información sobre el documento
function ExportDocInfo(docObj, txtFile)
{
    txtFile.WriteLine( "Doc info:" );
    txtFile.WriteLine("IsAssembled " + docObj.IsAssembled);
    txtFile.WriteLine("IsVerified " + docObj.IsVerified);
    txtFile.WriteLine("IsExported " + docObj.IsExported);
    txtFile.WriteLine("ProcessingErrors " + docObj.ProcessingErrors);
    txtFile.WriteLine("ProcessingWarnings " + docObj.ProcessingWarnings);
    txtFile.WriteLine("TotalSymbolsCount " + docObj.TotalSymbolsCount);
    txtFile.WriteLine("RecognizedSymbolsCount " + docObj.RecognizedSymbolsCount);
    txtFile.WriteLine("UncertainSymbolsCount " + docObj.UncertainSymbolsCount);
    txtFile.WriteLine();
}

// Procedimiento que exporta campos de la colección de campos
function ExportFields(fields, txtFile, indent)
{
    var i
    for( i = 0; i < fields.Count; i++ ) {
        ExportField( fields.Item(i), txtFile, indent );
    }
}

// Comprueba si el valor del campo es nulo
// Si el valor del campo no es válido, cualquier intento de acceder a este campo (incluso
// para comprobar si es nulo) puede provocar una excepción
function IsNullFieldValue( field )
{
    try {
        return ( field.Value == null );
    } catch( e ) {
        return true;
    }
}

// Procedimiento de exportación de campos
function ExportField(field, txtFile, indent)
{
    // almacenamiento del nombre de archivo
    txtFile.Write(indent + field.Name);

    // almacenamiento del valor del campo, si se puede acceder a él
    if( IsNullFieldValue( field ) ) {
        txtFile.WriteLine();
    } else {
        txtFile.WriteLine("    " + field.Text);
    } }

    if( field.Children != null ) {
        // exportación de campos secundarios
        ExportFields( field.Children, txtFile, indent + "    " );
    } else if( field.Items != null ) {
        // exportación de instancias de campo
        ExportFields( field.Items, txtFile, indent + "    " );
    }
}

// La función crea una carpeta de exportación y devuelve la ruta completa a dicha carpeta
function CreateExportFolder(definitionName, fso)
{
    var docFolder, folderName

    // carpeta principal
    var exportFolder = "d:\\ScriptExport";

    if( !fso.FolderExists(exportFolder) ) {
        fso.CreateFolder (exportFolder);
    } }

    // la carpeta de la Definición de Document especificada
    docFolder = fso.BuildPath(exportFolder, definitionName);

    if( !fso.FolderExists(docFolder) ) {
        fso.CreateFolder(docFolder);
    }

    // la carpeta del documento exportado
    var i = 1;
    folderName = fso.BuildPath(docFolder, i);

    while( fso.FolderExists(folderName) ) {
        i++;
        folderName = fso.BuildPath(docFolder, i);
    }

    fso.CreateFolder(folderName);
    return folderName;
}
```

<div id="use-an-external-com-component">
  ## Uso de un componente COM externo
</div>

Llame a un componente COM externo desde el script de exportación. Este enfoque resulta útil para exportar campos del documento con niveles de anidamiento variables.

El siguiente VBScript llama al componente:

```vb theme={null}
dim autoExport
set autoExport = CreateObject( "AutomationExport.Exporter" )
autoExport.Export me, FCTools
```

La llamada equivalente en JScript:

```javascript theme={null}
var autoExport = new ActiveXObject("AutomationExport.Exporter");
autoExport.Export( this, FCTools );
```

<div id="exporter-class-code-in-visual-basic">
  ### Código de la clase Exporter en Visual Basic
</div>

Este es el código de la clase `Exporter` del proyecto `AutomationExport` que se usa en los scripts anteriores.

```vb theme={null}
Option Explicit

Dim mFso As New Scripting.FileSystemObject

' El procedimiento realiza la exportación del documento: crea una carpeta de exportación y
' guarda en ella los archivos de imagen de página, el archivo de texto con los campos del documento
' e información sobre el documento
Public Sub Export(ByRef docObj As Object, ByRef FCTools As Object)
    On Error GoTo err_h
    Dim folderName As String
    Dim txtFile As TextStream, fileName As String
    Dim imageExportResult As String, errMessage As String

    ' creación de la carpeta de exportación
    folderName = createExportFolder(docObj.definitionName)
    If folderName = "" Then
        docObj.Action.Succeeded = False
        docObj.Action.ErrorMessage = "Cannot create export folder"
        Exit Sub
    End If

    ' exportación de imágenes
    imageExportResult = exportImages(docObj, FCTools, folderName)

    ' creación del archivo de texto
    fileName = mFso.BuildPath(folderName, "doc.txt")
    Set txtFile = mFso.CreateTextFile(fileName, True)

    ' guardado de información sobre problemas en la exportación de imágenes
    If imageExportResult <> "" Then
        txtFile.WriteLine imageExportResult
        errMessage = errMessage & imageExportResult
    End If

    ' exportación de información sobre el documento
    exportDocInfo docObj, txtFile

    ' exportación de campos
    txtFile.WriteLine "Fields:"
    If Not exportFields(docObj.Children, txtFile, "") Then
        errMessage = errMessage & " Error during export data"
    End If
    txtFile.Close

    ' si se producen errores durante la exportación, restablecer
    ' el indicador de éxito de exportación a False
    If errMessage <> "" Then
        docObj.Action.Succeeded = False
        docObj.Action.ErrorMessage = errMessage
    End If

    Set txtFile = Nothing
    Set mFso = Nothing
    Exit Sub

err_h:
    docObj.Action.Succeeded = False
    docObj.Action.ErrorMessage = Err.Description
    txtFile.Close
    Set mFso = Nothing
End Sub

' Función de exportación de imágenes. Si se produce un error al exportar imágenes,
' devuelve un mensaje de error; de lo contrario, devuelve una cadena vacía
Private Function exportImages(ByRef docObj As Object, ByRef FCTools As Object, _
    ByVal exportFolder As String) As String
    On Error GoTo err_h
    Dim pages As Object, page As Object, imageOptions As Object
    Dim fileName As String, pageNum As Long
    exportImages = ""

    ' especificación de la configuración de exportación
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "png"
    imageOptions.ColorType = "GrayScale"
    imageOptions.Resolution = 300

    ' exportación página por página
    Set pages = docObj.pages
    pageNum = 1
    For Each page In pages
        fileName = mFso.BuildPath(exportFolder, page.definitionName + "_page" & pageNum & "." & imageOptions.Format)
        page.SaveAs fileName, imageOptions
        pageNum = pageNum + 1
    Next page
    Exit Function

err_h:
    exportImages = Err.Description
End Function

' El procedimiento que exporta información sobre el documento
Private Sub exportDocInfo(ByRef docObj As Object, ByRef txtFile As TextStream)
    On Error GoTo err_h
    txtFile.WriteLine "Doc info:"
    txtFile.WriteLine ("DocumentId " & docObj.Id)
    txtFile.WriteLine ("IsAssembled " & docObj.IsAssembled)
    txtFile.WriteLine ("IsVerified " & docObj.IsVerified)
    txtFile.WriteLine ("IsExported " & docObj.IsExported)
    txtFile.WriteLine ("ProcessingErrors " & docObj.ProcessingErrors)
    txtFile.WriteLine ("ProcessingWarnings " & docObj.ProcessingWarnings)
    txtFile.WriteLine ("TotalSymbolsCount " & docObj.TotalSymbolsCount)
    txtFile.WriteLine ("RecognizedSymbolsCount " & docObj.RecognizedSymbolsCount)
    txtFile.WriteLine ("UncertainSymbolsCount " & docObj.UncertainSymbolsCount)
    txtFile.WriteLine
    Exit Sub

err_h:
    txtFile.WriteLine Err.Description
End Sub

' El procedimiento que exporta campos de la colección de fields
Private Function exportFields(ByRef fields As Object, ByRef txtFile As TextStream, ByVal indent As String) As Boolean
    On Error GoTo err_h
    Dim curField As Object
    exportFields = True
    For Each curField In fields
        If Not exportField(curField, txtFile, indent) Then
            exportFields = False
        End If
    Next curField
    Exit Function

err_h:
    txtFile.WriteLine Err.Description
    exportFields = False
End Function

' Comprueba si el valor del campo es nulo
' Si el valor no es válido, cualquier intento de acceder a este campo (incluso
' para comprobar si es nulo) puede provocar una excepción
Function IsNullFieldValue(ByRef field As Object) As Boolean
    On Error GoTo err_h
    IsNullFieldValue = IsNull(field.Value)
    Exit Function

err_h:
    IsNullFieldValue = True
End Function

' Función de exportación de campo
Private Function exportField(ByRef field As Object, ByRef txtFile As TextStream, _
    ByVal indent As String) As Boolean
    On Error GoTo err_h
    Dim result As Boolean
    result = True

    ' guardado del nombre del campo
    txtFile.Write (indent & field.Name)

    ' guardado del valor del campo si se puede acceder a él
    If Not IsNullFieldValue(field) Then
        txtFile.WriteLine ("    " & field.Value)
    Else
        txtFile.WriteLine
    End If

    If Not field.Children Is Nothing Then
        ' exportación de campos secundarios
        result = result And exportFields(field.Children, txtFile, indent & "    ")
    ElseIf Not field.Items Is Nothing Then
        ' exportación de instancias del campo
        result = result And exportFields(field.Items, txtFile, indent & "    ")
    End If

    exportField = result
    Exit Function

err_h:
    txtFile.WriteLine Err.Description
    exportField = False
End Function

' La función crea una carpeta de exportación y devuelve la ruta completa a dicha carpeta
Private Function createExportFolder(ByVal definitionName As String) As String
    On Error GoTo err_h
    Dim docFolder As String, folderName As String

    ' carpeta principal
    Const exportFolder = "d:\AutomationExport"
    If mFso.FolderExists(exportFolder) = False Then
        mFso.CreateFolder (exportFolder)
    End If

    ' la carpeta de la Definición de Document especificada
    docFolder = mFso.BuildPath(exportFolder, definitionName)
    If mFso.FolderExists(docFolder) = False Then
        mFso.CreateFolder (docFolder)
    End If

    ' la carpeta del documento exportado
    Dim i As Long
    i = 1
    folderName = mFso.BuildPath(docFolder, i)
    While mFso.FolderExists(folderName)
        i = i + 1
        folderName = mFso.BuildPath(docFolder, i)
    Wend
    mFso.CreateFolder (folderName)
    createExportFolder = folderName
    Exit Function

err_h:
    createExportFolder = ""
End Function
```

<div id="use-a-net-component-written-in-c">
  ### Usar un componente de .NET escrito en C\#
</div>

<Steps>
  <Step title="Crear un proyecto ClassLibrary">
    Cree un proyecto de tipo `ClassLibrary`.
  </Step>

  <Step title="Agregar la referencia a ControllerInterop.dll">
    Agregue `ControllerInterop.dll` a **References** del proyecto. `ABBYY.FlexiCapture` aparece en la lista References y todas las interfaces de los objetos de script quedan disponibles en el proyecto.
  </Step>

  <Step title="Definir la dispinterface, la clase y el ProgId">
    Defina la dispinterface y la clase que implementa esta interfaz, así como el `ProgId`. Esto permite trabajar con el componente de .NET desde código de script igual que con ActiveX.
  </Step>

  <Step title="Registrar la biblioteca de tipos generada">
    Después de compilar el proyecto, registre la biblioteca de tipos generada. Para hacerlo automáticamente, habilite la opción correspondiente en las Propiedades del proyecto.
  </Step>

  <Step title="Llamar al componente desde el código de exportación">
    Desde el código de exportación, llame al método del componente de la forma habitual, como se muestra en el siguiente ejemplo.
  </Step>
</Steps>

El siguiente VBScript llama al componente:

```vb theme={null}
dim autoExport
set autoExport = CreateObject( "ExportLibrary1.Export" )
autoExport.ExportDocument me, FCTools
```

La llamada equivalente en JScript:

```javascript theme={null}
var autoExport = new ActiveXObject("ExportLibrary1.Export"); autoExport.ExportDocument( this, FCTools );
```

El siguiente código en C# implementa dicho componente:

```csharp theme={null}
using System;
using System.Runtime.InteropServices;
using System.IO;
using ABBYY.FlexiCapture;

namespace ExportLibrary1
{
    // La interfaz del componente de exportación a la que se puede acceder desde el script
    // Al crear un nuevo componente, genere un nuevo GUID
    [Guid("32B10C3B-EEA3-4194-B0A0-E358C310225A")]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    public interface _cExport
    {
        [DispId(1)]
        void ExportDocument(ref IExportDocument DocRef, ref FCTools Tools);
    }

    // La clase que implementa la funcionalidad del componente de exportación
    // Al crear un nuevo componente, genere un nuevo GUID
    // y establezca su ProgId
    [Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
    [ClassInterface(ClassInterfaceType.None)]
    [ProgId("ExportLibrary1.Export")]
    [ComVisible(true)]
    public class Export : _cExport
    {
        public Export()
        {
        }

        // La función realiza la exportación del documento: crea una carpeta de exportación y
        // guarda en ella los archivos de imagen de página,
        // el archivo de texto con los campos del documento e información sobre el documento
        public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )
        {
            try
            {
                string exportFolder = createExportFolder( docRef.DefinitionName );
                exportImages( docRef, FCTools, exportFolder );

                // creación del archivo de texto
                string fileName = exportFolder + "//" + "doc.txt";
                StreamWriter sw = File.CreateText( fileName );

                // exportación de información sobre el documento
                exportDocInfo( docRef, sw );

                // exportación de campos
                sw.WriteLine( "Fields:" );
                exportFields( docRef.Children, sw, "" );
                sw.Close();
            }
            catch( Exception e )
            {
                docRef.Action.Succeeded = false;
                docRef.Action.ErrorMessage = e.ToString();
            }
        }

        // La función crea una carpeta de exportación y devuelve la ruta completa a dicha carpeta
        private string createExportFolder(string definitionName )
        {
            string docFolder, folderName;

            // carpeta principal
            string exportFolder = "d:\\DotNetExport";
            if( !Directory.Exists(exportFolder) )
            {
                Directory.CreateDirectory(exportFolder);
            }

            // la carpeta de la Definición de Document especificada
            docFolder = exportFolder + "\\" + definitionName;
            if( !Directory.Exists(docFolder) )
            {
                Directory.CreateDirectory( docFolder );
            }

            // la carpeta del documento exportado
            int i = 1;
            folderName = docFolder + "\\" + i;
            while( Directory.Exists(folderName) )
            {
                i++;
                folderName = docFolder + "\\" + i;
            }
            Directory.CreateDirectory(folderName);
            return folderName;
        }

        // Función de exportación de imágenes
        private void exportImages( IExportDocument docRef, FCTools FCTools, string exportFolder )
        {
            string baseFileName = exportFolder + "\\page_";
            IExportImageSavingOptions imageOptions = FCTools.NewImageSavingOptions();
            imageOptions.Format = "bmp";
            imageOptions.ColorType = "FullColor";
            imageOptions.Resolution = 100;
            int i = 1;
            foreach( IExportPage curPage in docRef.Pages )
            {
                string fileName = baseFileName + i + ".bmp";
                curPage.SaveAs( fileName, imageOptions );
                i++;
            }
        }

        // Exportación de información sobre el documento
        private void exportDocInfo( IExportDocument docRef, StreamWriter sw )
        {
            sw.WriteLine( "Doc info:" );
            sw.WriteLine("DocumentId " + docRef.Id );
            sw.WriteLine("IsAssembled " + docRef.IsAssembled);
            sw.WriteLine("IsVerified " + docRef.IsVerified);
            sw.WriteLine("IsExported " + docRef.IsExported);
            sw.WriteLine("ProcessingErrors " + docRef.ProcessingErrors);
            sw.WriteLine("ProcessingWarnings " + docRef.ProcessingWarnings);
            sw.WriteLine("TotalSymbolsCount " + docRef.TotalSymbolsCount);
            sw.WriteLine("RecognizedSymbolsCount " + docRef.RecognizedSymbolsCount);
            sw.WriteLine();
        }

        // Exportación de la colección de campos
        private void exportFields( IExportFields fields, StreamWriter sw, string indent )
        {
            foreach( IExportField curField in fields )
            {
                exportField( curField, sw, indent );
            }
        }

        // Comprueba si el valor del campo es nulo
        // Si el valor del campo no es válido, cualquier intento de acceder a este campo (incluso
        // para comprobar si es nulo) puede provocar una excepción
        private bool IsNullFieldValue( IExportField field )
        {
            try
            {
                return ( field.Value == null );
            }
            catch( Exception e )
            {
                return true;
            }
        }

        // Exportación del campo especificado
        private void exportField( IExportField field, StreamWriter sw, string indent )
        {
            // guardado del nombre del campo
            sw.Write( indent + field.Name );

            // guardado del valor del campo si se puede acceder a él
            if( IsNullFieldValue( field ) )
            {
                sw.WriteLine();
            }
            else
            {
                sw.WriteLine( "    " + field.Text );
            }

            if( field.Children != null )
            {
                // exportación de campos secundarios
                exportFields( field.Children, sw, indent + "    " );
            }
            else if( field.Items != null )
            {
                // exportación de instancias de campo
                exportFields( field.Items, sw, indent + "    " );
            }
        }
    }
}
```

<div id="write-an-export-handler">
  ## Crear un controlador de exportación
</div>

Este ejemplo muestra un controlador de exportación sencillo que guarda información sobre los documentos exportados y los resultados de la exportación en archivos de texto. Usa dos archivos de texto: uno para la lista de documentos exportados correctamente y otro para la lista de documentos que devolvieron errores durante la exportación.

El siguiente ejemplo de VBScript procesa los resultados de la exportación:

```vb theme={null}
dim curDoc
dim fso, fileErrorName, txtErrorFile, fileSucceedName, txtSucceedFile
set fso = CreateObject("Scripting.FileSystemObject")

' creando el archivo con los documentos fallidos
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )

' creando el archivo con los documentos exportados correctamente
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo

' iterando la colección de documentos exportados
for i = 0 To me.Count - 1
    set exportResult = me.Item(i)
    docInfo = "DocumentId:" & exportResult.Document.Id
    if exportResult.Succeeded then
        docInfo = docInfo & " - Exported successfully."
        txtSucceedFile.WriteLine docInfo
    else
        docInfo = docInfo & " - Export error: " & exportResult.ErrorMessage
        txtErrorFile.WriteLine docInfo
    endif
next

txtErrorFile.Close
txtSucceedFile.Close
```

El ejemplo equivalente en JScript:

```javascript theme={null}
var fso = new ActiveXObject("Scripting.FileSystemObject");

// creación del archivo con documentos con errores
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );

// creación del archivo con documentos exportados correctamente
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i

// iteración de la colección de documentos exportados
for( i = 0; i < Documents.Count; i++ ) {
    var curDoc = Documents.Item( i );
    var docInfo = "DocumentId: " + curDoc.Id;
    if( curDoc.Action.Succeeded ) {
        docInfo = docInfo + ". Exported successfully.  Result:" + curDoc.Action.Result;
        txtSucceedFile.WriteLine( docInfo );
    } else {
        docInfo = docInfo + ". Export error: " + curDoc.Action.ErrorMessage + "  Result:" + curDoc.Action.Result;
        txtErrorFile.WriteLine( docInfo );
    }
}
txtErrorFile.Close();
txtSucceedFile.Close();
```

<div id="access-source-files-in-common-office-formats">
  ## Acceder a los archivos de origen en formatos ofimáticos comunes
</div>

Este script de ejemplo guarda los archivos de origen al exportar documentos. Los archivos de origen deben estar en uno de los [formatos ofimáticos comunes admitidos](/es/flexi-capture/appendix/input-formats) y tener nombres únicos para evitar conflictos de nombres.

```csharp theme={null}
using System;
using System.IO;
using System.Collections.Generic;

// Iterar por las páginas.
for( int i = 0; i<Document.Pages.Count; i++ ) {
    IPage page = Document.Pages[i];

    // Comprobar si existe un archivo de origen.
    if( page.SourceFileGUID == "" ) {
        continue;
    }

    // El nombre original del archivo.
    string sourceFileName = @"";

    // Especificar el nombre de archivo original.
    if( page.ImageSourceType == @"File" ) {
        sourceFileName = Path.GetFileName( page.ImageSource );
    } else if( page.ImageSourceType == @"Scanner" || page.ImageSourceType == @"Custom" ) {
        sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );
    }

    // Eliminar la extensión del nombre de archivo.
    if( sourceFileName != @"" ) {
        sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";
    }

    // Nombre único del archivo de origen (nombre original + guid).
    string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;

    // La ruta a la carpeta donde se guardará el archivo de origen.
    string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;

    // Verificar que el archivo no exista.
    if( File.Exists( sourceFilePath ) ) {
        continue;
    }

    // Guardar el archivo.
    Processing.ReportMessage( "Saving source file: " + sourceFileUniqueName );
    page.SaveSourceFile( sourceFilePath );
}
```