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

# Barcoderkennung

> Verwenden Sie ABBYY FineReader Engine zum Lesen von Barcodes für die Dokumententrennung, Indizierung und Klassifizierung — passen Sie Geschwindigkeit und Genauigkeit mit dem Profil BarcodeRecognition an.

In diesem Szenario wird ABBYY FineReader Engine zum Lesen von Barcodes verwendet. Barcodes müssen beispielsweise für die automatische Documententrennung, für die Verarbeitung von Documenten durch ein Documentenmanagementsystem oder für die Indizierung und Klassifizierung von Documenten gelesen werden.

Dieses Szenario kann als Teil anderer Szenarien verwendet werden. Beispielsweise können mit Hochgeschwindigkeits-Produktionsscannern gescannte Documente mithilfe von Barcodes getrennt werden, oder für die Langzeitarchivierung vorbereitete Documente können anhand der Werte ihrer Barcodes in Archivierungs-Documentenmanagementsysteme eingeordnet werden.

Beim Extrahieren von Barcodes aus Texten kann das System alle Barcodes oder nur Barcodes eines bestimmten Typs mit einem bestimmten Wert erkennen. Das System kann den Wert eines Barcodes auslesen und seine Prüfsumme berechnen. So erzielen Sie bei der Barcoderkennung die schnellsten und zugleich qualitativ besten Ergebnisse:

1. Verwenden Sie Farbbilder mit einer optimalen Auflösung von 300 dpi.

2. Passen Sie die Erkennungsgeschwindigkeit mithilfe von Profilen an (weitere Informationen finden Sie unter [Arbeiten mit Profilen](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles)).

Erkannte Barcode-Werte können zur weiteren Verarbeitung in die jeweils am besten geeigneten Formate gespeichert werden, zum Beispiel in TXT."

<div id="scenario-implementation">
  ## Umsetzung des Szenarios
</div>

<Note>
  Die in diesem Thema bereitgestellten Codebeispiele sind Windows-spezifisch.
</Note>

Im Folgenden finden Sie eine ausführliche Beschreibung der empfohlenen Vorgehensweise für die Verwendung von ABBYY FineReader Engine 12 in diesem Szenario. Dabei werden Verarbeitungseinstellungen verwendet, die für dieses Szenario als besonders geeignet gelten.

<Accordion title="Schritt 1. ABBYY FineReader Engine laden">
  Um mit ABBYY FineReader Engine zu arbeiten, müssen Sie zunächst das [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt erstellen. Das Engine-Objekt steht an der Spitze der Hierarchie der ABBYY FineReader Engine-Objekte und stellt verschiedene globale Einstellungen, einige Verarbeitungsmethoden sowie Methoden zum Erstellen weiterer Objekte bereit.

  Um das Engine-Objekt zu erstellen, können Sie die Funktion [InitializeEngine](/de/fine-reader/engine/api-reference/functions/initializeengine-function) verwenden. Siehe auch [andere Möglichkeiten zum Laden des Engine-Objekts](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) (Win).

  ### C\#

  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      public EngineLoader()
      {
          // Initialisieren Sie diese Variablen mit dem vollständigen Pfad zu FREngine.dll, Ihrer Customer Project ID,
          // und ggf. dem Pfad zur Online License-Token-Datei und dem Online License-Kennwort
          string enginePath = "";
          string customerProjectId = "";
          string licensePath = "";
          string licensePassword = "";
          // FREngine.dll-Bibliothek laden
          dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
             
          try
          {
              if (dllHandle == IntPtr.Zero)
              {
                  throw new Exception("Laden nicht möglich: " + enginePath);
              }
              IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
              if (initializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("Funktion InitializeEngine nicht gefunden");
              }
              IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
              if (deinitializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("Funktion DeinitializeEngine nicht gefunden");
              }
              IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
              if (dllCanUnloadNowPtr == IntPtr.Zero)
              {
                  throw new Exception("Funktion DllCanUnloadNow nicht gefunden");
              }
              // Zeiger in Delegates umwandeln
              initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  initializeEnginePtr, typeof(InitializeEngine));
              deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  deinitializeEnginePtr, typeof(DeinitializeEngine));
              dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                  dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
              // InitializeEngine-Funktion aufrufen
              // und den Pfad zur Online License-Datei sowie das Online License-Kennwort übergeben
              int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                  "", "", false, ref engine);
              Marshal.ThrowExceptionForHR(hresult);
          }
          catch (Exception)
          {
              // FREngine.dll-Bibliothek freigeben
              engine = null;
              // Alle Objekte vor dem FreeLibrary-Aufruf löschen
              GC.Collect();
              GC.WaitForPendingFinalizers();
              GC.Collect();
              FreeLibrary(dllHandle);
              dllHandle = IntPtr.Zero;
              initializeEngine = null;
              deinitializeEngine = null;
              dllCanUnloadNow = null;
              throw;
          }
      }
      // Kernel32.dll-Funktionen
      [DllImport("kernel32.dll")]
      private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
      private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
      [DllImport("kernel32.dll")]
      private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
      [DllImport("kernel32.dll")]
      private static extern bool FreeLibrary(IntPtr hModule);
      // FREngine.dll-Funktionen
      [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
      private delegate int InitializeEngine(string customerProjectId, string licensePath, 
          string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, 
          ref FREngine.IEngine engine);
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DeinitializeEngine();
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DllCanUnloadNow();
      // Private Variablen
      private FREngine.IEngine engine = null;
      // Handle für FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Initialisieren Sie diese Variablen mit dem Pfad zu FREngine.dll, Ihrer FineReader Engine Customer Project ID
  // und ggf. dem Pfad zum Online License-Token und dem Online License-Kennwort
  wchar_t* FreDllPath;
  wchar_t* CustomerProjectId;
  wchar_t* LicensePath;  // wenn Sie keine Online License verwenden, weisen Sie diesen Variablen leere Strings zu
  wchar_t* LicensePassword;
  // HANDLE zu FREngine.dll
  static HMODULE libraryHandle = 0;
  // Globales FineReader Engine-Objekt
  FREngine::IEnginePtr Engine;
  void LoadFREngine()
  {
      if( Engine != 0 ) {
      // Bereits geladen
      return;
      }
      // Erster Schritt: FREngine.dll laden
      if( libraryHandle == 0 ) {
          libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
          if( libraryHandle == 0 ) {
              throw L"Fehler beim Laden von ABBYY FineReader Engine";
          }
      }
      // Zweiter Schritt: Engine-Objekt abrufen
      typedef HRESULT ( STDAPICALLTYPE* InitializeEngineFunc )( BSTR, BSTR, BSTR, BSTR, 
          BSTR, VARIANT_BOOL, FREngine::IEngine** );
      InitializeEngineFunc pInitializeEngine =
      ( InitializeEngineFunc )GetProcAddress( libraryHandle, "InitializeEngine" );
      if( pInitializeEngine == 0 || pInitializeEngine( CustomerProjectId, LicensePath, 
          LicensePassword, L"", L"", VARIANT_FALSE, &Engine ) != S_OK ) {
      UnloadFREngine();
      throw L"Fehler beim Laden von ABBYY FineReader Engine";
      }
  }
  ```
</Accordion>

<Accordion title="Schritt 2. Einstellungen für das Szenario laden">
  Die am besten geeigneten Einstellungen lassen sich mit der Methode [LoadPredefinedProfile](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/loadpredefinedprofile-method) des [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekts auswählen. Diese Methode übernimmt den Namen des verwendeten Einstellungsprofils als Eingabeparameter. Weitere Informationen zu Profilen finden Sie unter [Arbeiten mit Profilen](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles).

  ABBYY FineReader Engine unterstützt für dieses Szenario 2 Einstellungsvarianten:

  | Profilname                   | Beschreibung                                                                                                                                                                                                                                                                                                                   |
  | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
  | BarcodeRecognition\_Accuracy | Extrahiert nur Barcodes (Texte, Bilder oder Tabellen werden nicht erkannt). Die Einstellungen sind auf maximale Genauigkeit optimiert. <Warning> Dieses Profil erfordert das in der Lizenz verfügbare Modul [Barcode Autolocation](/de/fine-reader/engine/licensing/modules#barcode_autolocation). </Warning>                  |
  | BarcodeRecognition\_Speed    | Extrahiert nur Barcodes (Texte, Bilder oder Tabellen werden nicht erkannt). Die Einstellungen sind auf maximale Verarbeitungsgeschwindigkeit optimiert. <Warning> Dieses Profil erfordert das in der Lizenz verfügbare Modul [Barcode Autolocation](/de/fine-reader/engine/licensing/modules#barcode_autolocation). </Warning> |

  ### C\#

  ```csharp theme={null}
  // Ein vordefiniertes Profil laden
  engine.LoadPredefinedProfile("BarcodeRecognition_Speed");
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Ein vordefiniertes Profil laden
  Engine->LoadPredefinedProfile( L"BarcodeRecognition_Speed" );
  ```

  Wenn Sie die für die Verarbeitung verwendeten Einstellungen ändern möchten, verwenden Sie die entsprechenden Parameter-Objekte. Weitere Informationen finden Sie weiter unten im Abschnitt [Zusätzliche Optimierung](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition#optimization).
</Accordion>

<Accordion title="Schritt 3. Bilder laden und vorverarbeiten">
  ABBYY FineReader Engine stellt für die Verarbeitung mehrseitiger Documente ein [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument)-Objekt bereit. Um die Bilder eines Documents zu laden und vorzuverarbeiten, erstellen Sie das FRDocument-Objekt und fügen ihm Bilder hinzu. Dazu haben Sie folgende Möglichkeiten:

  * Erstellen Sie ein FRDocument-Objekt mit der Methode [CreateFRDocumentFromImage](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) des Engine-Objekts. Diese Methode erstellt ein FRDocument-Objekt und lädt Bilder aus einer angegebenen Datei.
  * Erstellen Sie ein FRDocument-Objekt mit der Methode [CreateFRDocument](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) des Engine-Objekts und fügen Sie anschließend Bilder aus einer Datei zum erstellten FRDocument-Objekt hinzu (verwenden Sie dazu die Methode [AddImageFile](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefile-method), [AddImageFileWithPassword](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpassword-method) oder [AddImageFileWithPasswordCallback](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpasswordcallback-method) des FRDocument-Objekts).

  ### C\#

  ```csharp theme={null}
  // Das FRDocument-Objekt aus einer Bilddatei erstellen
  FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Eine Bilddatei öffnen und das FRDocument-Objekt erstellen
  FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
  ```
</Accordion>

<Accordion title="Schritt 4. Barcodes extrahieren">
  Wenn das Profil BarcodeRecognition geladen ist, können Sie die Methode [Process](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method) des Objekts FRDocument verwenden, um ausschließlich Barcodes zu extrahieren. In diesem Fall erkennt ABBYY FineReader Engine nur Blöcke mit Barcodes. Andere Blöcke werden nicht erkannt. Auf die erkannten Barcode-Blöcke können Sie über das Objekt [Layout](/de/fine-reader/engine/api-reference/layout-related-objects/layout) zugreifen, ein Unterobjekt des Objekts [FRPage](/de/fine-reader/engine/api-reference/document-related-objects/frpage), das eine Seite des Documents repräsentiert.

  Um Barcodes eines bestimmten Typs zu lesen, geben Sie die entsprechenden Parameter des Objekts [BarcodeParams](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/barcodeparams) an und übergeben Sie das BarcodeParams-Objekt als Parameter an eine der oben genannten Funktionen.

  ### C\#

  ```csharp theme={null}
  // While the BarcodeRecognition profile is loaded,
  // you do not need to pass any additional parameters to the processing method,
  // if barcodes conform to specification
  frDocument.Process( null );
  // If you need to read barcodes of specific type
  // Create a DocumentProcessingParams object
  FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
  // Specify the necessary parameters
  dpp.PageProcessingParams.PageAnalysisParams.BarcodeParams.Type = ( int )FREngine.BarcodeTypeEnum.BT_Code39;
  // Now recognize barcodes with these parameters
  frDocument.Process( dpp );
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // While the BarcodeRecognition profile is loaded,
  // you do not need to pass any additional parameters to the processing method,
  // if barcodes conform to specification
  frDocument->Process( 0 );
  // If you need to read barcodes of specific type
  // Create a DocumentProcessingParams object
  FREngine::IDocumentProcessingParamsPtr params = Engine->CreateDocumentProcessingParams();
  // Specify the necessary parameters
  params->PageProcessingParams->PageAnalysisParams->BarcodeParams->Type = FREngine::BT_Code39;
  // Now recognize barcodes with these parameters
  frDocument->Process( params );
  ```
</Accordion>

<Accordion title="Schritt 5. Erkannte Daten exportieren">
  Um die Werte der erkannten Barcodes in einer Datei zu speichern, können Sie die Methode [Export](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) des Objekts [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument) verwenden, indem Sie die Konstante [FileExportFormatEnum](/de/fine-reader/engine/api-reference/enumerations/fileexportformatenum) als einen der Parameter angeben. In diesem Szenario ist beispielsweise ein Export in das TXT-Format möglich. Sie können die Standardparameter für den Export über das entsprechende Exportobjekt ändern. Weitere Informationen finden Sie weiter unten unter [Zusätzliche Optimierung für bestimmte Aufgaben](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition#optimization).

  Nachdem Sie die Arbeit mit dem Objekt FRDocument abgeschlossen haben, geben Sie alle von diesem Objekt verwendeten Ressourcen frei. Verwenden Sie dazu die Methode [IFRDocument::Close](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/close-method).

  ### C\#

  ```csharp theme={null}
  // Save recognized barcodes to some format (e.g., TXT)
  frDocument.Export( "C:\\barcodes.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
  // Release the FRDocument object
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Save recognized barcodes to some format (e.g., TXT)
  frDocument->Export( L"C:\\barcodes.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
  // Release the FRDocument object
  frDocument->Close();
  ```
</Accordion>

<Accordion title="Schritt 6. ABBYY FineReader Engine entladen">
  Nachdem Sie die Arbeit mit ABBYY FineReader Engine abgeschlossen haben, müssen Sie das [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt entladen. Verwenden Sie dazu die exportierte Funktion [DeinitializeEngine](/de/fine-reader/engine/api-reference/functions/deinitializeengine-function).

  ### C\#

  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      // FineReader Engine entladen
      public void Dispose()
      {
          if (engine == null)
          {
              // Engine wurde nicht geladen
              return;
          }
          engine = null;
          // Vor dem Aufruf von FreeLibrary alle Objekte löschen
          GC.Collect();
          GC.WaitForPendingFinalizers();
          GC.Collect();
          int hresult = deinitializeEngine();
   
          hresult = dllCanUnloadNow();
          if (hresult == 0)
          {
              FreeLibrary(dllHandle);
          }
          dllHandle = IntPtr.Zero;
          initializeEngine = null;
          deinitializeEngine = null;
          dllCanUnloadNow = null;
          // Ausnahme nach dem Bereinigen auslösen
          Marshal.ThrowExceptionForHR(hresult);
      }
      // Kernel32.dll-Funktionen
      [DllImport("kernel32.dll")]
      private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
      private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
      [DllImport("kernel32.dll")]
      private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
      [DllImport("kernel32.dll")]
      private static extern bool FreeLibrary(IntPtr hModule);
      // FREngine.dll-Funktionen
      [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
      private delegate int InitializeEngine( string customerProjectId, string LicensePath, string LicensePassword, , , , ref FREngine.IEngine engine);
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DeinitializeEngine();
      [UnmanagedFunctionPointer(CallingConvention.StdCall)]
      private delegate int DllCanUnloadNow();
      // Private Variablen
      private FREngine.IEngine engine = null;
      // Handle für FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```

  ### C++ (COM)

  ```cpp theme={null}
  void UnloadFREngine()
  {
   if( libraryHandle == 0 ) {
    return;
   }
   // Engine-Objekt freigeben
   Engine = 0;
   // FineReader Engine deinitialisieren
   typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )();
   DeinitializeEngineFunc pDeinitializeEngine =
    ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" );
   if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
    throw L"Fehler beim Entladen von ABBYY FineReader Engine";
   }
   // Jetzt kann die Bibliothek FREngine.dll sicher freigegeben werden
   FreeLibrary( libraryHandle );
   libraryHandle = 0;
  }
  ```
</Accordion>

<div id="required-resources">
  ## Erforderliche Ressourcen
</div>

Sie können die Datei [FREngineDistribution.csv](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) verwenden, um automatisch eine Liste der Dateien zu erstellen, die erforderlich sind, damit Ihre Anwendung funktioniert. Wählen Sie für die Verarbeitung in diesem Szenario in Spalte 5 (RequiredByModule) die folgenden Werte aus:

Core

Core.Resources

Opening

Opening, Processing

Processing

Processing.OCR

Processing.OCR, Processing.ICR

Processing.OCR.NaturalLanguages

Processing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguages

Export

Export, Processing

Wenn Sie das Standardszenario ändern, passen Sie die erforderlichen Module entsprechend an. Sie müssen außerdem die Sprachen der Benutzeroberfläche, die Erkennungssprachen und alle zusätzlichen Funktionen angeben, die Ihre Anwendung verwendet (wie z. B. Opening.PDF, wenn Sie PDF-Dateien öffnen müssen, oder Processing.OCR.CJK, wenn Sie Texte in [CJK-Sprachen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk) erkennen müssen). Weitere Einzelheiten finden Sie unter [Working with the FREngineDistribution.csv File](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file).

<div id="additional-optimization">
  ## Zusätzliche Optimierung
</div>

In den folgenden Abschnitten der Hilfedatei finden Sie zusätzliche Informationen zum Einrichten der Parameter für die verschiedenen Verarbeitungsstufen:

* Extrahieren und Lesen von Barcodes
  * [BarcodeParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/barcodeparams)<br />Mit diesem Objekt können Sie die Parameter für die Barcodeanalyse und das Lesen von Barcodes festlegen.
  * [Erkennen von Barcodes](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-barcodes)<br />Behandelt Sonderfälle bei der Barcodeerkennung und gibt Hinweise zur Arbeit mit Barcodes.
  * [Barcode-Typen](/de/fine-reader/engine/specifications/barcode-types)<br />Eine Liste der in ABBYY FineReader Engine 12 unterstützten Barcodes mit Kurzbeschreibungen.
  * [FRDocument-Objekt](/de/fine-reader/engine/api-reference/document-related-objects/frdocument)<br />Neben Barcodewerten müssen Sie möglicherweise weitere im Document enthaltene Informationen extrahieren. In diesem Fall können Sie die Methoden des FRDocument-Objekts verwenden.
  * [PageProcessingParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams)<br />Mit diesem Objekt können Sie Analyse- und Erkennungsparameter für das gesamte Document festlegen. Außerdem können Sie angeben, ob Barcodewerte erkannt werden sollen. Auf die Barcode-Leseparameter kann über die Eigenschaften BarcodeParams und DetectBarcodes des Unterobjekts PageAnalysisParams zugegriffen werden.
  * [Arbeiten mit Layout und Blöcken](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-layout-and-blocks)<br />Sie können Barcodeblöcke auch manuell markieren und ihre Analyse- und Leseparameter festlegen. Dieser Abschnitt enthält ausführliche Informationen zur Arbeit mit Blöcken.
* Arbeiten mit den erkannten Barcodewerten
  * [BarcodeBlock-Objekt](/de/fine-reader/engine/api-reference/layout-related-objects/barcodeblock)<br />Die Eigenschaften Text und BarcodeText dieses Objekts enthalten den durch die Erkennung ermittelten Barcodewert. Die anderen Eigenschaften dieses Objekts können verwendet werden, um den Typ des Barcodes, seine Orientierung und weitere Parameter abzurufen.
* Export
  * [Exportparameter optimieren](/de/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters)<br />Einrichten des Exports mithilfe von Exportparameterobjekten.
  * [TextExportParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/textexportparams)<br />Mit diesem Objekt können Sie das Speichern von Erkennungsergebnissen im TXT-Format festlegen.

<div id="see-also">
  ## Siehe auch
</div>

[Implementierung grundlegender Anwendungsszenarien](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)