> ## 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.
# Trabajar con propiedades
> Use las propiedades de ABBYY FineReader Engine — tipos VARIANT_BOOL, integer, string y objeto — mediante métodos get/put en C++ en Linux/macOS o con sintaxis de propiedades en Windows.
Las interfaces de los objetos de ABBYY FineReader Engine tienen varias propiedades y métodos. En general, las propiedades representan información sobre un objeto, mientras que los métodos representan las acciones que puede realizar.
Los ejemplos de C# se aplican a Windows. Los ejemplos de C++ se aplican a todos los sistemas operativos compatibles.
Para C++, una propiedad es un par de métodos (`get` y `put` para las propiedades de lectura y escritura) o un único método `get` (para las propiedades de solo lectura).
Las propiedades de ABBYY FineReader Engine pueden ser de los siguientes tipos:
* VARIANT\_BOOL (con dos valores: VARIANT\_TRUE o VARIANT\_FALSE)
* int
* double
* BSTR, un puntero a una cadena Unicode. El valor cero especifica una cadena vacía.
* \_\_int64
* HANDLE\*
* interfaz derivada de IUnknown
* enum
Los usuarios de C# y Visual Basic están familiarizados con el concepto de propiedad.
Para un usuario de C++, una propiedad es un par de métodos (`get` y `put` para las propiedades de lectura y escritura) o un único método `get` (para las propiedades de solo lectura).
Sin embargo, la característica "Native COM support" de Microsoft C++ hace que la forma de manejar las propiedades se parezca más a la que se usa en C#.
Las propiedades de ABBYY FineReader Engine pueden ser de los siguientes tipos:
| IDL | C++ | C# | Visual Basic .NET |
| --------------------------------------------------------------------------------- | ---------------------------------------------- | -------------------- | ----------------------- |
| VARIANT\_BOOL (VARIANT\_TRUE o VARIANT\_FALSE) | VARIANT\_BOOL (VARIANT\_TRUE o VARIANT\_FALSE) | bool (true or false) | Boolean (True or False) |
| int | int | int | Integer |
| double | double | double | Double |
| BSTR, un puntero a una cadena Unicode. El valor cero especifica una cadena vacía. | BSTR | string | String |
| \_\_int64 | \_\_int64 | Int64 | Int64 |
| HANDLE\* | void\* | IntPtr | IntPtr |
| interfaz derivada de IUnknown | interfaz derivada de IUnknown | objeto | Object |
| enum | enum | enum | Enum |
Consulte a continuación los detalles sobre cómo trabajar con distintos tipos de propiedades:
Usaremos una propiedad Boolean como ejemplo de cómo se usan las propiedades simples. La propiedad se describe en la biblioteca de tipos de la siguiente manera:
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT MyProperty( [out, retval] VARIANT_BOOL* result );
[propput]
HRESULT MyProperty( [in] VARIANT_BOOL value );
};
```
Si la biblioteca de tipos solo define el método "get" para una propiedad simple, esta propiedad se denomina de solo lectura. El usuario no puede cambiar su valor; solo puede acceder a él para "leerlo".
Un usuario de C# maneja una propiedad simple de la siguiente manera:
```csharp theme={null}
if (MyObject.MyProperty != true)
MyObject.MyProperty = true;
```
Por otro lado, un usuario de C++ utiliza dos métodos para trabajar con esta propiedad. Estos métodos tienen los prefijos `get_` y `put_`. El código correspondiente en C++ debería tener el siguiente aspecto:
```cpp theme={null}
IMyObject* pMyObject;
VARIANT_BOOL res;
pMyObject->get_MyProperty(&res);
if( res != VARIANT_TRUE )
pMyObject->put_MyProperty(VARIANT_TRUE);
```
Sin embargo, "Native COM support" en Windows simplifica el procedimiento, y el código correspondiente debería tener el siguiente aspecto:
```cpp theme={null}
IMyObjectPtr pMyObject;
if(pMyObject->MyProperty != VARIANT_TRUE)
pMyObject->MyProperty = VARIANT_TRUE
```
Trabajar con propiedades string es muy similar a trabajar con propiedades simples, pero tiene sus particularidades. Un usuario de C++ que trabaje con propiedades string debe liberar las cadenas que se pasan a los métodos set, así como las que devuelven los métodos get.
* En Windows, esto se hace automáticamente en C#, Visual Basic y en C++ con Native COM support.
* En Linux, use las funciones FREngineAllocString y FREngineFreeString para asignar y liberar la memoria de las cadenas.
Supongamos que MyObject también admite una propiedad string llamada Name. Esta propiedad se describe en la biblioteca de tipos de la siguiente manera:
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT Name([out, retval]BSTR* result);
[propput]
HRESULT Name([in]BSTR value);
};
```
Un usuario de C++ trabaja con esta propiedad de la siguiente manera:
**Windows**
```cpp theme={null}
IMyObject* pMyObject;
// método "get"
BSTR res;
pMyObject->get_Name(&res);
// Ahora libere la cadena asignada en ABBYY FineReader Engine
::SysFreeString(res);
// método "put"
BSTR str = ::SysAllocString(L"New Name");
pMyObject->put_Name(str);
// Ahora libere la cadena que asignamos
::SysFreeString(str);
```
**Linux**
```cpp theme={null}
IMyObject* pMyObject;
// método "get"
BSTR res;
pMyObject->get_Name(&res);
// Ahora libere la cadena asignada en ABBYY FineReader Engine
::FREngineFreeString(res);
// método "put"
BSTR str = ::FREngineAllocString(L"New Name");
pMyObject->put_Name(str);
// Ahora libere la cadena que asignamos
::FREngineFreeString(str);
```
Un usuario de C++ dirá que los parámetros de los métodos "get" de las propiedades de objeto son punteros al puntero de interfaz de un objeto. Como las interfaces de los objetos se derivan de IUnknown, pueden pasarse como punteros IUnknown a las propiedades o métodos que usan objetos de varios tipos como parámetros de entrada o salida (aunque puede obtener la interfaz que necesita llamando al método QueryInterface).
Un método "put" para una propiedad de objeto, si existe, admite clear put, descrito por la palabra clave propput en la biblioteca de tipos. Esto significa que el objeto se copia, en lugar de pasar un puntero a la interfaz de un objeto existente.
Supongamos de nuevo que el objeto MyObject admite la propiedad MyObjectProperty, que hace referencia a un objeto de tipo MyChildObject.
```cpp theme={null}
interface IMyObject : IUnknown
{
[propget]
HRESULT MyObjectProperty([out, retval]IMyChildObject** result);
[propput]
HRESULT MyObjectProperty([in]IMyChildObject* value);
};
```
Un usuario de C++ escribirá este código de la siguiente manera:
```cpp theme={null}
IMyObject* pMyObject;
IMyChildObject* pChildObj=0;
// el método get_ puede devolver 0 en ciertos casos
pMyObject->get_MyObjectProperty(&pChildObj);
// Hacer algo con el objeto
...
pMyObject->put_MyObjectProperty(pChildObj);
pChildObj->Release();
```
Tenga en cuenta que en C++ debe llamar al método Release para un objeto obtenido mediante una propiedad. Native COM support en Windows llama automáticamente a los métodos AddRef y Release mediante punteros automáticos.
## Trabajar con propiedades de objeto de solo lectura
Ciertos objetos de ABBYY FineReader Engine (por ejemplo, [ILayout::Blocks](/es/fine-reader/engine/api-reference/layout-related-objects/layout#blocks)) tienen propiedades de objeto de solo lectura. Esto no significa que esas propiedades no se puedan modificar; solo significa que no se pueden cambiar sustituyendo directamente la propiedad del objeto por otro objeto, ya que no se admite el método "put". Sin embargo, sí puede modificar las subpropiedades de estos objetos.
En C++ (*C++ nativo en Windows*), si quiere cambiar una propiedad de este tipo, debe pasar una referencia al objeto de la propiedad a una nueva variable y, a continuación, usar esa variable para modificarla. A continuación, consulte un ejemplo en C++ para la propiedad ILayout::Blocks, que se representa mediante una colección de solo lectura:
```cpp theme={null}
// Asumimos que una página ya ha sido abierta
ILayout* pLayout = 0;
ILayoutBlocks* pLayoutBlocks = 0;
int blockIndex = 0;
// Obtener el layout de la FRPage previamente abierta
pFRPage->get_Layout( &pLayout );
// La variable pLayoutBlocks recibe una referencia a la colección de bloques del Layout
pLayout->get_Blocks( &pLayoutBlocks );
// Eliminar un elemento de la colección de bloques
pLayoutBlocks->DeleteAt( blockIndex );
// Trabajar con el layout modificado
...
// Liberar los objetos
pLayoutBlocks->Release();
pLayout->Release();
```