将一个对象属性值传输到另一个对象

首先，我知道自动映射器，而且我不想使用它。因为我正在学习C#我想深入了解它。所以我正在尝试自己解决这个问题（如下所述）。

但是，我正在尝试创建一个属性复制器，以将一种类型的属性值复制到另一种类型，前提是该属性具有相同的名称和类型，并且可以从源读取并在目标中写入。我在用着type.GetProperties()方法。采样方法在这里：

    static void Transfer(object source, object target) {

        var sourceType = source.GetType();
        var targetType = target.GetType();

        var sourceProps = sourceType.GetProperties(BindingFlags.Public | BindingFlags.Instance);

        var targetProps = (from t in targetType.GetProperties()
                           where t.CanWrite
                                 && (t.GetSetMethod().Attributes & MethodAttributes.Static) == 0
                           select t).ToList();

        foreach(var prop in sourceProps) {
            var value = prop.GetValue(source, null);
            var tProp = targetProps
                .FirstOrDefault(p => p.Name == prop.Name &&
                    p.PropertyType.IsAssignableFrom(prop.PropertyType));
            if(tProp != null)
                tProp.SetValue(target, value, null);
        }
    }

它有效，但我在 SO 上读到了一个答案，即使用System.Reflection.Emit and ILGenerator and 迟到的代表速度更快，性能更高。但没有更多解释或任何链接。您能帮助我了解加速此代码的方法吗？或者你能给我推荐一些关于Emit, ILGenerator, and 迟到的代表请？或者你认为有什么可以帮助我解决这个问题？

完整的问题：

我从@svick的回答中理解并学到了很多东西。但是现在，如果我想将它作为一个开放的泛型方法来使用，我该怎么做呢？像这样的东西：

public TTarget Transfer<TSource, TTarget>(TSource source) where TTarget : class, new() { } 

或扩展：

public static TTarget Transfer<TSource, TTarget>(this TSource source) where TTarget : class, new() { } 

You could使用 Reflection.Emit 来做到这一点，但它通常更容易使用Expressions 并且它为您提供基本相同的性能。请记住，只有缓存已编译的代码（例如在Dictionary<Tuple<Type, Type>, Action<object, object>>，我不在这里做。

static void Transfer(object source, object target)
{
    var sourceType = source.GetType();
    var targetType = target.GetType();

    var sourceParameter = Expression.Parameter(typeof(object), "source");
    var targetParameter = Expression.Parameter(typeof(object), "target");

    var sourceVariable = Expression.Variable(sourceType, "castedSource");
    var targetVariable = Expression.Variable(targetType, "castedTarget");

    var expressions = new List<Expression>();

    expressions.Add(Expression.Assign(sourceVariable, Expression.Convert(sourceParameter, sourceType)));
    expressions.Add(Expression.Assign(targetVariable, Expression.Convert(targetParameter, targetType)));

    foreach (var property in sourceType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
    {
        if (!property.CanRead)
            continue;

        var targetProperty = targetType.GetProperty(property.Name, BindingFlags.Public | BindingFlags.Instance);
        if (targetProperty != null
                && targetProperty.CanWrite
                && targetProperty.PropertyType.IsAssignableFrom(property.PropertyType))
        {
            expressions.Add(
                Expression.Assign(
                    Expression.Property(targetVariable, targetProperty),
                    Expression.Convert(
                        Expression.Property(sourceVariable, property), targetProperty.PropertyType)));
        }
    }

    var lambda =
        Expression.Lambda<Action<object, object>>(
            Expression.Block(new[] { sourceVariable, targetVariable }, expressions),
            new[] { sourceParameter, targetParameter });

    var del = lambda.Compile();

    del(source, target);
}

如果你有这个，那么编写通用方法就很简单：

public TTarget Transfer<TSource, TTarget>(TSource source)
    where TTarget : class, new()
{
    var target = new TTarget();
    Transfer(source, target);
    return target;
} 

让主工作方法变得通用并创建也是有意义的Action<TSource, TTarget>，甚至让它直接创建对象并使用Func<TSource, TTarget>。但如果按照我的建议添加缓存，则意味着您将不得不使用类似的东西Dictionary<Tuple<Type, Type>, Delegate>并在从缓存中检索委托后将其转换为正确的类型。