Рефакторинг для устранения повторения в лямбда-выражении

Повторение есть в именах, но C# не знает, что PropertyA в одном классе связано с PropertyA в другом. Вы должны установить соединение явно. То, как вы это сделали, отлично работает. Если у вас их достаточно, вы можете подумать об использовании отражения, чтобы написать один метод, который мог бы сделать это для любой пары классов.

Обращайте внимание на влияние любого выбранного вами метода на производительность. Само по себе отражение медленнее. Однако вы также можете использовать отражение для генерации IL, которая после генерации будет работать так же быстро, как и то, что вы написали. Вы также можете сгенерировать дерево выражений и преобразовать его в скомпилированный делегат. Эти методы несколько сложны, поэтому вы должны взвесить компромиссы.

Что ж, у меня есть способ действительно ужасно, которым вы могли бы это сделать.

Вы могли бы написать метод, который использовал отражение (терпите меня!), Чтобы проработать все свойства для определенного типа, и создать делегат (используя Reflection.Emit) для копирования свойств из этого типа в другой. Затем используйте анонимный тип, чтобы убедиться, что вам нужно создать копирующий делегат только один раз, чтобы это было быстро. Тогда ваш метод будет выглядеть так:

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

Нюансы тут:

• MagicCopier - это универсальный тип, а Copy - универсальный метод, поэтому вы можете явно указать «целевой» тип, но неявно указать «исходный» тип.
• Он использует инициализатор проекции для вывода имен свойств из выражений, используемых для инициализации анонимного типа.

Не уверен, действительно ли оно того стоит, но идея довольно забавная ... Возможно, мне все равно придется ее реализовать :)

Обновлено: С MemberInitExpression мы могли бы сделать все это с помощью дерева выражений, что делает его намного проще, чем CodeDOM. Попробую сегодня вечером ...

Обновлено: Готово, и на самом деле это довольно простой код. Вот класс:

/// <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();
        }
    }

И называя это:

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

Вы можете позволить вызывающей стороне возвращать свой собственный объект анонимного типа только со свойствами, которые им нужны:

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});

Если FooEditDto является подклассом FooDto и выражения MemberInitExpressions вам не нужны, используйте конструктор:

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
    };
}