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

# Exemples de scripts pour l’Export

> Exemples de scripts d’Export pour ABBYY FlexiCapture : lire les valeurs des champs lors de l’Export, enregistrer des images de page, exporter des tableaux et écrire des gestionnaires de résultat d’Export.

Les exemples suivants présentent des tâches d’Export courantes dans ABBYY FlexiCapture, telles que la lecture des valeurs des champs, l’enregistrement des images de page, l’exportation de tableaux et le traitement des résultats d’Export. La plupart des exemples sont fournis à la fois en VBScript et en JScript, et certains incluent un composant externe écrit en Visual Basic ou en C#.

<div id="get-field-values-during-export">
  ## Obtenir les valeurs des champs lors de l’export
</div>

Cet exemple récupère la valeur d’un champ lors de l’export. Vous pouvez utiliser cette valeur pour nommer les fichiers dans lesquels les images ou les données sont exportées. Si le document ne contient pas le champ, une erreur se produit.

La structure du document à exporter :

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

L’exemple VBScript suivant récupère les valeurs des champs :

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

' Obtient la valeur de Field1 dans Section 1
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
    field1Value = me.Field( "Section 1\Field1" ).Value
end if

' Obtient la valeur de Field2 dans Group1 dans Section 1
if Not IsNull( me.FIELD( "Section 1\Group1\Field2" ).Value ) then
    field2Value = me.Field( "Section 1\Group1\Field2" ).Value
end if

' Obtient la valeur de Field1 dans Section 1 si la section comporte plusieurs instances
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
```

L’exemple JScript suivant fait de même :

```javascript theme={null}
// Obtient la valeur de Field1 dans Section 1
if( Field("Section 1\\Field1").Value != null ) {
    var field1Value = Field("Section 1\\Field1").Value;
}

// Obtient la valeur de Field2 dans Group1 dans Section 1
if( Field("Section 1\\Group1\\Field2").Value != null ) {
    var field2Value = Field("Section 1\\Group1\\Field2").Value;
}

// Obtient la valeur de Field1 dans Section 1 si la section comporte plusieurs instances
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">
  ## Exporter les images des pages
</div>

Cet exemple exporte les images de toutes les pages du document selon le format de fichier, le mode colorimétrique et la résolution choisis. Chaque page est enregistrée dans un fichier distinct.

Les fichiers de cet exemple sont nommés `page1.tif`, `page2.tif`, et ainsi de suite. Vous pouvez modifier la convention de nommage des fichiers — par exemple, en basant les noms de fichier sur la valeur d’un champ.

L’exemple VBScript suivant exporte les images des pages :

```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
    ' Définit le nom et l'extension souhaités pour le fichier en fonction du format sélectionné
    fileName = fso.BuildPath( folderName, "page" & (i+1) & ".tif" )
    me.Pages.Item(i).SaveAs fileName, imageOptions
next
```

L’exemple JScript suivant fait de même :

```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++ ) {
    // Définit le nom et l'extension souhaités pour le fichier en fonction du format sélectionné
    var fileName = fso.BuildPath( folderName, "page" + (i+1) + ".tif" );
    Pages.Item(i).SaveAs( fileName, imageOptions );
}
```

<div id="export-a-table">
  ## Export d’un tableau
</div>

Cet exemple exporte un tableau vers un fichier `*.txt`.

L’exemple VBScript suivant exporte le tableau :

```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
```

L’exemple JScript suivant fait de même :

```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">
  ## Exportation d’un document, quel que soit son niveau d’imbrication
</div>

Cet exemple exporte les champs d’un document, quel que soit son niveau d’imbrication, à l’aide de fonctions personnalisées issues du module d’export global. Pour exporter des champs de document avec un niveau d’imbrication variable, utilisez un composant COM externe, comme indiqué dans l’exemple suivant.

<div id="core-export-code">
  ### Code d’export principal
</div>

Ajoutez cet appel au script d’export du document.

Le VBScript suivant appelle la fonction d’export :

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

L’appel JScript équivalent :

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

<div id="global-export-module-functions">
  ### Fonctions du module d’export global
</div>

Le module d’export global définit les fonctions suivantes.

L’implémentation en VBScript :

```vb theme={null}
' La procédure effectue l'export : crée un dossier d'export et
' y enregistre les fichiers d'image de page, le fichier texte avec les champs du document,
' ainsi que les informations sur le document
Sub ExportDocument(ByRef docObj, ByRef FCTools)
    Dim folderName
    Dim txtFile, fileName
    Dim fso

    On Error Resume Next
    set fso = CreateObject("Scripting.FileSystemObject")
    ' création du dossier d'export
    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

    ' exportation des images
    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

    ' création du fichier texte
    fileName = fso.BuildPath(folderName, "doc.txt")
    Set txtFile = fso.CreateTextFile(fileName, True)

    ' exportation des informations sur le document
    ExportDocInfo docObj, txtFile

    ' exportation des champs
    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

' Fonction d'exportation des images
Function ExportImages( ByRef docObj, ByRef FCTools, ByVal exportFolder, ByRef fso )
    Dim pages, page, imageOptions
    Dim fileName, pageNum

    ' définition des paramètres d'export
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "bmp"
    imageOptions.ColorType = "FullColor"
    imageOptions.Resolution = 100

    ' exportation page par page
    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

' La procédure qui exporte les informations sur le document
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

' La procédure qui exporte les champs depuis la collection de champs
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
    Dim curField
    For Each curField In fields
        ExportField curField, txtFile, indent
    Next
End Sub

' Vérifie si la valeur des champs est nulle
' Si la valeur du champ est invalide, toute tentative d'accès à ce champ (même
' pour vérifier si elle est nulle) peut lever une exception
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

' Procédure d'exportation des champs
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)
    ' enregistrement du nom du champ
    txtFile.Write (indent & field.Name)

    ' enregistrement de la valeur du champ si elle est accessible
    If IsNullFieldValue(field) Then
        txtFile.WriteLine
    Else
        txtFile.WriteLine ("    " & field.Text)
    End If

    If Not field.Children Is Nothing Then
        ' exportation des champs enfants
        ExportFields field.Children, txtFile, indent & "    "
    ElseIf Not field.Items Is Nothing Then
        ' exportation des instances de champ
        ExportFields field.Items, txtFile, indent & "    "
    End If
End Sub

' La fonction crée un dossier d'export et renvoie le chemin complet vers ce dossier
Function CreateExportFolder(ByVal definitionName, ByRef fso)
    Dim docFolder, folderName

    ' dossier principal
    exportFolder = "d:\ScriptExport"

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

    ' le dossier de la définition de document spécifiée
    docFolder = fso.BuildPath(exportFolder, definitionName)

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

    ' le dossier du document exporté
    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
```

L’implémentation en JScript :

```javascript theme={null}
// La fonction effectue l'exportation : crée un dossier d'export et
// y enregistre les fichiers image de page, le fichier texte avec les champs du document,
// ainsi que les informations sur le document
function ExportDocument(docObj, exportImageTools)
{
    var folderName
    var txtFile, fileName
    var fso

    fso = new ActiveXObject("Scripting.FileSystemObject");
    // création des dossiers d'export
    try {
        folderName = CreateExportFolder(docObj.DefinitionName, fso);
    } catch( e ) {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during create export folder: " + e.description;
        return;n;
    }

    // exportation des images
    try {
        ExportImages(docObj, exportImageTools, folderName, fso);
    } catch( e ) {
        docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error during export images: " + e.description;
        return;
    }

    // création du fichier texte
    fileName = fso.BuildPath(folderName, "doc.txt");
    txtFile = fso.CreateTextFile(fileName, true);

    // exportation des informations sur le document
    ExportDocInfo( docObj, txtFile );

    // exportation des champs
    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;
}

// Fonction d'exportation des images. Si une erreur survient lors de l'exportation des images,
// elle renvoie un message d'erreur ; sinon, elle renvoie une chaîne vide
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{
    // définition des paramètres d'exportation
    var imageOptions = exportImageTools.NewImageSavingOptions();
    imageOptions.Format = "bmp";
    imageOptions.ColorType = "FullColor";
    imageOptions.Resolution = 100;

    // exportation page par page
    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 );
    }
}

// Procédure d'exportation des informations sur le document
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();
}

// Procédure d'exportation des champs depuis la collection de champs
function ExportFields(fields, txtFile, indent)
{
    var i
    for( i = 0; i < fields.Count; i++ ) {
        ExportField( fields.Item(i), txtFile, indent );
    }
}

// Vérifie si la valeur du champ est nulle
// Si la valeur du champ est invalide, toute tentative d'accès à ce champ (même
// pour vérifier si elle est nulle) peut lever une exception
function IsNullFieldValue( field )
{
    try {
        return ( field.Value == null );
    } catch( e ) {
        return true;
    }
}

// Procédure d'exportation du champ
function ExportField(field, txtFile, indent)
{
    // enregistrement du nom de fichier
    txtFile.Write(indent + field.Name);

    // enregistrement de la valeur du champ, si elle est accessible
    if( IsNullFieldValue( field ) ) {
        txtFile.WriteLine();
    } else {
        txtFile.WriteLine("    " + field.Text);
    } }

    if( field.Children != null ) {
        // exportation des champs enfants
        ExportFields( field.Children, txtFile, indent + "    " );
    } else if( field.Items != null ) {
        // exportation des instances de champ
        ExportFields( field.Items, txtFile, indent + "    " );
    }
}

// La fonction crée un dossier d'export et renvoie le chemin complet vers ce dossier
function CreateExportFolder(definitionName, fso)
{
    var docFolder, folderName

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

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

    // le dossier de la définition de document spécifiée
    docFolder = fso.BuildPath(exportFolder, definitionName);

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

    // le dossier du document exporté
    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">
  ## Utilisation d'un composant COM externe
</div>

Appelez un composant COM externe à partir du script d’export. Cette approche est utile pour exporter des champs de document avec un niveau d’imbrication variable.

Le VBScript suivant appelle le composant :

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

L’appel JScript équivalent :

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

<div id="exporter-class-code-in-visual-basic">
  ### Code de la classe `Exporter` en Visual Basic
</div>

Voici le code de la classe `Exporter` du projet `AutomationExport`, utilisée dans les scripts précédents.

```vb theme={null}
Option Explicit

Dim mFso As New Scripting.FileSystemObject

' La procédure effectue l'export du document : crée un dossier d'export et
' y enregistre les fichiers image de page, le fichier texte avec les champs du document,
' ainsi que les informations relatives au document
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

    ' création du dossier d'export
    folderName = createExportFolder(docObj.definitionName)
    If folderName = "" Then
        docObj.Action.Succeeded = False
        docObj.Action.ErrorMessage = "Cannot create export folder"
        Exit Sub
    End If

    ' exportation des images
    imageExportResult = exportImages(docObj, FCTools, folderName)

    ' création du fichier texte
    fileName = mFso.BuildPath(folderName, "doc.txt")
    Set txtFile = mFso.CreateTextFile(fileName, True)

    ' enregistrement des informations sur les problèmes d'exportation des images
    If imageExportResult <> "" Then
        txtFile.WriteLine imageExportResult
        errMessage = errMessage & imageExportResult
    End If

    ' exportation des informations relatives au document
    exportDocInfo docObj, txtFile

    ' exportation des champs
    txtFile.WriteLine "Fields:"
    If Not exportFields(docObj.Children, txtFile, "") Then
        errMessage = errMessage & " Error during export data"
    End If
    txtFile.Close

    ' si des erreurs surviennent lors de l'export, réinitialiser
    ' l'indicateur de réussite de l'export à 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

' Fonction d'exportation des images. Si une erreur survient lors de l'exportation des images,
' elle retourne un message d'erreur, sinon elle retourne une chaîne vide
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 = ""

    ' définition des paramètres d'export
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "png"
    imageOptions.ColorType = "GrayScale"
    imageOptions.Resolution = 300

    ' exportation page par page
    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

' La procédure qui exporte les informations relatives au document
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

' La procédure qui exporte les champs depuis la collection de champs
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

' Vérifie si la valeur du champ est nulle
' Si la valeur est invalide, toute tentative d'accès à ce champ (même
' pour vérifier si elle est nulle) peut provoquer une exception
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

' Fonction d'exportation du champ
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

    ' enregistrement du nom du champ
    txtFile.Write (indent & field.Name)

    ' enregistrement de la valeur du champ si elle est accessible
    If Not IsNullFieldValue(field) Then
        txtFile.WriteLine ("    " & field.Value)
    Else
        txtFile.WriteLine
    End If

    If Not field.Children Is Nothing Then
        ' exportation des champs enfants
        result = result And exportFields(field.Children, txtFile, indent & "    ")
    ElseIf Not field.Items Is Nothing Then
        ' exportation des instances du champ
        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 fonction crée un dossier d'export et retourne le chemin complet vers ce dossier
Private Function createExportFolder(ByVal definitionName As String) As String
    On Error GoTo err_h
    Dim docFolder As String, folderName As String

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

    ' le dossier de la définition de document spécifiée
    docFolder = mFso.BuildPath(exportFolder, definitionName)
    If mFso.FolderExists(docFolder) = False Then
        mFso.CreateFolder (docFolder)
    End If

    ' le dossier du document exporté
    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">
  ### Utiliser un composant .NET écrit en C\#
</div>

<Steps>
  <Step title="Créer un projet ClassLibrary">
    Créez un projet de type `ClassLibrary`.
  </Step>

  <Step title="Ajouter la référence ControllerInterop.dll">
    Ajoutez `ControllerInterop.dll` aux **References** du projet. `ABBYY.FlexiCapture` apparaît dans la liste References, et toutes les interfaces des objets script deviennent disponibles dans le projet.
  </Step>

  <Step title="Définir la dispinterface, la classe et le ProgId">
    Définissez la dispinterface et la classe qui implémente cette interface, ainsi que le `ProgId`. Cela permet d’utiliser le composant .NET depuis le code script comme s’il s’agissait d’un composant ActiveX.
  </Step>

  <Step title="Enregistrer la bibliothèque de types générée">
    Après avoir compilé le projet, enregistrez la bibliothèque de types générée. Pour le faire automatiquement, activez l’option correspondante dans les Propriétés du projet.
  </Step>

  <Step title="Appeler le composant depuis le code d’export">
    Depuis le code d’export, appelez la méthode du composant de la manière habituelle, comme dans l’exemple suivant.
  </Step>
</Steps>

Le script VBScript suivant appelle le composant :

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

L’appel JScript équivalent :

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

Le code C# suivant implémente un tel composant :

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

namespace ExportLibrary1
{
    // L'interface du composant d'exportation accessible depuis le script
    // Lors de la création d'un nouveau composant, générez un nouveau GUID
    [Guid("32B10C3B-EEA3-4194-B0A0-E358C310225A")]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    public interface _cExport
    {
        [DispId(1)]
        void ExportDocument(ref IExportDocument DocRef, ref FCTools Tools);
    }

    // La classe qui implémente les fonctionnalités du composant d'exportation
    // Lors de la création d'un nouveau composant, générez un nouveau GUID
    // et définissez votre ProgId
    [Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
    [ClassInterface(ClassInterfaceType.None)]
    [ProgId("ExportLibrary1.Export")]
    [ComVisible(true)]
    public class Export : _cExport
    {
        public Export()
        {
        }

        // La fonction effectue l'exportation du document : crée un dossier d'exportation et
        // y enregistre les fichiers d'image de page,
        // le fichier texte avec les champs du document, ainsi que les informations sur le document
        public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )
        {
            try
            {
                string exportFolder = createExportFolder( docRef.DefinitionName );
                exportImages( docRef, FCTools, exportFolder );

                // création du fichier texte
                string fileName = exportFolder + "//" + "doc.txt";
                StreamWriter sw = File.CreateText( fileName );

                // exportation des informations sur le document
                exportDocInfo( docRef, sw );

                // exportation des champs
                sw.WriteLine( "Fields:" );
                exportFields( docRef.Children, sw, "" );
                sw.Close();
            }
            catch( Exception e )
            {
                docRef.Action.Succeeded = false;
                docRef.Action.ErrorMessage = e.ToString();
            }
        }

        // La fonction crée un dossier d'exportation et renvoie le chemin complet vers ce dossier
        private string createExportFolder(string definitionName )
        {
            string docFolder, folderName;

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

            // le dossier de la définition de document spécifiée
            docFolder = exportFolder + "\\" + definitionName;
            if( !Directory.Exists(docFolder) )
            {
                Directory.CreateDirectory( docFolder );
            }

            // le dossier du document exporté
            int i = 1;
            folderName = docFolder + "\\" + i;
            while( Directory.Exists(folderName) )
            {
                i++;
                folderName = docFolder + "\\" + i;
            }
            Directory.CreateDirectory(folderName);
            return folderName;
        }

        // Fonction d'exportation des images
        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++;
            }
        }

        // Exportation des informations sur le document
        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();
        }

        // Exportation de la collection de champs
        private void exportFields( IExportFields fields, StreamWriter sw, string indent )
        {
            foreach( IExportField curField in fields )
            {
                exportField( curField, sw, indent );
            }
        }

        // Vérifie si la valeur du champ est nulle
        // Si la valeur du champ est invalide, toute tentative d'accès à ce champ (même
        // pour vérifier si elle est nulle) peut lever une exception
        private bool IsNullFieldValue( IExportField field )
        {
            try
            {
                return ( field.Value == null );
            }
            catch( Exception e )
            {
                return true;
            }
        }

        // Exportation du champ spécifié
        private void exportField( IExportField field, StreamWriter sw, string indent )
        {
            // enregistrement du nom du champ
            sw.Write( indent + field.Name );

            // enregistrement de la valeur du champ si elle est accessible
            if( IsNullFieldValue( field ) )
            {
                sw.WriteLine();
            }
            else
            {
                sw.WriteLine( "    " + field.Text );
            }

            if( field.Children != null )
            {
                // exportation des champs enfants
                exportFields( field.Children, sw, indent + "    " );
            }
            else if( field.Items != null )
            {
                // exportation des instances de champ
                exportFields( field.Items, sw, indent + "    " );
            }
        }
    }
}
```

<div id="write-an-export-handler">
  ## Écrire un gestionnaire d’export
</div>

Cet exemple présente un gestionnaire d’export simple qui enregistre dans des fichiers texte des informations sur les documents exportés et les résultats d’export. Il utilise deux fichiers texte : l’un pour la liste des documents exportés avec succès, l’autre pour la liste des documents pour lesquels des erreurs se sont produites lors de l’export.

L’exemple VBScript suivant traite les résultats d’export :

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

' création du fichier pour les documents en échec
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )

' création du fichier pour les documents exportés avec succès
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo

' parcours de la collection de documents exportés
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
```

L’exemple JScript équivalent :

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

// création du fichier avec les documents en échec
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );

// création du fichier avec les documents exportés avec succès
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i

// itération de la collection de documents exportés
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">
  ## Accéder aux fichiers source dans des formats Office courants
</div>

Cet exemple de script enregistre les fichiers source lors de l’exportation des documents. Les fichiers source doivent être dans l’un des [formats Office courants pris en charge](/fr/flexi-capture/appendix/input-formats) et porter des noms uniques afin d’éviter tout conflit de noms.

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

// Parcourir les pages.
for( int i = 0; i<Document.Pages.Count; i++ ) {
    IPage page = Document.Pages[i];

    // Vérifier s'il existe un fichier source.
    if( page.SourceFileGUID == "" ) {
        continue;
    }

    // Le nom d'origine du fichier.
    string sourceFileName = @"";

    // Indiquer le nom de fichier d'origine.
    if( page.ImageSourceType == @"File" ) {
        sourceFileName = Path.GetFileName( page.ImageSource );
    } else if( page.ImageSourceType == @"Scanner" || page.ImageSourceType == @"Custom" ) {
        sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );
    }

    // Supprimer l'extension du nom de fichier.
    if( sourceFileName != @"" ) {
        sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";
    }

    // Nom de fichier source unique (nom d'origine + guid).
    string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;

    // Chemin vers le dossier où le fichier source doit être enregistré.
    string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;

    // Vérifier que le fichier n'existe pas.
    if( File.Exists( sourceFilePath ) ) {
        continue;
    }

    // Enregistrer le fichier.
    Processing.ReportMessage( "Saving source file: " + sourceFileUniqueName );
    page.SaveSourceFile( sourceFilePath );
}
```