Właściwość odnośnika na wykresie obiektu za pomocą ciągu znaków

Question

Próbuję uzyskać dostęp do różnych części zagnieżdżonej struktury klas, używając dowolnego ciągu znaków .

Przy następujących klas (wymyślonych):

public class Person 
{ 
    public Address PersonsAddress { get; set; } 
} 

public class Adddress 
{ 
    public PhoneNumber HousePhone { get; set; } 
} 

public class PhoneNumber 
{ 
    public string Number { get; set; } 
} 

które chciałbym, aby móc uzyskać obiektu w "PersonsAddress.HousePhone.Number" z instancji obiektu Person.

Obecnie robię kilka funky rekursywne wyszukiwanie za pomocą refleksji, ale mam nadzieję, że niektórzy ninja tam mają jakieś lepsze pomysły.

Dla porównania, tutaj jest metoda (bzdura) Mam rozwinięte:

private static object ObjectFromString(object basePoint, IEnumerable<string> pathToSearch) 
{ 
    var numberOfPaths = pathToSearch.Count(); 

    if (numberOfPaths == 0) 
    return null; 

    var type = basePoint.GetType(); 
    var properties = type.GetProperties(); 

    var currentPath = pathToSearch.First(); 

    var propertyInfo = properties.FirstOrDefault(prop => prop.Name == currentPath); 

    if (propertyInfo == null) 
    return null; 

    var property = propertyInfo.GetValue(basePoint, null); 

    if (numberOfPaths == 1) 
    return property; 

    return ObjectFromString(property, pathToSearch.Skip(1)); 
} 

Answer 1

Mogłeś po prostu użyć standardowego .NET DataBinder.Eval Method coś takiego:

object result = DataBinder.Eval(myPerson, "PersonsAddress.HousePhone.Number"); 

Answer 2

Oto nierekursywnych wersja z (prawie) same semantyki:

private static object ObjectFromString(object basePoint, IEnumerable<string> pathToSearch) 
{ 
    var value = basePoint; 
    foreach (var propertyName in pathToSearch) 
    { 
     var property = value.GetType().GetProperty(propertyName); 
     if (property == null) return null; 
     value = property.GetValue(value, null); 
    } 
    return value; 
} 

Answer 3

mam w przeszłości coś podobnego. Poszedłem z podejściem lambda, ponieważ po ich skompilowaniu mogę je buforować. Usunąłem buforowanie w tym kodzie.

Dołączyłem kilka testów jednostkowych, aby pokazać użycie tej metody. Mam nadzieję, że to będzie pomocne.

private static object GetValueForPropertyOrField(object objectThatContainsPropertyName, IEnumerable<string> properties) 
    { 
    foreach (var property in properties) 
    { 
     Type typeOfCurrentObject = objectThatContainsPropertyName.GetType(); 

     var parameterExpression = Expression.Parameter(typeOfCurrentObject, "obj"); 
     Expression memberExpression = Expression.PropertyOrField(parameterExpression, property); 

     var expression = Expression.Lambda(Expression.GetDelegateType(typeOfCurrentObject, memberExpression.Type), memberExpression, parameterExpression).Compile(); 

     objectThatContainsPropertyName = expression.DynamicInvoke(objectThatContainsPropertyName); 
    } 

    return objectThatContainsPropertyName; 
    } 

    [TestMethod] 
    public void TestOneProperty() 
    { 
    var dateTime = new DateTime(); 

    var result = GetValueForPropertyOrField(dateTime, new[] { "Day" }); 

    Assert.AreEqual(dateTime.Day, result); 
    } 

    [TestMethod] 
    public void TestNestedProperties() 
    { 
    var dateTime = new DateTime(); 

    var result = GetValueForPropertyOrField(dateTime, new[] { "Date", "Day" }); 

    Assert.AreEqual(dateTime.Date.Day, result); 
    } 

    [TestMethod] 
    public void TestDifferentNestedProperties() 
    { 
    var dateTime = new DateTime(); 

    var result = GetValueForPropertyOrField(dateTime, new[] { "Date", "DayOfWeek" }); 

    Assert.AreEqual(dateTime.Date.DayOfWeek, result); 
    } 

Answer 4

Skoro już jesteś zainteresowany w rozwiązywaniu ścieżki własności ciąg, można skorzystać z patrząc w bibliotece Dynamic LINQ zapytań pisał jako przykład autorstwa Scotta Guthrie @ Microsoft. Analizuje twoje wyrażenia łańcuchowe i generuje drzewa ekspresowe, które mogą być kompilowane i buforowane zgodnie z sugestią @Brian Dishaw.

Zapewni to bogactwo dodatkowych opcji, zapewniając prostą i niezawodną składnię wyrażeń, której można użyć w podejściu konfiguracyjnym. Obsługuje typowe metody LINQ na wyliczeniach, a także prostą logikę operatora, obliczenia matematyczne, ocenę ścieżki własności, itp.