transfering一个对象的属性值，另一个

Question

一切之前，我知道AutoMapper，我不希望使用它。因为我在学习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和ILGenerator和后期绑定代表更迅速，具有更高的性能。但没有更多的解释或任何联系。你能帮我理解加速这段代码的方法吗？或者你可以建议我约Emit，ILGenerator一些链接，并后期绑定代表好吗？或者你认为的任何事情都会帮助我学习？提前致谢。

COMPELETE问：

我了解和@ 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() { } 

Answer 1

你可能会考虑只获得属性（按名称）的目标相匹配的。这将显着简化您的代码。

foreach (var property in sourceType.GetProperties(BindingFlags.Public | BindingFlags.Instance)) 
{ 
    var targetProperty = targetType.GetProperty(property.Name, BindingFlags.Public | BindingFlags.Instance); 
    if (targetProperty != null 
      && targetProperty.CanWrite 
      && targetProperty.PropertyType.IsAssignableFrom(property.PropertyType)) 
    { 
     targetProperty.SetValue(target, property.GetValue(source, null), null); 
    } 
} 

Answer 2

C# Reflection IL - Understanding how values are copied

问题是关于克隆所以源对象的类型是相同的目标对象的（而据我所知，你可以在源和目标的不同类型的类型）但仍然值得分析。

Answer 3

你可能使用Reflection.Emit来做到这一点，但它通常更容易使用Expression s，它给你基本上相同的性能。请记住，性能优势是存在的前提是你缓存编译后的代码，例如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); 
} 

如果你有这样的，写你的泛型方法是simpple：

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>并从缓存中检索之后投的委托权类型。

Answer 4

我写了一篇博客文章如何做到这一点（葡萄牙唯一，但你可以阅读代码）

http://elemarjr.net/2012/02/27/um-helper-para-shallow-cloning-emitting-em-c/

你可以从代码：

https://github.com/ElemarJR/FluentIL/blob/master/demos/Cloning/src/Cloning/Cloning/ILCloner.cs

我认为使用Reflection.Emit比需要更难。因此，我编写了一个名为FluentIL（www.fluentil.org）的开源库，使其更容易。我在这里使用它。

[] s