> ## 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 Eigenschaften
> Arbeiten Sie mit ABBYY FineReader Engine-Eigenschaften — VARIANT_BOOL-, Integer-, string- und object-Typen — unter Verwendung von get/put-Methoden in C++ unter Linux/macOS oder der Eigenschaftssyntax unter Windows.
Die Schnittstellen von ABBYY FineReader Engine-Objekten verfügen über verschiedene Eigenschaften und Methoden. Im Allgemeinen enthalten Eigenschaften Informationen über ein Objekt, während Methoden Aktionen darstellen, die ein Objekt ausführen kann.
C#-Beispiele gelten für Windows. C++-Beispiele gelten für alle unterstützten Betriebssysteme.
Für C++ ist eine Eigenschaft ein Methodenpaar (get und put für Lese-/Schreibeigenschaften) oder eine einzelne get-Methode (für Eigenschaften, die nur lesbar sind).
Die Eigenschaften von ABBYY FineReader Engine können die folgenden Typen haben:
* VARIANT\_BOOL (mit den beiden Werten VARIANT\_TRUE oder VARIANT\_FALSE)
* int
* double
* BSTR, ein Zeiger auf eine Unicode-Zeichenfolge. Der Nullwert steht für eine leere Zeichenfolge.
* \_\_int64
* HANDLE\*
* Von IUnknown abgeleitete Schnittstelle
* enum
C#- und Visual Basic-Benutzer sind mit dem Konzept von Eigenschaften vertraut.
Für einen C++-Benutzer ist eine Eigenschaft ein Methodenpaar (get und put für Lese-/Schreibeigenschaften) oder eine einzelne get-Methode (für Eigenschaften, die nur lesbar sind).
Die von Microsoft C++ bereitgestellte Funktion „Native COM-Unterstützung“ sorgt jedoch dafür, dass Eigenschaften eher so behandelt werden wie in C#.
Die Eigenschaften von ABBYY FineReader Engine können die folgenden Typen haben:
| IDL | C++ | C# | Visual Basic .NET |
| ----------------------------------------------------------------------------------------------- | ------------------------------------------------- | ---------------------- | ------------------------- |
| VARIANT\_BOOL (VARIANT\_TRUE oder VARIANT\_FALSE) | VARIANT\_BOOL (VARIANT\_TRUE oder VARIANT\_FALSE) | bool (true oder false) | Boolean (True oder False) |
| int | int | int | Integer |
| double | double | double | Double |
| BSTR, ein Zeiger auf eine Unicode-Zeichenfolge. Der Nullwert steht für eine leere Zeichenfolge. | BSTR | string | String |
| \_\_int64 | \_\_int64 | Int64 | Int64 |
| HANDLE\* | void\* | IntPtr | IntPtr |
| Von IUnknown abgeleitete Schnittstelle | Von IUnknown abgeleitete Schnittstelle | object | Object |
| enum | enum | enum | Enum |
Im Folgenden finden Sie Details zur Arbeit mit verschiedenen Eigenschaftstypen:
Anhand einer booleschen Eigenschaft zeigen wir, wie einfache Eigenschaften verwendet werden. Die Eigenschaft wird in der Typbibliothek wie folgt beschrieben:
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT MyProperty( [out, retval] VARIANT_BOOL* result );
[propput]
HRESULT MyProperty( [in] VARIANT_BOOL value );
};
```
Wenn die Typbibliothek für eine einfache Eigenschaft nur die Methode „get“ definiert, wird diese Eigenschaft als nur lesbar bezeichnet. Ihr Wert kann vom Benutzer nicht geändert werden; es kann nur lesend darauf zugegriffen werden.
Ein C#-Benutzer arbeitet mit einer einfachen Eigenschaft wie folgt:
```csharp theme={null}
if (MyObject.MyProperty != true)
MyObject.MyProperty = true;
```
Ein C++-Benutzer hingegen verwendet zwei Methoden, um mit dieser Eigenschaft zu arbeiten. Diese Methoden haben die Präfixe get\_ und put\_. Der entsprechende C++-Code sollte wie folgt aussehen:
```cpp theme={null}
IMyObject* pMyObject;
VARIANT_BOOL res;
pMyObject->get_MyProperty(&res);
if( res != VARIANT_TRUE )
pMyObject->put_MyProperty(VARIANT_TRUE);
```
Die Native COM-Unterstützung in Windows vereinfacht das Verfahren jedoch, und der entsprechende Code sollte wie folgt aussehen:
```cpp theme={null}
IMyObjectPtr pMyObject;
if(pMyObject->MyProperty != VARIANT_TRUE)
pMyObject->MyProperty = VARIANT_TRUE
```
Das Arbeiten mit String-Eigenschaften ähnelt dem Arbeiten mit einfachen Eigenschaften, weist jedoch eigene Besonderheiten auf. Ein C++-Entwickler, der mit String-Eigenschaften arbeitet, muss die Strings freigeben, die an Set-Methoden übergeben werden, sowie jene, die von Get-Methoden zurückgegeben werden.
* Unter Windows geschieht dies automatisch in C#, Visual Basic und in C++ mit nativer COM-Unterstützung.
* Unter Linux verwenden Sie die Funktionen FREngineAllocString und FREngineFreeString, um den Speicher für die Strings zu reservieren und freizugeben.
Angenommen, MyObject unterstützt auch eine String-Eigenschaft namens Name. Diese Eigenschaft wird in der Typbibliothek wie folgt beschrieben:
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT Name([out, retval]BSTR* result);
[propput]
HRESULT Name([in]BSTR value);
};
```
Ein C++-Entwickler arbeitet mit dieser Eigenschaft wie folgt:
**Windows**
```cpp theme={null}
IMyObject* pMyObject;
// "get"-Methode
BSTR res;
pMyObject->get_Name(&res);
// Jetzt den in ABBYY FineReader Engine reservierten String freigeben
::SysFreeString(res);
// "put"-Methode
BSTR str = ::SysAllocString(L"New Name");
pMyObject->put_Name(str);
// Jetzt den selbst reservierten String freigeben
::SysFreeString(str);
```
**Linux**
```cpp theme={null}
IMyObject* pMyObject;
// "get"-Methode
BSTR res;
pMyObject->get_Name(&res);
// Jetzt den in ABBYY FineReader Engine reservierten String freigeben
::FREngineFreeString(res);
// "put"-Methode
BSTR str = ::FREngineAllocString(L"New Name");
pMyObject->put_Name(str);
// Jetzt den selbst reservierten String freigeben
::FREngineFreeString(str);
```
Ein C++-Entwickler wird feststellen, dass die Parameter der „get"-Methoden von Objekteigenschaften Zeiger auf den Interface-Zeiger eines Objekts sind. Da die Interfaces der Objekte von IUnknown abgeleitet sind, können sie als IUnknown-Zeiger an Eigenschaften oder Methoden übergeben werden, die Objekte mehrerer Typen als Ein- oder Ausgabeparameter verwenden (das benötigte Interface lässt sich jedoch durch Aufruf der QueryInterface-Methode abrufen).
Eine „put"-Methode für eine Objekteigenschaft, sofern vorhanden, unterstützt Clear Put, das durch das Schlüsselwort propput in der Typbibliothek beschrieben wird. Das bedeutet, dass das Objekt kopiert wird, anstatt einen Zeiger auf das Interface eines vorhandenen Objekts zu übergeben.
Angenommen, das Objekt MyObject unterstützt die Eigenschaft MyObjectProperty, die auf ein Objekt vom Typ MyChildObject verweist.
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT MyObjectProperty([out, retval]IMyChildObject** result);
[propput]
HRESULT MyObjectProperty([in]IMyChildObject* value);
};
```
Ein C++-Entwickler schreibt diesen Code wie folgt:
```cpp theme={null}
IMyObject* pMyObject;
IMyChildObject* pChildObj=0;
// get_-Methode kann in bestimmten Fällen 0 zurückgeben
pMyObject->get_MyObjectProperty(&pChildObj);
// Etwas mit dem Objekt tun
...
pMyObject->put_MyObjectProperty(pChildObj);
pChildObj->Release();
```
Beachten Sie, dass Sie in C++ die Release-Methode für ein über eine Eigenschaft erhaltenes Objekt aufrufen müssen. Die native COM-Unterstützung unter Windows ruft die Methoden AddRef und Release automatisch mithilfe von Auto-Zeigern auf.
## Arbeiten mit nur lesbaren Objekteigenschaften
Bestimmte Objekte in ABBYY FineReader Engine (zum Beispiel [ILayout::Blocks](/de/fine-reader/engine/api-reference/layout-related-objects/layout#blocks)) haben nur lesbare Objekteigenschaften. Das bedeutet nicht, dass solche Eigenschaften nicht geändert werden können, sondern nur, dass sie nicht geändert werden können, indem die Objekteigenschaft direkt durch ein anderes Objekt ersetzt wird, da die "put"-Methode nicht unterstützt wird. Die Untereigenschaften dieser Objekte können Sie jedoch ändern.
Wenn Sie in C++ (*natives C++ unter Windows*) eine solche Eigenschaft ändern möchten, müssen Sie eine Referenz auf das Eigenschaftsobjekt an eine neue Variable übergeben und diese Variable dann zum Ändern verwenden. Unten sehen Sie ein C++-Beispiel für die Eigenschaft ILayout::Blocks, die als nur lesbare Sammlung dargestellt wird:
```cpp theme={null}
// Wir gehen davon aus, dass eine Seite bereits geöffnet wurde
ILayout* pLayout = 0;
ILayoutBlocks* pLayoutBlocks = 0;
int blockIndex = 0;
// Layout von der zuvor geöffneten FRPage abrufen
pFRPage->get_Layout( &pLayout );
// Die Variable pLayoutBlocks erhält einen Verweis auf die Blocks-Sammlung aus dem Layout
pLayout->get_Blocks( &pLayoutBlocks );
// Ein Element aus der Block-Sammlung entfernen
pLayoutBlocks->DeleteAt( blockIndex );
// Mit dem geänderten Layout arbeiten
...
// Objekte freigeben
pLayoutBlocks->Release();
pLayout->Release();
```