Meilleure façon d'obtenir des sous-propriétés à l'aide de GetProperty

Vous auriez besoin de quelque chose comme:

PropertyInfo addressProperty = typeof(Customer).GetProperty("Address");
ProportyInfo zipCodeProperty = addressProperty.PropertyType.GetProperty("ZipCode");

object address = addressProperty.GetValue(customer, null);
object zipCode = zipCodeProperty.GetValue(address, null);

Fondamentalement, si vous voulez prendre une corde "de l'Adresse.Code postal" et naviguez vers le bas, vous devez diviser par "." et ensuite appeler GetProperty sur le type approprié à chaque étape pour obtenir la propriété elle-même, puis PropertyInfo.GetValue pour obtenir la valeur suivante dans la chaîne. Quelque chose comme ceci:

public static object FollowPropertyPath(object value, string path)
{
    Type currentType = value.GetType();

    foreach (string propertyName in path.Split('.'))
    {
        PropertyInfo property = currentType.GetProperty(propertyName);
        value = property.GetValue(value, null);
        currentType = property.PropertyType;
    }
    return value;
}

L'appeler comme ceci:

object zipCode = FollowPropertyPath(customer, "Address.ZipCode");

Notez que cela fonctionne sur le moment de la compilation types de propriétés. Si vous le souhaitez pour faire face au temps d'exécution de type (par exemple, si le client.L'adresse n'a pas un code Postal de la propriété, mais le type retourné par Adresse) puis changer property.PropertyType à property.GetType().

Notez également que ce n'est pas toute erreur de manipulation etc 🙂

Les questions /réponses sont beaux; juste un point de vue alternatif: dans de nombreux cas, il est souhaitable d'utiliser le Système.ComponentModel plutôt que de la réflexion, car cela permet d'exécution propriété scénarios - à-dire comment un DataTable du DataView expose les colonnes comme propriétés.

Performance sage - par défaut, c'est en grande partie identique, mais si vous faites beaucoup de ce (par exemple, la masse de données importation/exportation), vous pouvez réellement obtenir une amélioration significative des performances à l'aide de cette approche, avec l'aimable autorisation de HyperDescriptor.

À utiliser le Système.ComponentModel, le code est similaire, mais légèrement différents:

static void Main()
{
object obj = new Customer { Address = new Address { ZipCode = "abcdef" } };
object address = GetValue(obj, "Address");
object zip = GetValue(address, "ZipCode");
Console.WriteLine(zip);
}
static object GetValue(object component, string propertyName)
{
return TypeDescriptor.GetProperties(component)[propertyName].GetValue(component);
}

Cela vous donne ensuite la même manipulation que si vous aviez utilisé les données de liaison pour lier à "Adresse.Code postal" (abstraction de certains détails comme les listes, etc).

(à noter que vous pourriez lancer zip comme une chaîne de caractères, etc si vous savez qui est le type attendu)

Pour obtenir la valeur d'un profond chemin d'accès (y compris la même liste de manipulation de liaison de données utilise), vous pouvez utiliser quelque chose comme:

static object ResolveValue(object component, string path) {
foreach(string segment in path.Split('.')) {
if (component == null) return null;
if(component is IListSource) {
component = ((IListSource)component).GetList();
}
if (component is IList) {
component = ((IList)component)[0];
}
component = GetValue(component, segment);
}
return component;
}

La liste des trucs environ reflète le comportement de l'ordinaire de liaison de données (bien qu'il omet de mentionner quelques petites choses comme la liaison des contextes de devises, gestionnaires, etc)

adabyron,

J'ai créé une version de votre code quand vous avez seulement besoin de saisir les types, et si vous n'avez pas une réelle instance de l'objet.

    public static Type FollowPropertyPath<T>(string path)
{
if (path == null) throw new ArgumentNullException("path");
Type currentType = typeof(T);
foreach (string propertyName in path.Split('.'))
{
int brackStart = propertyName.IndexOf("[");
var property = currentType.GetProperty(brackStart > 0 ? propertyName.Substring(0, brackStart) : propertyName);
if (property == null)
return null;
currentType = property.PropertyType;
if (brackStart > 0)
{
foreach (Type iType in currentType.GetInterfaces())
{
if (iType.IsGenericType && iType.GetGenericTypeDefinition() == typeof (IDictionary<,>))
{
currentType = iType.GetGenericArguments()[1];
break;
}
if (iType.IsGenericType && iType.GetGenericTypeDefinition() == typeof (ICollection<>))
{
currentType = iType.GetGenericArguments()[0];
break;
}
}
}
}
return currentType;
}