Propiedad de búsqueda en el gráfico de objetos a través de una cadena

Question

Estoy intentando acceder a varias partes de una estructura de clase anidada utilizando una cadena arbitraria .

Dadas las clases (artificiales) siguientes:

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

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

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

Me gustaría ser capaz de conseguir el objeto en "PersonsAddress.HousePhone.Number" desde una instancia del objeto Person.

Actualmente estoy haciendo algunas búsquedas funky recursivas usando la reflexión, pero espero que algunos ninjas tengan mejores ideas.

Para referencia, aquí es el método (cutre) que he desarrollado:

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

Usted puede simplemente utilizar el estándar .NET DataBinder.Eval Method, así:

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

Answer 2

Aquí hay una versión no recursiva con (casi) la misma semántica:

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

tengo tenía algo similar en el pasado. Fui con el enfoque lambda porque después de compilarlos puedo guardarlos en caché. He eliminado el almacenamiento en caché en este código.

Incluí algunas pruebas unitarias para mostrar el uso del método. Espero que esto sea útil.

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

Puesto que ya está interesado en la resolución de los caminos de propiedad cadena, se pueden beneficiar de buscar en la biblioteca de consulta publicado como Dynamic LINQ un ejemplo de Scott Guthrie @ Microsoft. Analiza las expresiones de cadena y produce árboles expresos que se pueden compilar y almacenar en caché según lo sugerido por @Brian Dishaw.

Esto le proporcionará una gran cantidad de opciones adicionales al proporcionar una sintaxis de expresión simple y robusta que puede utilizar en su enfoque de configuración. Es compatible con los métodos LINQ comunes en enumerables, además de lógica de operador simple, cálculos matemáticos, evaluación de ruta de propiedad, etc.