Type.GetProperty Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Obtiene una propiedad específica del objeto Type actual.
Sobrecargas
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]) |
Busca la propiedad especificada cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas. |
GetProperty(String) |
Busca la propiedad pública con el nombre especificado. |
GetProperty(String, BindingFlags) |
Busca la propiedad especificada, mediante las restricciones de enlace especificadas. |
GetProperty(String, Type) |
Busca la propiedad pública con el nombre especificado y el tipo de valor devuelto. |
GetProperty(String, Type[]) |
Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos de argumentos especificados. |
GetProperty(String, Type, Type[]) |
Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos de argumentos especificados. |
GetProperty(String, Type, Type[], ParameterModifier[]) |
Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos y modificadores de los argumentos especificados. |
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
Busca la propiedad especificada cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas.
public:
virtual System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, Type ^ returnType, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.PropertyInfo? GetProperty (string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, Type? returnType, Type[] types, System.Reflection.ParameterModifier[]? modifiers);
public System.Reflection.PropertyInfo GetProperty (string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, Type returnType, Type[] types, System.Reflection.ParameterModifier[] modifiers);
abstract member GetProperty : string * System.Reflection.BindingFlags * System.Reflection.Binder * Type * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.PropertyInfo
override this.GetProperty : string * System.Reflection.BindingFlags * System.Reflection.Binder * Type * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.PropertyInfo
Public Function GetProperty (name As String, bindingAttr As BindingFlags, binder As Binder, returnType As Type, types As Type(), modifiers As ParameterModifier()) As PropertyInfo
Parámetros
- name
- String
Cadena que contiene el nombre de la propiedad que se va a obtener.
- bindingAttr
- BindingFlags
Combinación bit a bit de los valores de enumeración que especifican cómo se realiza la búsqueda.
O bien
Default para devolver null
.
- binder
- Binder
Objeto que define un conjunto de propiedades y permite realizar operaciones de enlace, que pueden incluir la selección de un método sobrecargado, la coerción de tipos de argumentos y la invocación de un miembro mediante reflexión.
O bien
Referencia nula (Nothing
en Visual Basic) para usar la propiedad DefaultBinder.
- returnType
- Type
Tipo de valor devuelto de la propiedad.
- types
- Type[]
Matriz de objetos Type que representa el número, el orden y el tipo de parámetros que la propiedad indizada debe obtener.
O bien Matriz vacía del tipo Type (es decir, Type[] types = new Type[0]) para obtener una propiedad que no esté indizada.
- modifiers
- ParameterModifier[]
Matriz de objetos ParameterModifier que representan los atributos asociados al elemento correspondiente de la matriz types
. El enlazador predeterminado no procesa este parámetro.
Devoluciones
Objeto que representa la propiedad que cumple los requisitos especificados, si se encuentra; en caso contrario, es null
.
Implementaciones
Excepciones
Se encontró más de una propiedad con el nombre especificado y que coincide con las restricciones de enlace especificadas.
types
es multidimensional.
O bien
modifiers
es multidimensional.
O bien
types
y modifiers
no tienen la misma longitud.
Un elemento de types
es null
.
Comentarios
Una propiedad se considera pública para la reflexión si tiene al menos un accessor que es público. De lo contrario, la propiedad se considera privada y debe usar | | (en Visual Basic, combine los valores mediante BindingFlags.NonPublic BindingFlags.Instance ) para BindingFlags.Static Or
obtenerla.
Aunque el enlazador predeterminado no procesa (el parámetro ), puede usar la clase abstracta para escribir un ParameterModifier modifiers
System.Reflection.Binder enlazador personalizado que procese modifiers
. ParameterModifier
solo se usa cuando se llama a través de interoperabilidad COM y solo se controlan los parámetros que se pasan por referencia.
En la tabla siguiente se muestra qué miembros de una clase base devuelven los métodos Get
al reflejar en un tipo.
Tipo de miembro | Estático | No estático |
---|---|---|
Constructor | No | No |
Campo | No | Sí. Un campo siempre se oculta por nombre y firma. |
evento | No es aplicable | La regla común del sistema de tipos es que la herencia es la misma que la de los métodos que implementan la propiedad . La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación. |
Método | No | Sí. Un método (virtual y no virtual) puede ocultarse por nombre u ocultar por nombre y firma. |
Tipo anidado | No | No |
Propiedad. | No es aplicable | La regla común del sistema de tipos es que la herencia es la misma que la de los métodos que implementan la propiedad . La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación. |
Ocultar por nombre y firma tiene en cuenta todas las partes de la firma, incluidos modificadores personalizados, tipos de valor devuelto, tipos de parámetros, centinelas y convenciones de llamada no administradas. Se trata de una comparación binaria.
Para la reflexión, las propiedades y los eventos se ocultan por nombre y firma. Si tiene una propiedad con un accessor get y set en la clase base, pero la clase derivada solo tiene un accessor get, la propiedad de clase derivada oculta la propiedad de clase base y no podrá acceder al establecedor en la clase base.
Los atributos personalizados no forman parte del sistema de tipos comunes.
Las marcas BindingFlags de filtro siguientes se pueden usar para definir las propiedades que se incluirán en la búsqueda:
Debe especificar o
BindingFlags.Instance
BindingFlags.Static
para obtener una devolución.Especifique
BindingFlags.Public
para incluir propiedades públicas en la búsqueda.Especifique
BindingFlags.NonPublic
para incluir propiedades no públicas (es decir, propiedades privadas, internas y protegidas) en la búsqueda.Especifique para incluir y los miembros estáticos en la jerarquía; no se incluyen los miembros estáticos de
BindingFlags.FlattenHierarchy
public
las clasesprotected
private
heredadas.
Las siguientes BindingFlags marcas modificadoras se pueden usar para cambiar el funcionamiento de la búsqueda:
BindingFlags.IgnoreCase
para pasar por alto el caso dename
.BindingFlags.DeclaredOnly
para buscar solo las propiedades declaradas en Type , no las propiedades que simplemente se heredaron.
Vea System.Reflection.BindingFlags para obtener más información.
Si el objeto actual representa un tipo genérico construido, este método devuelve con los parámetros Type PropertyInfo de tipo reemplazados por los argumentos de tipo adecuados.
Si el objeto actual representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en las Type propiedades de la restricción de clase.
Indexadores y propiedades predeterminadas
Visual Basic 2005, Visual C# 2005 y Visual C++ 2005 tienen una sintaxis simplificada para acceder a las propiedades indizadas y permiten que una propiedad indizada sea un valor predeterminado para su tipo. Por ejemplo, si la variable hace referencia a , la sintaxis ( en Visual Basic) recupera el elemento con el myList
ArrayList índice de myList[3]
myList(3)
3. Puede sobrecargar la propiedad .
En C#, esta característica se denomina indexador y no se puede hacer referencia a esta característica por su nombre. De forma predeterminada, un indexador de C# aparece en los metadatos como una propiedad indizada denominada "Item". Sin embargo, un desarrollador de bibliotecas de clases puede usar IndexerNameAttribute el atributo para cambiar el nombre del indexador en los metadatos. Por ejemplo, la String clase tiene un indexador denominado Chars[] . Las propiedades indizadas creadas con lenguajes distintos de C# también pueden tener nombres distintos de Item.
Para determinar si un tipo tiene una propiedad predeterminada, use el GetCustomAttributes(Type, Boolean) método para probar el DefaultMemberAttribute atributo. Si el tipo tiene DefaultMemberAttribute , la propiedad devuelve el nombre de la propiedad MemberName predeterminada.
Consulte también
- PropertyInfo
- String
- BindingFlags
- Binder
- DefaultBinder
- ParameterModifier
- GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
- GetProperties(BindingFlags)
Se aplica a
GetProperty(String)
Busca la propiedad pública con el nombre especificado.
public:
System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name);
public:
virtual System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name);
public System.Reflection.PropertyInfo? GetProperty (string name);
public System.Reflection.PropertyInfo GetProperty (string name);
member this.GetProperty : string -> System.Reflection.PropertyInfo
abstract member GetProperty : string -> System.Reflection.PropertyInfo
override this.GetProperty : string -> System.Reflection.PropertyInfo
Public Function GetProperty (name As String) As PropertyInfo
Parámetros
- name
- String
Cadena que contiene el nombre de la propiedad pública que se va a obtener.
Devoluciones
Objeto que representa la propiedad pública con el nombre especificado, si se encuentra; en caso contrario, null
.
Implementaciones
Excepciones
Se encontró más de una propiedad con el nombre especificado.
name
es null
.
Ejemplos
En el ejemplo siguiente se recupera el objeto de una clase definida por el usuario, se recupera una propiedad de esa clase y Type
se muestra el nombre de propiedad.
using namespace System;
using namespace System::Reflection;
ref class MyClass
{
private:
int myProperty;
public:
property int MyProperty
{
// Declare MyProperty.
int get()
{
return myProperty;
}
void set( int value )
{
myProperty = value;
}
}
};
int main()
{
try
{
// Get the Type object corresponding to MyClass.
Type^ myType = MyClass::typeid;
// Get the PropertyInfo object by passing the property name.
PropertyInfo^ myPropInfo = myType->GetProperty( "MyProperty" );
// Display the property name.
Console::WriteLine( "The {0} property exists in MyClass.", myPropInfo->Name );
}
catch ( NullReferenceException^ e )
{
Console::WriteLine( "The property does not exist in MyClass. {0}", e->Message );
}
}
using System;
using System.Reflection;
class MyClass
{
private int myProperty;
// Declare MyProperty.
public int MyProperty
{
get
{
return myProperty;
}
set
{
myProperty=value;
}
}
}
public class MyTypeClass
{
public static void Main(string[] args)
{
try
{
// Get the Type object corresponding to MyClass.
Type myType=typeof(MyClass);
// Get the PropertyInfo object by passing the property name.
PropertyInfo myPropInfo = myType.GetProperty("MyProperty");
// Display the property name.
Console.WriteLine("The {0} property exists in MyClass.", myPropInfo.Name);
}
catch(NullReferenceException e)
{
Console.WriteLine("The property does not exist in MyClass." + e.Message);
}
}
}
Imports System.Reflection
Class MyClass1
Private myProperty1 As Integer
' Declare MyProperty.
Public Property MyProperty() As Integer
Get
Return myProperty1
End Get
Set(ByVal Value As Integer)
myProperty1 = Value
End Set
End Property
End Class
Public Class MyTypeClass
Public Shared Sub Main(ByVal args() As String)
Try
' Get Type Object corresponding to MyClass.
Dim myType As Type = GetType(MyClass1)
' Get PropertyInfo object by passing property name.
Dim myPropInfo As PropertyInfo = myType.GetProperty("MyProperty")
' Display Name propety to console.
Console.WriteLine("The {0} property exists in MyClass.", myPropInfo.Name)
Catch e As NullReferenceException
Console.WriteLine("The property does not exist in MyClass.", e.Message.ToString())
End Try
End Sub
End Class
Internamente, se hace referencia a esta propiedad en los metadatos con el nombre "Item". Cualquier intento de obtener el uso de la reflexión debe especificar PropertyInfo
este nombre interno para devolver correctamente la propiedad PropertyInfo
.
Comentarios
La búsqueda de name
distingue mayúsculas de minúsculas. La búsqueda incluye propiedades públicas de instancias estáticas y públicas.
Una propiedad se considera pública para la reflexión si tiene al menos un accessor que es público. De lo contrario, la propiedad se considera privada y debe usar | | (en Visual Basic, combine los valores mediante BindingFlags.NonPublic BindingFlags.Instance ) para BindingFlags.Static Or
obtenerla.
Si el objeto actual representa un tipo genérico construido, este método devuelve con los parámetros Type PropertyInfo de tipo reemplazados por los argumentos de tipo adecuados.
Si el objeto actual representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en las Type propiedades de la restricción de clase.
Entre las AmbiguousMatchException situaciones en las que se produce se incluyen las siguientes:
Un tipo contiene dos propiedades indizadas que tienen el mismo nombre pero distintos números de parámetros. Para resolver la ambigüedad, use una sobrecarga del GetProperty método que especifica los tipos de parámetro.
Un tipo derivado declara una propiedad que oculta una propiedad heredada con el mismo nombre, mediante el
new
modificador (Shadows
en Visual Basic). Para resolver la ambigüedad, use la sobrecarga del método y agregue la marca para restringir la búsqueda a los miembros GetProperty(String, BindingFlags) BindingFlags.DeclaredOnly que no se heredan.
Indexadores y propiedades predeterminadas
Visual Basic 2005, Visual C# 2005 y Visual C++ 2005 tienen una sintaxis simplificada para acceder a las propiedades indizadas y permiten que una propiedad indizada sea un valor predeterminado para su tipo. Por ejemplo, si la variable hace referencia a , la sintaxis ( en Visual Basic) recupera el elemento myList
con el índice de ArrayList myList[3]
myList(3)
3. Puede sobrecargar la propiedad .
En C#, esta característica se denomina indexador y no se puede hacer referencia a esta característica por nombre. De forma predeterminada, un indexador de C# aparece en los metadatos como una propiedad indizada denominada "Item". Sin embargo, un desarrollador de bibliotecas de clases puede usar IndexerNameAttribute el atributo para cambiar el nombre del indexador en los metadatos. Por ejemplo, la String clase tiene un indexador denominado Chars[] . Las propiedades indizadas creadas con lenguajes distintos de C# también pueden tener nombres distintos de Item.
Para determinar si un tipo tiene una propiedad predeterminada, use el GetCustomAttributes(Type, Boolean) método para probar el DefaultMemberAttribute atributo. Si el tipo tiene DefaultMemberAttribute , la propiedad devuelve el nombre de la propiedad MemberName predeterminada.
Consulte también
- PropertyInfo
- String
- DefaultBinder
- GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
- GetProperties(BindingFlags)
Se aplica a
GetProperty(String, BindingFlags)
Busca la propiedad especificada, mediante las restricciones de enlace especificadas.
public:
virtual System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, System::Reflection::BindingFlags bindingAttr);
public System.Reflection.PropertyInfo? GetProperty (string name, System.Reflection.BindingFlags bindingAttr);
public System.Reflection.PropertyInfo GetProperty (string name, System.Reflection.BindingFlags bindingAttr);
abstract member GetProperty : string * System.Reflection.BindingFlags -> System.Reflection.PropertyInfo
override this.GetProperty : string * System.Reflection.BindingFlags -> System.Reflection.PropertyInfo
Public Function GetProperty (name As String, bindingAttr As BindingFlags) As PropertyInfo
Parámetros
- name
- String
Cadena que contiene el nombre de la propiedad que se va a obtener.
- bindingAttr
- BindingFlags
Combinación bit a bit de los valores de enumeración que especifican cómo se realiza la búsqueda.
O bien
Default para devolver null
.
Devoluciones
Objeto que representa la propiedad que cumple los requisitos especificados, si se encuentra; en caso contrario, es null
.
Implementaciones
Excepciones
Se encontró más de una propiedad con el nombre especificado y que coincide con las restricciones de enlace especificadas.
name
es null
.
Ejemplos
En el ejemplo siguiente se recupera el tipo de una clase definida por el usuario, se recupera una propiedad de esa clase y se muestra el nombre de propiedad de acuerdo con las restricciones de enlace especificadas.
using namespace System;
using namespace System::Reflection;
ref class MyClass
{
private:
int myProperty;
public:
property int MyProperty
{
// Declare MyProperty.
int get()
{
return myProperty;
}
void set( int value )
{
myProperty = value;
}
}
};
int main()
{
try
{
// Get Type object of MyClass.
Type^ myType = MyClass::typeid;
// Get the PropertyInfo by passing the property name and specifying the BindingFlags.
PropertyInfo^ myPropInfo = myType->GetProperty( "MyProperty", static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance) );
// Display Name propety to console.
Console::WriteLine( "{0} is a property of MyClass.", myPropInfo->Name );
}
catch ( NullReferenceException^ e )
{
Console::WriteLine( "MyProperty does not exist in MyClass. {0}", e->Message );
}
}
using System;
using System.Reflection;
class MyClass
{
private int myProperty;
// Declare MyProperty.
public int MyProperty
{
get
{
return myProperty;
}
set
{
myProperty=value;
}
}
}
public class MyTypeClass
{
public static void Main(string[] args)
{
try
{
// Get Type object of MyClass.
Type myType=typeof(MyClass);
// Get the PropertyInfo by passing the property name and specifying the BindingFlags.
PropertyInfo myPropInfo = myType.GetProperty("MyProperty", BindingFlags.Public | BindingFlags.Instance);
// Display Name propety to console.
Console.WriteLine("{0} is a property of MyClass.", myPropInfo.Name);
}
catch(NullReferenceException e)
{
Console.WriteLine("MyProperty does not exist in MyClass." +e.Message);
}
}
}
Imports System.Reflection
Module Module1
Public Class MyClass1
Private myProperty1 As Integer
' Declare MyProperty.
Public Property MyProperty() As Integer
Get
Return myProperty1
End Get
Set(ByVal Value As Integer)
myProperty1 = Value
End Set
End Property
Public Shared Sub Main()
Try
' Get a Type object corresponding to MyClass.
Dim myType As Type = GetType(MyClass1)
' Get a PropertyInfo object by passing property name and specifying BindingFlags.
Dim myPropInfo As PropertyInfo = myType.GetProperty("MyProperty", BindingFlags.Public Or BindingFlags.Instance)
' Display the Name property.
Console.WriteLine("{0} is a property of MyClass.", myPropInfo.Name)
Catch e As NullReferenceException
Console.WriteLine("MyProperty does not exist in MyClass.", e.Message.ToString())
End Try
End Sub
End Class
End Module 'Module1
Comentarios
Una propiedad se considera pública para la reflexión si tiene al menos un accessor que es público. De lo contrario, la propiedad se considera privada y debe usar | | (en Visual Basic, combine los valores mediante BindingFlags.NonPublic BindingFlags.Instance ) para BindingFlags.Static Or
obtenerla.
Las marcas BindingFlags de filtro siguientes se pueden usar para definir las propiedades que se incluirán en la búsqueda:
Debe especificar o
BindingFlags.Instance
BindingFlags.Static
para obtener una devolución.Especifique
BindingFlags.Public
para incluir propiedades públicas en la búsqueda.Especifique
BindingFlags.NonPublic
para incluir propiedades no públicas (es decir, propiedades privadas, internas y protegidas) en la búsqueda.Especifique para incluir y los miembros estáticos en la jerarquía; no se incluyen los miembros estáticos de
BindingFlags.FlattenHierarchy
public
las clasesprotected
private
heredadas.
Las siguientes BindingFlags marcas modificadoras se pueden usar para cambiar el funcionamiento de la búsqueda:
BindingFlags.IgnoreCase
para pasar por alto el caso dename
.BindingFlags.DeclaredOnly
para buscar solo las propiedades declaradas en Type , no las propiedades que simplemente se heredaron.
Vea System.Reflection.BindingFlags para obtener más información.
Si el objeto actual representa un tipo genérico construido, este método devuelve con los parámetros Type PropertyInfo de tipo reemplazados por los argumentos de tipo adecuados.
Si el objeto actual representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en las Type propiedades de la restricción de clase.
Entre las AmbiguousMatchException situaciones en las que se produce se incluyen las siguientes:
Un tipo contiene dos propiedades indizadas que tienen el mismo nombre pero distintos números de parámetros. Para resolver la ambigüedad, use una sobrecarga del GetProperty método que especifica los tipos de parámetro.
Un tipo derivado declara una propiedad que oculta una propiedad heredada con el mismo nombre, utilizando el
new
modificador (Shadows
en Visual Basic). Para resolver la ambigüedad, incluya BindingFlags.DeclaredOnly para restringir la búsqueda a los miembros que no se heredan.
Indexadores y propiedades predeterminadas
Visual Basic 2005, Visual C# 2005 y Visual C++ 2005 tienen una sintaxis simplificada para acceder a las propiedades indizadas y permiten que una propiedad indizada sea un valor predeterminado para su tipo. Por ejemplo, si la variable hace referencia a , la sintaxis ( en Visual Basic) recupera el elemento con el myList
ArrayList índice de myList[3]
myList(3)
3. Puede sobrecargar la propiedad .
En C#, esta característica se denomina indexador y no se puede hacer referencia a esta característica por su nombre. De forma predeterminada, un indexador de C# aparece en los metadatos como una propiedad indizada denominada "Item". Sin embargo, un desarrollador de bibliotecas de clases puede usar IndexerNameAttribute el atributo para cambiar el nombre del indexador en los metadatos. Por ejemplo, la String clase tiene un indexador denominado Chars[] . Las propiedades indizadas creadas con lenguajes distintos de C# también pueden tener nombres distintos de Item.
Para determinar si un tipo tiene una propiedad predeterminada, use el GetCustomAttributes(Type, Boolean) método para probar el DefaultMemberAttribute atributo. Si el tipo tiene DefaultMemberAttribute , la propiedad devuelve el nombre de la propiedad MemberName predeterminada.
Consulte también
- PropertyInfo
- String
- BindingFlags
- DefaultBinder
- GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
- GetProperties(BindingFlags)
Se aplica a
GetProperty(String, Type)
Busca la propiedad pública con el nombre especificado y el tipo de valor devuelto.
public:
System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, Type ^ returnType);
public:
virtual System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, Type ^ returnType);
public System.Reflection.PropertyInfo? GetProperty (string name, Type? returnType);
public System.Reflection.PropertyInfo GetProperty (string name, Type returnType);
member this.GetProperty : string * Type -> System.Reflection.PropertyInfo
abstract member GetProperty : string * Type -> System.Reflection.PropertyInfo
override this.GetProperty : string * Type -> System.Reflection.PropertyInfo
Public Function GetProperty (name As String, returnType As Type) As PropertyInfo
Parámetros
- name
- String
Cadena que contiene el nombre de la propiedad pública que se va a obtener.
- returnType
- Type
Tipo de valor devuelto de la propiedad.
Devoluciones
Objeto que representa la propiedad pública con el nombre especificado, si se encuentra; en caso contrario, null
.
Implementaciones
Excepciones
Se encontró más de una propiedad con el nombre especificado.
name
es null
o returnType
es null
.
Ejemplos
En el ejemplo siguiente se define una clase con una propiedad y se recupera el nombre y el tipo de la propiedad.
using namespace System;
using namespace System::Reflection;
ref class MyClass1
{
private:
String^ myMessage;
public:
property String^ MyProperty1
{
String^ get()
{
return myMessage;
}
void set( String^ value )
{
myMessage = value;
}
}
};
int main()
{
try
{
Type^ myType = MyClass1::typeid;
// Get the PropertyInfo Object* representing MyProperty1.
PropertyInfo^ myStringProperties1 = myType->GetProperty( "MyProperty1", String::typeid );
Console::WriteLine( "The name of the first property of MyClass1 is {0}.", myStringProperties1->Name );
Console::WriteLine( "The type of the first property of MyClass1 is {0}.", myStringProperties1->PropertyType );
}
catch ( ArgumentNullException^ e )
{
Console::WriteLine( "ArgumentNullException : {0}", e->Message );
}
catch ( AmbiguousMatchException^ e )
{
Console::WriteLine( "AmbiguousMatchException : {0}", e->Message );
}
catch ( NullReferenceException^ e )
{
Console::WriteLine( "Source : {0}", e->Source );
Console::WriteLine( "Message : {0}", e->Message );
}
//Output:
//The name of the first property of MyClass1 is MyProperty1.
//The type of the first property of MyClass1 is System.String.
}
using System;
using System.Reflection;
class MyClass1
{
String myMessage="Hello World.";
public string MyProperty1
{
get
{
return myMessage;
}
set
{
myMessage =value;
}
}
}
class TestClass
{
static void Main()
{
try
{
Type myType = typeof(MyClass1);
// Get the PropertyInfo object representing MyProperty1.
PropertyInfo myStringProperties1 = myType.GetProperty("MyProperty1",
typeof(string));
Console.WriteLine("The name of the first property of MyClass1 is {0}.", myStringProperties1.Name);
Console.WriteLine("The type of the first property of MyClass1 is {0}.", myStringProperties1.PropertyType);
}
catch(ArgumentNullException e)
{
Console.WriteLine("ArgumentNullException :"+e.Message);
}
catch(AmbiguousMatchException e)
{
Console.WriteLine("AmbiguousMatchException :"+e.Message);
}
catch(NullReferenceException e)
{
Console.WriteLine("Source : {0}" , e.Source);
Console.WriteLine("Message : {0}" , e.Message);
}
//Output:
//The name of the first property of MyClass1 is MyProperty1.
//The type of the first property of MyClass1 is System.String.
}
}
Imports System.Reflection
Class MyClass1
Private myMessage As [String] = "Hello World."
Public Property MyProperty1() As String
Get
Return myMessage
End Get
Set(ByVal Value As String)
myMessage = Value
End Set
End Property
End Class
Class TestClass
Shared Sub Main()
Try
Dim myType As Type = GetType(MyClass1)
' Get the PropertyInfo object representing MyProperty1.
Dim myStringProperties1 As PropertyInfo = myType.GetProperty("MyProperty1", GetType(String))
Console.WriteLine("The name of the first property of MyClass1 is {0}.", myStringProperties1.Name)
Console.WriteLine("The type of the first property of MyClass1 is {0}.", myStringProperties1.PropertyType.ToString())
Catch e As ArgumentNullException
Console.WriteLine("ArgumentNullException :" + e.Message.ToString())
Catch e As AmbiguousMatchException
Console.WriteLine("AmbiguousMatchException :" + e.Message.ToString())
Catch e As NullReferenceException
Console.WriteLine("Source : {0}", e.Source.ToString())
Console.WriteLine("Message : {0}", e.Message.ToString())
End Try
'Output:
'The name of the first property of MyClass1 is MyProperty1.
'The type of the first property of MyClass1 is System.String.
End Sub
End Class
Comentarios
Una propiedad se considera pública para la reflexión si tiene al menos un accessor que es público. De lo contrario, la propiedad se considera privada y debe usar | | (en Visual Basic, combine los valores mediante BindingFlags.NonPublic BindingFlags.Instance ) para BindingFlags.Static Or
obtenerla.
La búsqueda de name
distingue mayúsculas de minúsculas. La búsqueda incluye propiedades públicas de instancias estáticas y públicas.
Si el objeto actual representa un tipo genérico construido, este método devuelve con los parámetros de tipo Type PropertyInfo reemplazados por los argumentos de tipo adecuados.
Si el objeto actual representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en las Type propiedades de la restricción de clase.
Indexadores y propiedades predeterminadas
Visual Basic 2005, Visual C# 2005 y Visual C++ 2005 tienen una sintaxis simplificada para acceder a las propiedades indizadas y permiten que una propiedad indizada sea un valor predeterminado para su tipo. Por ejemplo, si la variable hace referencia a , la sintaxis ( en Visual Basic) recupera el elemento con el myList
ArrayList índice de myList[3]
myList(3)
3. Puede sobrecargar la propiedad .
En C#, esta característica se denomina indexador y no se puede hacer referencia a esta característica por su nombre. De forma predeterminada, un indexador de C# aparece en los metadatos como una propiedad indizada denominada "Item". Sin embargo, un desarrollador de bibliotecas de clases puede usar IndexerNameAttribute el atributo para cambiar el nombre del indexador en los metadatos. Por ejemplo, la String clase tiene un indexador denominado Chars[] . Las propiedades indizadas creadas con lenguajes distintos de C# también pueden tener nombres distintos de Item.
Para determinar si un tipo tiene una propiedad predeterminada, use el GetCustomAttributes(Type, Boolean) método para probar el DefaultMemberAttribute atributo. Si el tipo tiene DefaultMemberAttribute , la propiedad devuelve el nombre de la propiedad MemberName predeterminada.
Consulte también
- PropertyInfo
- String
- DefaultBinder
- GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
- GetProperties(BindingFlags)
Se aplica a
GetProperty(String, Type[])
Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos de argumentos especificados.
public:
System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, cli::array <Type ^> ^ types);
public:
virtual System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, cli::array <Type ^> ^ types);
public System.Reflection.PropertyInfo? GetProperty (string name, Type[] types);
public System.Reflection.PropertyInfo GetProperty (string name, Type[] types);
member this.GetProperty : string * Type[] -> System.Reflection.PropertyInfo
abstract member GetProperty : string * Type[] -> System.Reflection.PropertyInfo
override this.GetProperty : string * Type[] -> System.Reflection.PropertyInfo
Public Function GetProperty (name As String, types As Type()) As PropertyInfo
Parámetros
- name
- String
Cadena que contiene el nombre de la propiedad pública que se va a obtener.
- types
- Type[]
Matriz de objetos Type que representa el número, el orden y el tipo de parámetros que la propiedad indizada debe obtener.
O bien Matriz vacía del tipo Type (es decir, Type[] types = new Type[0]) para obtener una propiedad que no esté indizada.
Devoluciones
Objeto que representa la propiedad pública cuyos parámetros coinciden con los tipos de argumentos especificados, si se encuentra; en caso contrario, null
.
Implementaciones
Excepciones
Se encontró más de una propiedad con el nombre especificado y que coincide con los tipos de argumento especificados.
types
es multidimensional.
Un elemento de types
es null
.
Ejemplos
En el ejemplo siguiente se recupera el objeto de una clase definida por el usuario, se recupera la propiedad de esa clase y se muestra el nombre de propiedad y el tipo de la propiedad según lo especificado por los Type
argumentos pasados a GetProperty
.
using namespace System;
using namespace System::Reflection;
ref class MyClass1
{
private:
array<int, 2>^myArray;
public:
property int Item [int, int]
{
// Declare an indexer.
int get( int i, int j )
{
return myArray[ i,j ];
}
void set( int i, int j, int value )
{
myArray[ i,j ] = value;
}
}
};
int main()
{
try
{
// Get the Type object.
Type^ myType = MyClass1::typeid;
array<Type^>^myTypeArr = gcnew array<Type^>(2);
// Create an instance of a Type array.
myTypeArr->SetValue( int::typeid, 0 );
myTypeArr->SetValue( int::typeid, 1 );
// Get the PropertyInfo object for the indexed property Item, which has two integer parameters.
PropertyInfo^ myPropInfo = myType->GetProperty( "Item", myTypeArr );
// Display the property.
Console::WriteLine( "The {0} property exists in MyClass1.", myPropInfo );
}
catch ( NullReferenceException^ e )
{
Console::WriteLine( "An exception occurred." );
Console::WriteLine( "Source : {0}", e->Source );
Console::WriteLine( "Message : {0}", e->Message );
}
}
using System;
using System.Reflection;
class MyClass1
{
private int [,] myArray = {{1,2},{3,4}};
// Declare an indexer.
public int this [int i,int j]
{
get
{
return myArray[i,j];
}
set
{
myArray[i,j] = value;
}
}
}
public class MyTypeClass
{
public static void Main(string[] args)
{
try
{
// Get the Type object.
Type myType=typeof(MyClass1);
Type[] myTypeArr = new Type[2];
// Create an instance of a Type array.
myTypeArr.SetValue(typeof(int),0);
myTypeArr.SetValue(typeof(int),1);
// Get the PropertyInfo object for the indexed property Item, which has two integer parameters.
PropertyInfo myPropInfo = myType.GetProperty("Item", myTypeArr);
// Display the property.
Console.WriteLine("The {0} property exists in MyClass1.", myPropInfo.ToString());
}
catch(NullReferenceException e)
{
Console.WriteLine("An exception occurred.");
Console.WriteLine("Source : {0}" , e.Source);
Console.WriteLine("Message : {0}" , e.Message);
}
}
}
Imports System.Reflection
Module Module1
Class MyClass1
Private myArray As Integer(,) = {{1, 2}, {3, 4}}
' Declare an indexer.
Default Public Property Item(ByVal i As Integer, ByVal j As Integer) As Integer
Get
Return myArray(i, j)
End Get
Set(ByVal Value As Integer)
myArray(i, j) = Value
End Set
End Property
End Class
Public Class MyTypeClass
Public Shared Sub Main()
Try
' Get the Type Object.
Dim myType As Type = GetType(MyClass1)
Dim myTypeArr(1) As Type
' Create an instance of a Type array.
myTypeArr.SetValue(GetType(Integer), 0)
myTypeArr.SetValue(GetType(Integer), 1)
' Get the PropertyInfo object for the indexed property Item, which has two integer parameters.
Dim myPropInfo As PropertyInfo = myType.GetProperty("Item", myTypeArr)
' Display the property.
Console.WriteLine("The {0} property exists in MyClass1.", myPropInfo.ToString())
Catch e As NullReferenceException
Console.WriteLine("An exception occurred.")
Console.WriteLine("Source : {0}", e.Source.ToString())
Console.WriteLine("Message : {0}", e.Message.ToString())
End Try
End Sub
End Class
End Module 'Module1
Comentarios
Una propiedad se considera pública para la reflexión si tiene al menos un accessor que es público. De lo contrario, la propiedad se considera privada y debe usar | | (en Visual Basic, combine los valores mediante BindingFlags.NonPublic BindingFlags.Instance ) para BindingFlags.Static Or
obtenerla.
La búsqueda de name
distingue mayúsculas de minúsculas. La búsqueda incluye propiedades públicas de instancias estáticas y públicas.
Si el objeto actual representa un tipo genérico construido, este método devuelve con los parámetros de tipo Type PropertyInfo reemplazados por los argumentos de tipo adecuados.
Si el objeto actual representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en las Type propiedades de la restricción de clase.
Indexadores y propiedades predeterminadas
Visual Basic 2005, Visual C# 2005 y Visual C++ 2005 tienen una sintaxis simplificada para acceder a las propiedades indizadas y permiten que una propiedad indizada sea un valor predeterminado para su tipo. Por ejemplo, si la variable hace referencia a , la sintaxis ( en Visual Basic) recupera el elemento con el myList
ArrayList índice de myList[3]
myList(3)
3. Puede sobrecargar la propiedad .
En C#, esta característica se denomina indexador y no se puede hacer referencia a esta característica por su nombre. De forma predeterminada, un indexador de C# aparece en los metadatos como una propiedad indizada denominada "Item". Sin embargo, un desarrollador de bibliotecas de clases puede usar IndexerNameAttribute el atributo para cambiar el nombre del indexador en los metadatos. Por ejemplo, la String clase tiene un indexador denominado Chars[] . Las propiedades indizadas creadas con lenguajes distintos de C# también pueden tener nombres distintos de Item.
Para determinar si un tipo tiene una propiedad predeterminada, use el GetCustomAttributes(Type, Boolean) método para probar el DefaultMemberAttribute atributo. Si el tipo tiene DefaultMemberAttribute , la propiedad devuelve el nombre de la propiedad MemberName predeterminada.
Consulte también
- PropertyInfo
- String
- DefaultBinder
- GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
- GetProperties(BindingFlags)
Se aplica a
GetProperty(String, Type, Type[])
Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos de argumentos especificados.
public:
System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ types);
public:
virtual System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ types);
public System.Reflection.PropertyInfo? GetProperty (string name, Type? returnType, Type[] types);
public System.Reflection.PropertyInfo GetProperty (string name, Type returnType, Type[] types);
member this.GetProperty : string * Type * Type[] -> System.Reflection.PropertyInfo
abstract member GetProperty : string * Type * Type[] -> System.Reflection.PropertyInfo
override this.GetProperty : string * Type * Type[] -> System.Reflection.PropertyInfo
Public Function GetProperty (name As String, returnType As Type, types As Type()) As PropertyInfo
Parámetros
- name
- String
Cadena que contiene el nombre de la propiedad pública que se va a obtener.
- returnType
- Type
Tipo de valor devuelto de la propiedad.
- types
- Type[]
Matriz de objetos Type que representa el número, el orden y el tipo de parámetros que la propiedad indizada debe obtener.
O bien Matriz vacía del tipo Type (es decir, Type[] types = new Type[0]) para obtener una propiedad que no esté indizada.
Devoluciones
Objeto que representa la propiedad pública cuyos parámetros coinciden con los tipos de argumentos especificados, si se encuentra; en caso contrario, null
.
Implementaciones
Excepciones
Se encontró más de una propiedad con el nombre especificado y que coincide con los tipos de argumento especificados.
types
es multidimensional.
Un elemento de types
es null
.
Comentarios
Una propiedad se considera pública para la reflexión si tiene al menos un accessor que es público. De lo contrario, la propiedad se considera privada y debe usar | | (en Visual Basic, combine los valores mediante BindingFlags.NonPublic BindingFlags.Instance ) para BindingFlags.Static Or
obtenerla.
La búsqueda de name
distingue mayúsculas de minúsculas. La búsqueda incluye propiedades públicas de instancias estáticas y públicas.
Si el objeto actual representa un tipo genérico construido, este método devuelve con los parámetros de tipo Type PropertyInfo reemplazados por los argumentos de tipo adecuados.
Si el objeto actual representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en las Type propiedades de la restricción de clase.
Indexadores y propiedades predeterminadas
Visual Basic 2005, Visual C# 2005 y Visual C++ 2005 tienen una sintaxis simplificada para acceder a las propiedades indizadas y permiten que una propiedad indizada sea un valor predeterminado para su tipo. Por ejemplo, si la variable hace referencia a , la sintaxis ( en Visual Basic) recupera el elemento con el myList
ArrayList índice de myList[3]
myList(3)
3. Puede sobrecargar la propiedad .
En C#, esta característica se denomina indexador y no se puede hacer referencia a esta característica por su nombre. De forma predeterminada, un indexador de C# aparece en los metadatos como una propiedad indizada denominada "Item". Sin embargo, un desarrollador de bibliotecas de clases puede usar IndexerNameAttribute el atributo para cambiar el nombre del indexador en los metadatos. Por ejemplo, la String clase tiene un indexador denominado Chars[] . Las propiedades indizadas creadas con lenguajes distintos de C# también pueden tener nombres distintos de Item.
Para determinar si un tipo tiene una propiedad predeterminada, use el GetCustomAttributes(Type, Boolean) método para probar el DefaultMemberAttribute atributo. Si el tipo tiene DefaultMemberAttribute , la propiedad devuelve el nombre de la propiedad MemberName predeterminada.
Consulte también
- PropertyInfo
- String
- DefaultBinder
- GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
- GetProperties(BindingFlags)
Se aplica a
GetProperty(String, Type, Type[], ParameterModifier[])
Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos y modificadores de los argumentos especificados.
public:
System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public:
virtual System::Reflection::PropertyInfo ^ GetProperty(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.PropertyInfo? GetProperty (string name, Type? returnType, Type[] types, System.Reflection.ParameterModifier[]? modifiers);
public System.Reflection.PropertyInfo GetProperty (string name, Type returnType, Type[] types, System.Reflection.ParameterModifier[] modifiers);
member this.GetProperty : string * Type * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.PropertyInfo
abstract member GetProperty : string * Type * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.PropertyInfo
override this.GetProperty : string * Type * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.PropertyInfo
Public Function GetProperty (name As String, returnType As Type, types As Type(), modifiers As ParameterModifier()) As PropertyInfo
Parámetros
- name
- String
Cadena que contiene el nombre de la propiedad pública que se va a obtener.
- returnType
- Type
Tipo de valor devuelto de la propiedad.
- types
- Type[]
Matriz de objetos Type que representa el número, el orden y el tipo de parámetros que la propiedad indizada debe obtener.
O bien Matriz vacía del tipo Type (es decir, Type[] types = new Type[0]) para obtener una propiedad que no esté indizada.
- modifiers
- ParameterModifier[]
Matriz de objetos ParameterModifier que representan los atributos asociados al elemento correspondiente de la matriz types
. El enlazador predeterminado no procesa este parámetro.
Devoluciones
Objeto que representa la propiedad pública que cumple los requisitos especificados, si se encuentra; en caso contrario, es null
.
Implementaciones
Excepciones
Existe más de una propiedad con el nombre especificado que coincide con los modificadores y tipos de argumentos especificados.
types
es multidimensional.
O bien
modifiers
es multidimensional.
O bien
types
y modifiers
no tienen la misma longitud.
Un elemento de types
es null
.
Ejemplos
En el ejemplo siguiente se obtiene un objeto correspondiente a y la propiedad indizada de esta clase se recupera utilizando los Type
MyPropertyClass
argumentos pasados al GetProperty
método .
using namespace System;
using namespace System::Reflection;
public ref class MyPropertyClass
{
private:
array<int, 2>^ myPropertyArray;
public:
property int Item [int, int]
{
// Declare an indexer.
int get( int i, int j )
{
return myPropertyArray[ i,j ];
}
void set( int i, int j, int value )
{
myPropertyArray[ i,j ] = value;
}
}
};
int main()
{
try
{
Type^ myType = MyPropertyClass::typeid;
array<Type^>^myTypeArray = gcnew array<Type^>(2);
// Create an instance of the Type array representing the number, order
// and type of the parameters for the property.
myTypeArray->SetValue( int::typeid, 0 );
myTypeArray->SetValue( int::typeid, 1 );
// Search for the indexed property whose parameters match the
// specified argument types and modifiers.
PropertyInfo^ myPropertyInfo = myType->GetProperty( "Item", int::typeid, myTypeArray, nullptr );
Console::WriteLine( "{0}.{1} has a property type of {2}", myType->FullName, myPropertyInfo->Name, myPropertyInfo->PropertyType );
}
catch ( Exception^ ex )
{
Console::WriteLine( "An exception occurred {0}", ex->Message );
}
}
using System;
using System.Reflection;
public class MyPropertyClass
{
private int [,] myPropertyArray = new int[10,10];
// Declare an indexer.
public int this [int i,int j]
{
get
{
return myPropertyArray[i,j];
}
set
{
myPropertyArray[i,j] = value;
}
}
}
public class MyTypeClass
{
public static void Main()
{
try
{
Type myType=typeof(MyPropertyClass);
Type[] myTypeArray = new Type[2];
// Create an instance of the Type array representing the number, order
// and type of the parameters for the property.
myTypeArray.SetValue(typeof(int),0);
myTypeArray.SetValue(typeof(int),1);
// Search for the indexed property whose parameters match the
// specified argument types and modifiers.
PropertyInfo myPropertyInfo = myType.GetProperty("Item",
typeof(int),myTypeArray,null);
Console.WriteLine(myType.FullName + "." + myPropertyInfo.Name +
" has a property type of " + myPropertyInfo.PropertyType);
}
catch(Exception ex)
{
Console.WriteLine("An exception occurred " + ex.Message);
}
}
}
Imports System.Reflection
Public Class MyPropertyClass
Private myPropertyArray(9, 9) As Integer
' Declare an indexer.
Default Public Property Item(ByVal i As Integer, ByVal j As Integer) As Integer
Get
Return myPropertyArray(i, j)
End Get
Set(ByVal Value As Integer)
myPropertyArray(i, j) = Value
End Set
End Property
End Class
Public Class MyTypeClass
Public Shared Sub Main()
Try
Dim myType As Type = GetType(MyPropertyClass)
Dim myTypeArray(1) As Type
' Create an instance of a Type array representing the number, order
' and type of the parameters for the property.
myTypeArray.SetValue(GetType(Integer), 0)
myTypeArray.SetValue(GetType(Integer), 1)
' Search for the indexed property whose parameters match the
' specified argument types and modifiers.
Dim myPropertyInfo As PropertyInfo = myType.GetProperty("Item", _
GetType(Integer), myTypeArray, Nothing)
Console.WriteLine(myType.FullName + "." + myPropertyInfo.Name + _
" has a property type of " + myPropertyInfo.PropertyType.ToString())
Catch ex As Exception
Console.WriteLine("An exception occurred " + ex.Message.ToString())
End Try
End Sub
End Class
Comentarios
Una propiedad se considera pública para la reflexión si tiene al menos un accessor que es público. De lo contrario, la propiedad se considera privada y debe usar | | (en Visual Basic, combine los valores mediante BindingFlags.NonPublic BindingFlags.Instance ) para BindingFlags.Static Or
obtenerla.
Aunque el enlazador predeterminado no procesa (el parámetro ), puede usar la clase abstracta para escribir un ParameterModifier modifiers
System.Reflection.Binder enlazador personalizado que procese modifiers
. ParameterModifier
solo se usa cuando se llama a través de interoperabilidad COM y solo se controlan los parámetros que se pasan por referencia.
La búsqueda de name
distingue mayúsculas de minúsculas. La búsqueda incluye propiedades públicas de instancias estáticas y públicas.
Si el objeto actual representa un tipo genérico construido, este método devuelve con los parámetros Type PropertyInfo de tipo reemplazados por los argumentos de tipo adecuados.
Si el objeto actual representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en las Type propiedades de la restricción de clase.
Indexadores y propiedades predeterminadas
Visual Basic 2005, Visual C# 2005 y Visual C++ 2005 tienen una sintaxis simplificada para acceder a las propiedades indizadas y permiten que una propiedad indizada sea un valor predeterminado para su tipo. Por ejemplo, si la variable hace referencia a , la sintaxis ( en Visual Basic) recupera el elemento myList
con el índice de ArrayList myList[3]
myList(3)
3. Puede sobrecargar la propiedad .
En C#, esta característica se denomina indexador y no se puede hacer referencia a esta característica por nombre. De forma predeterminada, un indexador de C# aparece en los metadatos como una propiedad indizada denominada "Item". Sin embargo, un desarrollador de bibliotecas de clases puede usar IndexerNameAttribute el atributo para cambiar el nombre del indexador en los metadatos. Por ejemplo, la String clase tiene un indexador denominado Chars[] . Las propiedades indizadas creadas con lenguajes distintos de C# también pueden tener nombres distintos de Item.
Para determinar si un tipo tiene una propiedad predeterminada, use el GetCustomAttributes(Type, Boolean) método para probar el DefaultMemberAttribute atributo. Si el tipo tiene DefaultMemberAttribute , la propiedad devuelve el nombre de la propiedad MemberName predeterminada.
Consulte también
- PropertyInfo
- String
- DefaultBinder
- ParameterModifier
- GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
- GetProperties(BindingFlags)