Passer l'expression à l'initialisateur

Question

Je voudrais passer une expression qui représente une variable à utiliser lors de l'instanciation d'un objet.

Au lieu de :

class MyObject : IMyInterface { ... }

var list = db.MyObjects.Where(x => !x.IsDeleted).ToList();
var anotherList = list.Select(x => new AnotherObject() { 
  Id = x.Id,
  Value = x.Value
});

J'aimerais faire en sorte qu'une liste d'objets de type IMyInterface peut être transformée en un autre type de liste (AnotherObject par exemple) en utilisant des expressions définies comme suit :

var list = db.MyObjects
  .Where(x => !x.IsDeleted)
  .ToAnotherObjectList(x => x.Id, x => x.Value);

...

public static List<AnotherObject> ToAnotherObjectList<T>(
  this IEnumerable<IMyInterface> list, 
  Expression id, 
  Expression value)
{
    return list.Select(x => new AnotherObject() { Id = id, Value = value }).ToList();
}

Je ne suis pas sûr de la façon d'y parvenir. Je sais que je peux utiliser la réflexion pour créer des objets et définir des propriétés à l'aide d'une chaîne de caractères, mais je ne sais pas comment passer des expressions.

UPDATE

Eh bien, je pensais devoir réfléchir, mais c'est plus simple que ce que je pensais. Voici ma solution qui fonctionne en IRL.

public static IEnumerable<AnotherObject> ToAnotherObject<T>(this IEnumerable<T> list, Func<T, int> getId, Func<T, string> getValue, Func<T, bool> getSelected = null) where T : IMyInterface
{
    return list.Select(x => new AnotherObject {
        Display = getValue(x),
        Id = getId(x),
        Selected = getSelected != null && getSelected(x),
    });
}

Answer 1

Vous pourriez utiliser un Func<TInput,TReturn> pour cela. Par exemple :

public static List<AnotherObject> ToAnotherObjectList<T>(
  this IEnumerable<T> list, 
  Func<T, int> getId,
  Func<T, object> getValue)
{
    return list.Select(x => new AnotherObject() { Id = getId(x), Value = getValue(x) }).ToList();
}

Appelez :

list.ToAnotherObjectList(i => i.Id, i=> i.Value);

Dans cet exemple j'ai utilisé des Funcs avec un paramètre (de type T) et un retour de type int/objet.