Comment puis-je éviter d'utiliser un nom de membre de chaîne pour obtenir un membre d'un type anonyme?

Question

J'utilise le code suivant pour récupérer des membres nommés d'un type anonyme. Y a-t-il un moyen de convertir le code suivant pour utiliser une expression lambda, ou du moins permettre au code appelant d'utiliser un lamda, même si je dois utiliser une chaîne en profondeur?

private T GetAnonymousTypeMember<T>(object anonymousType, string memberName) where T: class 
{ 
    var anonTypesType = anonymousType.GetType(); 
    var propInfo = anonTypesType.GetProperty(memberName); 
    return propInfo.GetValue(anonymousType, null) as T; 
} 

AJOUTÉE: Voici comment anonymousType arrive. La méthode GetAnonymousTypeMember est privé à une classe dont la méthode publique seulement est déclarée comme suit:

PublishNotification public void (NotificationTriggers déclenchent, templateParameters objet)

J'appelle cette méthode:

PublishNotification(NotificationTriggers.RequestCreated, new {NewJobCard = model}); 

Ce new {NewJobCard = model} est ce qui est passé à GetAnonymousTypeMember comme anonymousType.

Answer 1

public U GetMemberValue<T, U>(T instance, Expression<Func<T, U>> selector) 
{ 
    Type type = typeof(T); 
    var expr = selector.Body as MemberExpression; 
    string name = expr.Member.Name; 

    var prop = type.GetProperty(name); 
    return (U)prop.GetValue(instance, null); 
} 

permettra de le faire:

string name = GetMemberValue(new { Name = "Hello" }, o => o.Name); 

Answer 2

Non, lorsque vous envoyez l'objet au type object, il n'y a pas d'informations de type spécifiques pour le paramètre. Si vous voulez accéder aux membres de l'objet, vous devez utiliser la réflexion pour obtenir les informations de type de l'objet lui-même.

En utilisant une expression lambda pour obtenir le membre fonctionnerait, mais ce serait tout à fait inutile ...

Answer 3

Vous voulez dire quelque chose comme ça?

private R GetAnonymousTypeMember<T, R>(T anonymousType, Expression<Func<T, R>> e) where T : class 
{ 
    return e.Compile()(anonymousType); 
} 

public void Do() 
{ 
    var x = new {S = "1", V = 2}; 
    var v = GetAnonymousTypeMember(x, _ => _.V); 
} 

Answer 4

Mais pourquoi ne pas utiliser simplement dynamique? par exemple:

class MyClass 
{ 
    public int member = 123; 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
    MyClass obj = new MyClass(); 

    dynamic dynObj = obj; 
    Console.WriteLine(dynObj.member); 

    Console.ReadKey(); 
    } 
} 

Vous pouvez également impliquer ExpandoObject

List<dynamic> objs = new List<dynamic>(); 

dynamic objA = new ExpandoObject(); 
objA.member = "marian"; 
objs.Add(objA); 

dynamic objB = new ExpandoObject(); 
objB.member = 123; 
objs.Add(objB); 

dynamic objC = new ExpandoObject(); 
objC.member = Guid.NewGuid(); 
objs.Add(objC); 

foreach (dynamic obj in objs) 
    Console.WriteLine(obj.member); 

Console.ReadKey();