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

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

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

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

Нюансы здесь:

• MagicCopier является универсальным типом, и Копия является общим методом так, чтобы можно было явно указать "целевой" тип, но неявно указать "исходный" тип.
• Это использует инициализатор проекции для выведения названий свойств от выражений, используемых для инициализации анонимного типа

Я не уверен, действительно ли это стоит того, но это - вполне забавная идея... Мне, вероятно, придется реализовать его так или иначе :)

Править: С 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});

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

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