Refactor Pour éliminer la répétition dans Lambda Expression

Question

Ces deux méthodes répétition d'exposition:

public static Expression<Func<Foo, FooEditDto>> EditDtoSelector() 
{ 
    return f => new FooEditDto 
    { 
     PropertyA = f.PropertyA, 
     PropertyB = f.PropertyB, 
     PropertyC = f.PropertyC, 
     PropertyD = f.PropertyD, 
     PropertyE = f.PropertyE 
    }; 
} 

public static Expression<Func<Foo, FooListDto>> ListDtoSelector() 
{ 
    return f => new FooDto 
    { 
     PropertyA = f.PropertyA, 
     PropertyB = f.PropertyB, 
     PropertyC = f.PropertyC 
    }; 
} 

Comment puis-je factoriser pour éliminer cette répétition?

MISE À JOUR: Oups, j'ai oublié de mentionner un point important. FooEditDto est une sous-classe de FooDto.

Answer 1

Si FooEditDto est un sous-ensemble de FooDto et vous n'avez pas besoin des MemberInitExpressions, utilisez un constructeur:

class FooDto 
{ public FooDto(Bar a, Bar b, Bar c) 
    { PropertyA = a; 
     PropertyB = b; 
     PropertyC = c; 
    } 
    public Bar PropertyA {get;set;} 
    public Bar PropertyB {get;set;} 
    public Bar PropertyC {get;set;} 
} 

class FooEditDto : FooDto 
{ public FooEditDto(Bar a, Bar b, Bar c) : base(a,b,c) 
    public Bar PropertyD {get;set;} 
    public Bar PropertyE {get;set;} 
} 

public static Expression<Func<Foo, FooEditDto>> EditDtoSelector() 
{ 
    return f => new FooEditDto(f.PropertyA,f.PropertyB,f.PropertyC) 
    { 
     PropertyD = f.PropertyD, 
     PropertyE = f.PropertyE 
    }; 
} 

Answer 2

La répétition est dans les noms, mais C# n'a aucune idée que PropertyA dans une classe est connecté à PropertyA dans un autre. Vous devez faire la connexion explicitement. La façon dont vous l'avez fait fonctionne bien. Si vous en avez assez, vous pourriez envisager d'utiliser la réflexion pour écrire une méthode qui pourrait le faire pour n'importe quelle paire de classes.

Faites attention aux implications de performance de n'importe quelle méthode que vous choisissez. La réflexion par elle-même est plus lente. Cependant, vous pouvez également utiliser la réflexion pour émettre IL qui, une fois émis, fonctionnera aussi vite que ce que vous avez écrit. Vous pouvez également générer une arborescence d'expression et la convertir en un délégué compilé. Ces techniques sont quelque peu compliquées, vous devez donc peser les compromis.

Answer 3

Eh bien, j'ai un vraiment horrible comme vous pouvez le faire.

Vous pouvez écrire une méthode qui a utilisé la réflexion (ours avec moi!) Pour élaborer toutes les propriétés pour un type particulier, et construit un délégué (en utilisant Reflection.Emit) pour copier les propriétés de ce type à un autre. Ensuite, utilisez un type anonyme pour vous assurer que vous n'avez besoin de créer le délégué de copie qu'une seule fois, donc c'est rapide. Votre méthode doit ressembler à ceci:

public static Expression<Func<Foo, FooEditDto>> EditDtoSelector() 
{ 
    return f => MagicCopier<FooEditDto>.Copy(new { 
     f.PropertyA, f.PropertyB, f.PropertyC, f.PropertyD, f.PropertyC 
    }); 
} 

Les nuances ici:

• MagicCopier est un type générique et Copy est une méthode générique de sorte que vous pouvez spécifier explicitement le type « cible », mais implicitement spécifiez le type "source".
• Il utilise un initialiseur de projection pour en déduire les noms des propriétés des expressions utilisées pour initialiser le type anonyme

Je ne suis pas sûr que ce soit vraiment la peine, mais il est tout à fait une idée amusante ... Je peux devoir l'implémenter de toute façon :)

EDIT: Avec MemberInitExpression nous pourrions faire tout cela avec un arbre d'expression, ce qui le rend beaucoup plus facile que CodeDOM. Je vais essayer ce soir ...

EDIT: Fait, et c'est en fait un code assez simple. Voici la classe:

/// <summary> 
/// Generic class which copies to its target type from a source 
/// type specified in the Copy method. The types are specified 
/// separately to take advantage of type inference on generic 
/// method arguments. 
/// </summary> 
public static class PropertyCopy<TTarget> where TTarget : class, new() 
{ 
    /// <summary> 
    /// Copies all readable properties from the source to a new instance 
    /// of TTarget. 
    /// </summary> 
    public static TTarget CopyFrom<TSource>(TSource source) where TSource : class 
    { 
     return PropertyCopier<TSource>.Copy(source); 
    } 

    /// <summary> 
    /// Static class to efficiently store the compiled delegate which can 
    /// do the copying. We need a bit of work to ensure that exceptions are 
    /// appropriately propagated, as the exception is generated at type initialization 
    /// time, but we wish it to be thrown as an ArgumentException. 
    /// </summary> 
    private static class PropertyCopier<TSource> where TSource : class 
    { 
     private static readonly Func<TSource, TTarget> copier; 
     private static readonly Exception initializationException; 

     internal static TTarget Copy(TSource source) 
     { 
      if (initializationException != null) 
      { 
       throw initializationException; 
      } 
      if (source == null) 
      { 
       throw new ArgumentNullException("source"); 
      } 
      return copier(source); 
     } 

     static PropertyCopier() 
     { 
      try 
      { 
       copier = BuildCopier(); 
       initializationException = null; 
      } 
      catch (Exception e) 
      { 
       copier = null; 
       initializationException = e; 
      } 
     } 

     private static Func<TSource, TTarget> BuildCopier() 
     { 
      ParameterExpression sourceParameter = Expression.Parameter(typeof(TSource), "source"); 
      var bindings = new List<MemberBinding>(); 
      foreach (PropertyInfo sourceProperty in typeof(TSource).GetProperties()) 
      { 
       if (!sourceProperty.CanRead) 
       { 
        continue; 
       } 
       PropertyInfo targetProperty = typeof(TTarget).GetProperty(sourceProperty.Name); 
       if (targetProperty == null) 
       { 
        throw new ArgumentException("Property " + sourceProperty.Name 
         + " is not present and accessible in " + typeof(TTarget).FullName); 
       } 
       if (!targetProperty.CanWrite) 
       { 
        throw new ArgumentException("Property " + sourceProperty.Name 
         + " is not writable in " + typeof(TTarget).FullName); 
       } 
       if (!targetProperty.PropertyType.IsAssignableFrom(sourceProperty.PropertyType)) 
       { 
        throw new ArgumentException("Property " + sourceProperty.Name 
         + " has an incompatible type in " + typeof(TTarget).FullName); 
       } 
       bindings.Add(Expression.Bind(targetProperty, Expression.Property(sourceParameter, sourceProperty))); 
      } 
      Expression initializer = Expression.MemberInit(Expression.New(typeof(TTarget)), bindings); 
      return Expression.Lambda<Func<TSource,TTarget>>(initializer, sourceParameter).Compile(); 
     } 
    } 

et de l'appeler:

TargetType target = PropertyCopy<TargetType>.CopyFrom(new { First="Foo", Second="Bar" }); 

Answer 4

Vous pouvez laisser l'appelant revenir leur propre objet d'un type anonyme avec uniquement les propriétés dont ils ont besoin:

public static Expression<Func<Foo,T>> 
          GetSelector<T>(Expression<Func<Foo,T>> f) 
{ return f; 
} 

/* ... */ 
var expr = GetSelector(f => new{f.PropertyA,f.PropertyB,f.PropertyC});