Comment convertir une expression LINQ telle que « obj => obj.Prop » en « parent => parent.obj.Prop » pour l'accès aux objets imbriqués ?

obj.Prop" à "parent => parent.obj.Prop" pour l'accès aux objets imbriqués ? " />

Convertir l'expression LINQ "obj => obj.Prop" en "parent => parent.obj.Prop" : guide étape par étape

Les expressions LINQ offrent un moyen puissant d'accéder aux propriétés d'un objet. Cependant, vous devez parfois parcourir plusieurs niveaux d'une hiérarchie, par exemple pour accéder aux propriétés d'objets imbriqués.

Considérez l'expression LINQ suivante :

<code class="language-c#">cust => cust.Name</code>

Cette expression récupère la propriété Name de l'objet client. Mais que se passe-t-il si vous devez accéder à la propriété Name de l'objet Customer dans CustomerModel ? L'expression originale semble insuffisante.

Pour résoudre ce problème, il faut une méthode qui accepte l'expression d'origine et génère une nouvelle expression, en prenant la classe parent comme paramètre d'entrée. Cette nouvelle expression deviendra le paramètre de la méthode MVC, permettant un accès efficace aux propriétés imbriquées.

Version initiale et bugs

Une approche possible est :

<code class="language-c#">public Expression<Func<object>> ExpressionFromField<T, TModel>(FieldDefinition<T> field)
    where TModel : BaseModel<T>
{
    var param = Expression.Parameter(typeof(TModel), "t");
    var body = Expression.PropertyOrField(param, nameof(SelectedItem));
    var member = Expression.MakeMemberAccess(body, field.Member);
    return Expression.Lambda<Func<object>>(member, param);
}</code>

Cependant, cette version échoue lors de l'accès aux propriétés imbriquées (par exemple cust.Address.State). L'erreur rencontrée indique que le membre spécifié n'existe pas dans le corps et que le corps fait référence à l'objet Customer plutôt qu'à l'objet Address.

Solution : combinaison d'expressions

La solution requise réside dans la composition de l'expression. Tout comme les fonctions peuvent être composées, les expressions peuvent également être composées :

<code class="language-c#">public static Expression<Func<T, TResult>> Compose<T, TIntermediate, TResult>(
    this Expression<Func<T, TIntermediate>> first,
    Expression<Func<TIntermediate, TResult>> second)
{
    return Expression.Lambda<Func<T, TResult>>(
        second.Body.Replace(second.Parameters[0], first.Body),
        first.Parameters[0]);
}</code>

Cela s'appuie sur la méthode Replace pour remplacer toutes les instances d'une expression par une autre expression. Avec ces méthodes, il est possible de construire l'expression suivante :

<code class="language-c#">Expression<Func<object>> propertySelector = cust => cust.Name;
Expression<Func<CustomerModel, Customer>> modelSelector = model => model.Customer;
Expression<Func<CustomerModel, object>> magic = modelSelector.Compose(propertySelector);</code>

Les expressions magiques peuvent désormais accéder efficacement à la propriété Name de l'objet Customer dans le CustomerModel. Il peut être utilisé comme paramètre d'expression d'une méthode MVC, offrant un accès transparent aux propriétés imbriquées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!