Cómo: Usar propiedades en C++/CLI

En este artículo se muestra cómo usar propiedades en C++/CLI.

Propiedades básicas

En el caso de las propiedades básicas (aquellas que simplemente asignan y recuperan un miembro de datos privado), no es necesario definir explícitamente las funciones de descriptor de acceso get y set porque el compilador las proporciona automáticamente cuando se proporciona solo el tipo de datos de la propiedad. Este código muestra una propiedad básica:

// SimpleProperties.cpp
// compile with: /clr
using namespace System;

ref class C {
public:
   property int Size;
};

int main() {
   C^ c = gcnew C;
   c->Size = 111;
   Console::WriteLine("c->Size = {0}", c->Size);
}

c->Size = 111

Propiedades estáticas

En este ejemplo de código se muestra cómo declarar y usar una propiedad estática. Una propiedad estática solo puede tener acceso a miembros estáticos de su clase.

// mcppv2_property_3.cpp
// compile with: /clr
using namespace System;

ref class StaticProperties {
   static int MyInt;
   static int MyInt2;

public:
   static property int Static_Data_Member_Property;

   static property int Static_Block_Property {
      int get() {
         return MyInt;
      }

      void set(int value) {
         MyInt = value;
      }
   }
};

int main() {
   StaticProperties::Static_Data_Member_Property = 96;
   Console::WriteLine(StaticProperties::Static_Data_Member_Property);

   StaticProperties::Static_Block_Property = 47;
   Console::WriteLine(StaticProperties::Static_Block_Property);
}

96
47

Las propiedades indexadas

Normalmente, una propiedad indizada expone una estructura de datos a la que se accede mediante un operador de subíndice.

Si usa una propiedad indexada predeterminada, puede acceder a la estructura de datos simplemente haciendo referencia al nombre de clase, pero si usa una propiedad indexada definida por el usuario, debe especificar el nombre de propiedad para tener acceso a la estructura de datos.

Para obtener información sobre cómo consumir un indexador escrito en C#, vea Cómo: Consumir un indizador de C# (C++/CLI).

En este ejemplo de código se muestra cómo usar las propiedades indexadas predeterminadas y definidas por el usuario:

// mcppv2_property_2.cpp
// compile with: /clr
using namespace System;
public ref class C {
   array<int>^ MyArr;

public:
   C() {
      MyArr = gcnew array<int>(5);
   }

   // default indexer
   property int default[int] {
      int get(int index) {
         return MyArr[index];
      }
      void set(int index, int value) {
         MyArr[index] = value;
      }
   }

   // user-defined indexer
   property int indexer1[int] {
      int get(int index) {
         return MyArr[index];
      }
      void set(int index, int value) {
         MyArr[index] = value;
      }
   }
};

int main() {
   C ^ MyC = gcnew C();

   // use the default indexer
   Console::Write("[ ");
   for (int i = 0 ; i < 5 ; i++) {
      MyC[i] = i;
      Console::Write("{0} ", MyC[i]);
   }

   Console::WriteLine("]");

   // use the user-defined indexer
   Console::Write("[ ");
   for (int i = 0 ; i < 5 ; i++) {
      MyC->indexer1[i] = i * 2;
      Console::Write("{0} ", MyC->indexer1[i]);
   }

   Console::WriteLine("]");
}

[ 0 1 2 3 4 ]
[ 0 2 4 6 8 ]

En el ejemplo siguiente se muestra cómo llamar al indexador predeterminado mediante el puntero this.

// call_default_indexer_through_this_pointer.cpp
// compile with: /clr /c
value class Position {
public:
   Position(int x, int y) : position(gcnew array<int, 2>(100, 100)) {
      this->default[x, y] = 1;
   }

   property int default[int, int] {
      int get(int x, int y) {
         return position[x, y];
      }

      void set(int x, int y, int value) {}
   }

private:
   array<int, 2> ^ position;
};

En este ejemplo se muestra cómo usar DefaultMemberAttribute para especificar el indexador predeterminado:

// specify_default_indexer.cpp
// compile with: /LD /clr
using namespace System;
[Reflection::DefaultMember("XXX")]
public ref struct Squares {
   property Double XXX[Double] {
      Double get(Double data) {
         return data*data;
      }
   }
};

El siguiente ejemplo consume los metadatos creados en el ejemplo anterior.

// consume_default_indexer.cpp
// compile with: /clr
#using "specify_default_indexer.dll"
int main() {
   Squares ^ square = gcnew Squares();
   System::Console::WriteLine("{0}", square[3]);
}

9

Propiedades virtuales

En este ejemplo de código se muestra cómo declarar y usar propiedades virtuales:

// mcppv2_property_4.cpp
// compile with: /clr
using namespace System;
interface struct IEFace {
public:
   property int VirtualProperty1;
   property int VirtualProperty2 {
      int get();
      void set(int i);
   }
};

// implement virtual events
ref class PropImpl : public IEFace {
   int MyInt;
public:
   virtual property int VirtualProperty1;

   virtual property int VirtualProperty2 {
      int get() {
         return MyInt;
      }
      void set(int i) {
         MyInt = i;
      }
   }
};

int main() {
   PropImpl ^ MyPI = gcnew PropImpl();
   MyPI->VirtualProperty1 = 93;
   Console::WriteLine(MyPI->VirtualProperty1);

   MyPI->VirtualProperty2 = 43;
   Console::WriteLine(MyPI->VirtualProperty2);
}

93
43

Propiedades Abstract y Sealed

Aunque las palabras clave abstract y sealed se especifican como válidas en la especificación de ECMA C++/CLI, para el compilador de Microsoft C++ no puede especificarlas en propiedades triviales ni en la declaración de propiedad de una propiedad no trivial.

Para declarar una propiedad sealed o abstract, debe definir una propiedad no trivial y, a continuación, especificar la palabra clave abstract o sealed en las funciones de descriptor de acceso get y set.

// properties_abstract_sealed.cpp
// compile with: /clr
ref struct A {
protected:
   int m_i;

public:
   A() { m_i = 87; }

   // define abstract property
   property int Prop_1 {
      virtual int get() abstract;
      virtual void set(int i) abstract;
   }
};

ref struct B : A {
private:
   int m_i;

public:
   B() { m_i = 86; }

   // implement abstract property
   property int Prop_1 {
      virtual int get() override { return m_i; }
      virtual void set(int i) override { m_i = i; }
   }
};

ref struct C {
private:
   int m_i;

public:
   C() { m_i = 87; }

   // define sealed property
   property int Prop_2 {
      virtual int get() sealed { return m_i; }
      virtual void set(int i) sealed { m_i = i; };
   }
};

int main() {
   B b1;
   // call implementation of abstract property
   System::Console::WriteLine(b1.Prop_1);

   C c1;
   // call sealed property
   System::Console::WriteLine(c1.Prop_2);
}

86
87

Propiedades multidimensionales

Puede usar propiedades multidimensionales para definir métodos de descriptor de acceso de propiedad que toman un número no estándar de parámetros.

// mcppv2_property_5.cpp
// compile with: /clr
ref class X {
   double d;
public:
   X() : d(0) {}
   property double MultiDimProp[int, int, int] {
      double get(int, int, int) {
         return d;
      }
      void set(int i, int j, int k, double l) {
         // do something with those ints
         d = l;
      }
   }

   property double MultiDimProp2[int] {
      double get(int) {
         return d;
      }
      void set(int i, double l) {
         // do something with those ints
         d = l;
      }
   }

};

int main() {
   X ^ MyX = gcnew X();
   MyX->MultiDimProp[0,0,0] = 1.1;
   System::Console::WriteLine(MyX->MultiDimProp[0, 0, 0]);
}

1.1

Sobrecarga de descriptores de acceso de propiedad

En el ejemplo siguiente se muestra cómo sobrecargar las propiedades indexadas.

// mcppv2_property_6.cpp
// compile with: /clr
ref class X {
   double d;
public:
   X() : d(0.0) {}
   property double MyProp[int] {
      double get(int i) {
         return d;
      }

      double get(System::String ^ i) {
         return 2*d;
      }

      void set(int i, double l) {
         d = i * l;
      }
   }   // end MyProp definition
};

int main() {
   X ^ MyX = gcnew X();
   MyX->MyProp[2] = 1.7;
   System::Console::WriteLine(MyX->MyProp[1]);
   System::Console::WriteLine(MyX->MyProp["test"]);
}

3.4
6.8

Consulte también

propiedad