proprietà Ricerca in oggetto grafico tramite una stringa

Question

Sto cercando di accedere a varie parti di una struttura di classe nidificata utilizzando un arbitrario stringa .

Dati i seguenti (artificiosa) classi:

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

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

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

mi piacerebbe essere in grado di ottenere l'oggetto "PersonsAddress.HousePhone.Number" da un'istanza dell'oggetto Person.

Attualmente sto facendo un po 'di ricerca ricorsiva funky utilizzando la riflessione, ma spero che alcuni ninja là fuori hanno alcune idee migliori.

Per avere un riferimento, qui è il metodo (scadente) ho sviluppato:

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

Si potrebbe semplicemente utilizzare lo standard .NET DataBinder.Eval Method, in questo modo:

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

Answer 2

Ecco una versione non ricorsiva con (quasi) la stessa semantica:

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

ho dovuto qualcosa di simile in passato. Sono andato con l'approccio lambda perché dopo averli compilati posso memorizzarli nella cache. Ho rimosso la cache in questo codice.

ho inserito un paio di unit test per mostrare l'utilizzo del metodo. Spero che questo sia utile.

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

Dal momento che sono già interessati a risolvere i percorsi di proprietà della stringa, si può beneficiare di guardare in biblioteca Dynamic LINQ interrogazione inviato come un esempio di Scott Guthrie @ Microsoft. Analizza le espressioni di stringa e produce alberi espressi che possono essere compilati e memorizzati nella cache come suggerito da @Brian Dishaw.

Ciò fornirà una vasta gamma di opzioni aggiuntive, fornendo una sintassi semplice e robusto espressione è possibile utilizzare nel vostro approccio di configurazione. Esso supporta i comuni metodi di LINQ su enumerables, più logica operatore semplice, calcoli matematici, proprietà valutazione percorso, ecc