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

# Arbeiten mit verknüpfbaren Objekten

> Verknüpfbare Objekte in ABBYY FineReader Engine implementieren IConnectionPointContainer für Callbacks zwischen FRE und Clientanwendungen, mit Dispatch- und vtbl-basierten Schnittstellen unter Windows.

Einige der Objekte in ABBYY FineReader Engine sind sogenannte „verknüpfbare Objekte“. Das bedeutet, dass sie die Schnittstelle IConnectionPointContainer implementieren. Verknüpfbare Objekte unterstützen die Kommunikation zwischen ABBYY FineReader Engine und seinen Clientanwendungen.

<Warning>
  Unter Linux unterstützt das als Out-of-Process-Server geladene [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt die Arbeit mit Callbacks nicht.
</Warning>

<Note>
  Für Windows-Benutzer stellt jedes der verknüpfbaren FRE-Objekte Verbindungspunkte von zwei Typen bereit — einen mit einer Dispatch-Schnittstelle und einen mit einer von IUnknown abgeleiteten Schnittstelle. Die Dispatch-Schnittstelle ist für die automatische Verwendung in Visual Basic und ähnlichen Umgebungen vorgesehen, während die vtbl-basierte Schnittstelle für den Einsatz in C++ geeignet ist.
</Note>

In der folgenden Tabelle finden Sie die Liste der verknüpfbaren Objekte in ABBYY FineReader Engine und die entsprechenden Callback-Schnittstellen (Dispinterfaces):

<Note>
  Dispinterfaces sind Windows-spezifisch.
</Note>

| Objekt                                                                                    | Callback-Schnittstelle (Dispinterface)                                                                                                                                                                       |
| ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument)    | [IFRDocumentEvents](/de/fine-reader/engine/api-reference/document-related-objects/ifrdocumentevents) [](/de/fine-reader/engine/api-reference/document-related-objects/ifrdocumentevents)(DIFRDocumentEvents) |
| [FRPages](/de/fine-reader/engine/api-reference/document-related-objects/frpages)          | [IFRPagesEvents](/de/fine-reader/engine/api-reference/document-related-objects/ifrpagesevents) (DIFRPagesEvents)                                                                                             |
| [FRPage](/de/fine-reader/engine/api-reference/document-related-objects/frpage)            | [IFRPageEvents](/de/fine-reader/engine/api-reference/document-related-objects/ifrpageevents) (DIFRPageEvents)                                                                                                |
| [ImageDocument](/de/fine-reader/engine/api-reference/image-related-objects/imagedocument) | [IImageDocumentEvents](/de/fine-reader/engine/api-reference/image-related-objects/iimagedocumentevents) (DIImageDocumentEvents)                                                                              |

Windows Visual Components

| Objekt                                                                                                                  | Callback-Schnittstelle (Dispinterface)                                                                                                                                |
| ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [ImageViewer](/de/fine-reader/engine/visual-components-reference/imageviewer)                                           | [IImageViewerEvents (DIImageViewerEvents)](/de/fine-reader/engine/visual-components-reference/iimageviewerevents)                                                     |
| [ZoomViewer](/de/fine-reader/engine/visual-components-reference/zoomviewer)                                             | [IZoomViewerEvents (DIZoomViewerEvents)](/de/fine-reader/engine/visual-components-reference/izoomviewerevents)                                                        |
| [DocumentViewer](/de/fine-reader/engine/visual-components-reference/documentviewer)                                     | [IDocumentViewerEvents (DIDocumentViewerEvents)](/de/fine-reader/engine/visual-components-reference/idocumentviewerevents)                                            |
| [TextEditor](/de/fine-reader/engine/visual-components-reference/texteditor)                                             | [ITextEditorEvents (DITextEditorEvents)](/de/fine-reader/engine/visual-components-reference/itexteditorevents)                                                        |
| [TextValidator](/de/fine-reader/engine/visual-components-reference/textvalidator)                                       | [ITextValidatorEvents (DITextValidatorEvents)](/de/fine-reader/engine/visual-components-reference/itextvalidatorevents)                                               |
| [ComponentSynchronizer](/de/fine-reader/engine/visual-components-reference/supplementary-objects/componentsynchronizer) | [IComponentSynchronizerEvents (DIComponentSynchronizerEvents)](/de/fine-reader/engine/visual-components-reference/supplementary-objects/icomponentsynchronizerevents) |
| [Commands](/de/fine-reader/engine/visual-components-reference/supplementary-objects/commands)                           | [ICommandEvents (DICommandEvents)](/de/fine-reader/engine/visual-components-reference/supplementary-objects/icommandevents)                                           |

Eine ABBYY FineReader Engine-Clientanwendung, die Benachrichtigungen über bestimmte Ereignisse in ABBYY FineReader Engine erhalten möchte, sollte Schnittstellen eines bestimmten Typs implementieren und die Objekte, die diese Schnittstellen implementieren, bei den entsprechenden verknüpfbaren Objekten „registrieren“.

<Accordion title="Für Linux und macOS">
  Es gibt zwei globale Methoden zum Verbinden und Trennen der Verbindung mit der Benachrichtigungsquelle:

  ```csharp theme={null}
  HRESULT AdviseFREngineObject( IUnknown* object, IUnknown* callback, DWORD* cookie );
  HRESULT UnAdviseFREngineObject( IUnknown* object, DWORD cookie );
  class CFRDocumentCallback: public IFRDocumentEvents {
  public:
  ...
      // Einfache Implementierung der IUnknown-Methoden bereitstellen
      ULONG STDMETHODCALLTYPE AddRef() { return 1; }
      ULONG STDMETHODCALLTYPE Release() { return 1; }
      HRESULT STDMETHODCALLTYPE QueryInterface( REFIID riid, void** ppObject )
      {
          if( ppObject == 0 ) {
              return E_POINTER;
          }
      *ppObject = 0;
      if( riid == IID_IUnknown || riid == IID_IFRDocumentEvents )
      {
          *ppObject = this;
          AddRef();
          return S_OK;
      } else {
          return E_NOINTERFACE;
      }
  }
  // Implementierung der IFRDocumentEvents-Methoden bereitstellen
  HRESULT STDMETHODCALLTYPE OnProgress(
  IFRDocument* sender, int percentage, VARIANT_BOOL* cancel );
  HRESULT STDMETHODCALLTYPE OnWarning(
  IFRDocument* sender, int index, BSTR tip, VARIANT_BOOL* cancel );
  HRESULT STDMETHODCALLTYPE OnPageProcessed(
      IFRDocument* sender, int index, PageProcessingStageEnum stage ) { return S_OK; }
  };
  // Annahme: Das FRDocument-Objekt wurde bereits empfangen
  IFRDocument* document;
  // Callback-Objekt erstellen
  CFRDocumentCallback callbackObject;
  // Listener mit der Benachrichtigungsquelle verbinden
  DWORD cookie; // Eine Variable zum Speichern des vom Advise-Aufruf zurückgegebenen Cookies
  AdviseFREngineObject( frDocument, &callbackObject, &cookie );
  // Dokument verarbeiten
  ...
  // Nach der Benachrichtigung wird der Listener nicht mehr benötigt und sollte abgemeldet werden
  UnadviseFREngineObject( frDocument, cookie );
  ```

  Diese Methoden erwarten eines der verknüpfbaren Objekte als `object`-Argument und die entsprechende Callback-Schnittstelle als `callback`-Argument.

  Sie müssen die erforderliche Schnittstelle implementieren und das die Schnittstelle implementierende Objekt bei den entsprechenden verknüpfbaren Objekten „registrieren". Als Beispiel verwenden wir das FRDocument-Objekt.

  1. Implementieren Sie die IFRDocumentEvents-Schnittstelle. Da sie von der IUnknown-Schnittstelle abgeleitet ist, muss das Client-Objekt auch die IUnknown-Methoden implementieren:

  2. Anschließend kann die CFRDocumentCallback-Klasse verwendet werden, um Benachrichtigungen vom FRDocument-Objekt zu empfangen. Registrieren Sie dieses Objekt bei der Benachrichtigungsquelle (Fehlerbehandlung wird der Übersichtlichkeit halber weggelassen):

  Linux-Benutzer können auch das Beispiel [EventsHandling](/de/fine-reader/engine/guided-tour/samples#eventshandling) zu Rate ziehen.

  <Note>
    Der Rest dieses Themas gilt für Benutzer von FRE für Windows.
  </Note>
</Accordion>

Für Windows:

<Accordion title="Visual Basic .NET">
  Deklarieren Sie das verknüpfbare Objekt einfach mit `WithEvents` und implementieren Sie die Methoden der entsprechenden Callback-Schnittstelle. Außerdem müssen Sie den dem Ereignis zugeordneten Ereignishandler explizit angeben.

  Für das FRDocument-Objekt ist die Vorgehensweise wie folgt:

  1. Deklarieren Sie das FRDocument-Objekt mit `WithEvents`:

  ```vb theme={null}
  Private WithEvents document As FREngine.FRDocument
  Private Sub document_RecognitionOnProgress(ByVal sender As FREngine.FRDocument, _
                                             ByVal Percentage As Integer, _
                                             ByRef cancel As Boolean)
  ...
  End Sub
  Private Sub document_RecognitionOnProgress(ByVal sender As FREngine.FRDocument, _
                                             ByVal Percentage As Integer, _
                                             ByRef cancel As Boolean) Handles document.OnProgress
  ...
  End Sub
  document = Engine.CreateFRDocument
  document.AddImageFile("D:\Demo.tif")
  AddHandler document.OnProgress, AddressOf Me.document_RecognitionOnProgress
  document.Process()
  RemoveHandler document.OnProgress, AddressOf Me.document_RecognitionOnProgress
  or simply use the FRDocument object for processing if you define the event handling methods with Handles keyword:
  document = Engine.CreateFRDocument
  document.AddImageFile("D:\Demo.tif")
  document.Process()
  ```

  2. Implementieren Sie die erforderlichen Methoden der DIFRDocumentEvents-Dispatch-Schnittstelle in einer `Sub` ähnlich der folgenden.

  Wenn Sie die Ereignisbehandlung zu einem beliebigen Zeitpunkt während der Programmausführung starten und beenden möchten (mithilfe der Anweisungen `AddHandler` und `RemoveHandler`):

  oder geben Sie einfach an, dass diese Prozedur ein bestimmtes Ereignis behandelt (verwenden Sie das Schlüsselwort `Handles` bei der Definition):

  3. Verbinden Sie den implementierten Ereignishandler mit der Ereignisquelle, verwenden Sie das FRDocument-Objekt zur Verarbeitung, und trennen Sie anschließend den Handler:
</Accordion>

<Accordion title="C++">
  In C++ müssen Sie die erforderliche Schnittstelle implementieren, einen Verbindungspunkt abrufen und das Objekt, das die Schnittstelle implementiert, bei den entsprechenden verknüpfbaren Objekten registrieren („advise“). Wir verwenden das FRDocument-Objekt als Beispiel.

  1. Implementieren Sie die Schnittstelle IFRDocumentEvents. Da sie von der Schnittstelle IUnknown abgeleitet ist, sollte das Client-Objekt auch die IUnknown-Methoden implementieren:

  ```cpp theme={null}
  class CFRDocumentEventsListener : public IFRDocumentEvents {
  public:
  ...
      // Einfache Implementierung der IUnknown-Methoden bereitstellen. Sie können auch
      // durch Vererbung von einer Standardklasse mit COM-Unterstützung implementiert werden
      ULONG AddRef();
      ULONG Release();
      HRESULT QueryInterface(REFIID riid, void** ppvObject)
      {
          if( ppvObject == 0 )
              return E_INVALIDARG;
          if( riid == __uuidof(IFRDocumentEvents) ) {
              *ppvObject = static_cast<IFRDocumentEvents*>( this );
          } else if( riid == IID_IUnknown ) {
              *ppvObject = static_cast<IUnknown*>( this );
          } else {
              *ppvObject = 0;
              return E_NOINTERFACE;
          }
          AddRef();
          return S_OK;
      }
      // Implementierung der IFRDocumentEvents-Methoden bereitstellen
   HRESULT STDMETHODCALLTYPE OnProgress(
    IFRDocument* sender, int percentage, VARIANT_BOOL* cancel );
   HRESULT STDMETHODCALLTYPE OnWarning(
    IFRDocument* sender, int index, BSTR tip, VARIANT_BOOL* cancel );
   HRESULT STDMETHODCALLTYPE OnPageProcessed(
    IFRDocument* sender, int index, PageProcessingStageEnum stage ) { return S_OK; }
  };
  // Angenommen, wir haben das FRDocument-Objekt bereits erhalten
  IFRDocument* document;
  // IConnectionPointContainer für das FRDocument-Objekt abfragen
  IConnectionPointContainer* pContainer=0;
  document->QueryInterface(IID_IConnectionPointContainer, (void**)&pContainer);
  // Einen Zeiger auf die Schnittstelle IConnectionPoint an einem Verbindungspunkt innerhalb des verknüpfbaren Objekts abrufen
  IConnectionPoint* pPoint=0;
  pContainer->FindConnectionPoint(__uuidof(IFRDocumentEvents),
                                  &pPoint);
  // Eine Verbindung zwischen der Klasse CFRDocumentEventsListener und dem Verbindungspunkt herstellen
  CFRDocumentEventsListener listener;
  IUnknown* listenerUnknown=0;
  listener.QueryInterface(IID_IUnknown, (void**)&listenerUnknown);
  // Listener bei der Benachrichtigungsquelle registrieren
  DWORD cookie; // Eine Variable zum Speichern des von der Methode IConnectionPoint::Advise zurückgegebenen Cookie-Werts
  pPoint->Advise(listenerUnknown, &cookie);
  // Das Dokument verarbeiten
  ...
  // Nach der Benachrichtigung wird der Listener nicht mehr benötigt und sollte deregistriert werden
  pPoint->Unadvise(cookie);
  ```

  2. Die Klasse CFRDocumentEventsListener kann dann verwendet werden, um Benachrichtigungen vom FRDocument-Objekt zu empfangen. Registrieren Sie dieses Objekt bei der Benachrichtigungsquelle (die Fehlerbehandlung ist ausgelassen):
</Accordion>

<Accordion title="C#">
  Das Verfahren in C# ist ähnlich wie in Visual Basic .NET. Sie müssen die erforderlichen Methoden der Callback-Schnittstelle implementieren und die implementierten Ereignishandler mit der Ereignisquelle verbinden. Wir verwenden das FRDocument-Objekt als Beispiel.

  1. Implementieren Sie die erforderlichen Methoden der Schnittstelle IFRDocumentEvents:

  ```csharp theme={null}
  private void document_RecognitionOnProgress(FREngine.IFRDocument sender, int Percentage, ref bool cancel)
  {
   ...
  }
  FREngine.DIFRDocumentEvents_OnProgressEventHandler recognizeOnProgressHandler =
   new FREngine.DIFRDocumentEvents_OnProgressEventHandler(
   document_RecognitionOnProgress );
  document.OnProgress += recognizeOnProgressHandler;
  document.Process( null, null, null );
  document.OnProgress -= recognizeOnProgressHandler;
  ```

  2. Verbinden Sie den Ereignishandler mit der Ereignisquelle, verwenden Sie das FRDocument-Objekt für die Verarbeitung und trennen Sie den Handler anschließend wieder:
</Accordion>

Windows-Benutzer sollten die COM-Dokumentation konsultieren, um eine ausführlichere Beschreibung verknüpfbarer Objekte zu erhalten.

Sie können auch das Beispiel [EventsHandling](/de/fine-reader/engine/guided-tour/samples#eventshandling) verwenden, das in FRE für Linux für C++ sowie für Windows für C#, C++ mit Native COM Support, Raw C++ und Visual Basic .NET bereitgestellt wird.