> ## 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.
# Utilisation des propriétés
> Utilisez les propriétés d’ABBYY FineReader Engine — types VARIANT_BOOL, integer, string et objet — avec les méthodes get/put en C++ sous Linux/macOS ou avec la syntaxe de propriété sous Windows.
Les interfaces des objets ABBYY FineReader Engine comportent diverses propriétés et méthodes. En règle générale, les propriétés représentent des informations sur un objet, tandis que les méthodes correspondent aux actions qu’un objet peut effectuer.
Les exemples en C# s’appliquent à Windows. Les exemples en C++ s’appliquent à tous les systèmes d’exploitation pris en charge.
Pour un utilisateur C++, une propriété est constituée d’une paire de méthodes (get et put pour les propriétés en lecture-écriture) ou d’une seule méthode get (pour les propriétés en lecture seule).
Les propriétés d’ABBYY FineReader Engine peuvent être des types suivants :
* VARIANT\_BOOL (avec deux valeurs VARIANT\_TRUE ou VARIANT\_FALSE)
* int
* double
* BSTR, un pointeur vers une string Unicode. La valeur zéro indique une string vide.
* \_\_int64
* HANDLE\*
* interface dérivée de IUnknown
* enum
Les utilisateurs de C# et de Visual Basic connaissent bien la notion de propriété.
Pour un utilisateur C++, une propriété est constituée d’une paire de méthodes (get et put pour les propriétés en lecture-écriture) ou d’une seule méthode get (pour les propriétés en lecture seule).
Cependant, la fonctionnalité "Native COM support" de Microsoft C++ rend la gestion des propriétés plus proche de celle utilisée en C#.
Les propriétés d’ABBYY FineReader Engine peuvent être des types suivants :
| IDL | C++ | C# | Visual Basic .NET |
| ---------------------------------------------------------------------------------- | ----------------------------------------------- | -------------------- | ----------------------- |
| VARIANT\_BOOL (VARIANT\_TRUE ou VARIANT\_FALSE) | VARIANT\_BOOL (VARIANT\_TRUE ou VARIANT\_FALSE) | bool (true ou false) | Boolean (True or False) |
| int | int | int | Integer |
| double | double | double | Double |
| BSTR, un pointeur vers une string Unicode. La valeur zéro indique une string vide. | BSTR | string | String |
| \_\_int64 | \_\_int64 | Int64 | Int64 |
| HANDLE\* | void\* | IntPtr | IntPtr |
| interface dérivée de IUnknown | interface dérivée de IUnknown | objet | Object |
| enum | enum | enum | Enum |
Voir ci-dessous les détails relatifs à l’utilisation des différents types de propriétés :
Nous prendrons une propriété booléenne comme exemple pour montrer comment les propriétés simples sont utilisées. La propriété est décrite dans la bibliothèque de types comme suit :
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT MyProperty( [out, retval] VARIANT_BOOL* result );
[propput]
HRESULT MyProperty( [in] VARIANT_BOOL value );
};
```
Si la bibliothèque de types définit uniquement la méthode "get" pour une propriété simple, cette propriété est dite en lecture seule. Sa valeur ne peut pas être modifiée par l’utilisateur et peut uniquement être consultée en "lecture".
Un utilisateur C# manipule une propriété simple comme suit :
```csharp theme={null}
if (MyObject.MyProperty != true)
MyObject.MyProperty = true;
```
Un utilisateur C++, en revanche, utilise deux méthodes pour travailler avec cette propriété. Ces méthodes portent les préfixes get\_ et put\_. Le code C++ correspondant doit se présenter comme suit :
```cpp theme={null}
IMyObject* pMyObject;
VARIANT_BOOL res;
pMyObject->get_MyProperty(&res);
if( res != VARIANT_TRUE )
pMyObject->put_MyProperty(VARIANT_TRUE);
```
Cependant, la fonctionnalité Native COM support sous Windows simplifie la procédure, et le code correspondant doit se présenter comme suit :
```cpp theme={null}
IMyObjectPtr pMyObject;
if(pMyObject->MyProperty != VARIANT_TRUE)
pMyObject->MyProperty = VARIANT_TRUE
```
L’utilisation des propriétés `string` est très similaire à celle des propriétés simples, mais présente quelques particularités. En C++, l’utilisateur qui manipule des propriétés `string` doit libérer les chaînes passées aux méthodes set, ainsi que celles renvoyées par les méthodes get.
* Sous Windows, cela se fait automatiquement en C#, en Visual Basic et en C++ avec le Native COM support.
* Sous Linux, utilisez les fonctions FREngineAllocString et FREngineFreeString pour allouer et libérer la mémoire des chaînes.
Supposons que MyObject prenne également en charge une propriété `string` appelée Name. Cette propriété est décrite dans la bibliothèque de types comme suit :
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT Name([out, retval]BSTR* result);
[propput]
HRESULT Name([in]BSTR value);
};
```
En C++, cette propriété s’utilise comme suit :
**Windows**
```cpp theme={null}
IMyObject* pMyObject;
// méthode "get"
BSTR res;
pMyObject->get_Name(&res);
// Libérez maintenant la chaîne allouée dans ABBYY FineReader Engine
::SysFreeString(res);
// méthode "put"
BSTR str = ::SysAllocString(L"New Name");
pMyObject->put_Name(str);
// Libérez maintenant la chaîne que nous avons allouée
::SysFreeString(str);
```
**Linux**
```cpp theme={null}
IMyObject* pMyObject;
// méthode "get"
BSTR res;
pMyObject->get_Name(&res);
// Libérez maintenant la chaîne allouée dans ABBYY FineReader Engine
::FREngineFreeString(res);
// méthode "put"
BSTR str = ::FREngineAllocString(L"New Name");
pMyObject->put_Name(str);
// Libérez maintenant la chaîne que nous avons allouée
::FREngineFreeString(str);
```
En C++, on dira que les paramètres des méthodes "get" des propriétés d’objet sont des pointeurs vers un pointeur d’interface d’objet. Comme les interfaces des objets dérivent de IUnknown, elles peuvent être transmises sous forme de pointeurs IUnknown aux propriétés ou méthodes qui utilisent des objets de plusieurs types comme paramètres d’entrée ou de sortie (vous pouvez toutefois obtenir l’interface dont vous avez besoin en appelant la méthode QueryInterface).
S’il existe une méthode "put" pour une propriété d’objet, elle prend en charge le clear put, décrit par le mot-clé propput dans la bibliothèque de types. Cela signifie que l’objet est copié (au lieu de transmettre un pointeur vers l’interface d’un objet existant).
Supposons de nouveau que l’objet MyObject prenne en charge la propriété MyObjectProperty, qui fait référence à un objet de type MyChildObject.
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT MyObjectProperty([out, retval]IMyChildObject** result);
[propput]
HRESULT MyObjectProperty([in]IMyChildObject* value);
};
```
En C++, ce code s’écrit comme suit :
```cpp theme={null}
IMyObject* pMyObject;
IMyChildObject* pChildObj=0;
// la méthode get_ peut renvoyer 0 dans certains cas
pMyObject->get_MyObjectProperty(&pChildObj);
// Faire quelque chose avec l’objet
...
pMyObject->put_MyObjectProperty(pChildObj);
pChildObj->Release();
```
Notez qu’en C++, vous devez appeler la méthode Release pour un objet obtenu via une propriété. Le Native COM support sous Windows appelle automatiquement les méthodes AddRef et Release à l’aide de pointeurs automatiques.
## Utilisation des propriétés d’objet en lecture seule
Certains objets ABBYY FineReader Engine (par exemple, [ILayout::Blocks](/fr/fine-reader/engine/api-reference/layout-related-objects/layout#blocks)) ont des propriétés d’objet en lecture seule. Cela ne signifie pas que ces propriétés ne peuvent pas être modifiées, mais seulement qu’elles ne peuvent pas l’être en remplaçant directement la propriété d’objet par un autre objet, car la méthode "put" n’est pas prise en charge. En revanche, vous pouvez modifier les sous-propriétés de ces objets.
En C++ (*C++ natif sous Windows*), si vous souhaitez modifier une telle propriété, vous devez affecter une référence à l’objet de propriété à une nouvelle variable, puis utiliser cette variable pour la modifier. Vous trouverez ci-dessous un exemple en C++ pour la propriété ILayout::Blocks, qui est représentée par une collection en lecture seule :
```cpp theme={null}
// Nous supposons qu'une page a déjà été ouverte
ILayout* pLayout = 0;
ILayoutBlocks* pLayoutBlocks = 0;
int blockIndex = 0;
// Récupérer le layout depuis la FRPage précédemment ouverte
pFRPage->get_Layout( &pLayout );
// La variable pLayoutBlocks reçoit une référence à la collection de blocs depuis le Layout
pLayout->get_Blocks( &pLayoutBlocks );
// Supprimer un élément de la collection de blocs
pLayoutBlocks->DeleteAt( blockIndex );
// Travailler avec le layout modifié
...
// Libérer les objets
pLayoutBlocks->Release();
pLayout->Release();
```