C#，如何通过为该对象创建表达式来将对象的字段复制到另一个对象

这是最简单的选择：

class MapperFactory
{
    public static Action<P, Q> CreateMapper<P, Q>()
    {
        var sourceType = typeof(P);
        var targetType = typeof(Q);

        var sourceProperties = GetVisibleProperties(sourceType);
        var targetProperties = GetVisibleProperties(targetType);

        var fromVar = Expression.Variable(sourceType, "from");
        var toVar = Expression.Variable(targetType, "to");

        Expression CreateCopyProperty(string name)
        {
            try
            {
                return Expression.Assign(
                    Expression.Property(toVar, targetProperties[name]),
                    Expression.Property(fromVar, sourceProperties[name]));
            }
            catch (Exception ex)
            {
                throw new ArgumentException($"Невозможно скопировать свойство {name}", ex);
            }
        }

        var commonProperties = sourceProperties.Keys.Intersect(targetProperties.Keys)
                                                    .OrderBy(n => n);
        var assignExpressions = commonProperties.Select(CreateCopyProperty);
        var assignment = Expression.Block(assignExpressions);
        var lambda = Expression.Lambda<Action<P, Q>>(assignment, fromVar, toVar);
        return lambda.Compile();
    }

    static Dictionary<string, PropertyInfo> GetVisibleProperties(Type type)
    {
        IEnumerable<Type> GetTypeChain(Type t) =>
            t == null ? Enumerable.Empty<Type>() : GetTypeChain(t.BaseType).Prepend(t);

        Dictionary<string, PropertyInfo> result = new Dictionary<string, PropertyInfo>();
        foreach (var t in GetTypeChain(type))
        {
            var properties = t.GetProperties(BindingFlags.Instance |
                                        BindingFlags.Public | BindingFlags.DeclaredOnly);
            foreach (var prop in properties)
            {
                if (!result.ContainsKey(prop.Name))
                    result.Add(prop.Name, prop);
            }
        }
        return result;
    }
}

它不检查可访问性，不查看私有/受保护，也不检查类型兼容性。如果无法复制同名属性，则在创建映射器时会抛出异常。如果目标属性不可写，则在创建映射器时会抛出异常。不匹配的属性会被静默忽略。如果派生类的属性在名称上覆盖了基类的属性，则忽略基类的属性（您还能做什么？）。静态属性被忽略（这似乎是正确的）。显式接口实现的属性将被忽略（因为我还没有弄清楚如何处理它们）。

像这样使用：

class From
{
    public int A { get; set; }
    public string B { get; set; }
}

class To
{
    public int A { get; set; }
    public string C { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        Action<From, To> map = MapperFactory.CreateMapper<From, To>();
        var from = new From() { A = 15, B = "hello world" };
        var to = new To();
        map(from, to);
        Console.WriteLine(to.A); // 15
    }
}

正常工作且不会崩溃的选项：

interface I
{
    int X { get; set; }
}

class FromBase
{
    public string A { get; set; }
    public int B { get; set; }
}

class From : FromBase, I
{
    public new int A { get; set; }
    static public string C { get; set; }
    int I.X { get; set; }
}

class To
{
    public int A { get; set; }
    public string C { get; set; }
}

解释。

我们先来看看函数GetVisibleProperties。我们需要获取所有属性的列表。这通常用一个简单的 来完成type.GetProperties()，但是如果我们有多个同名的属性呢？如果基类中的属性被覆盖，就会发生这种情况new，如上一个示例所示。如何只获得最新的财产？

要做到这一点，让我们做这个技巧：让我们遍历从我们的类型到的基本类型链object，并且在每一步它将只添加在该类型中定义的属性，并且只添加那些名称尚未与我们相遇的属性. 为此，我们需要获得一系列基本类型。最简单的方法是递归：将我们自己的类型添加到基类的链顶部。结果很简单：

IEnumerable<Type> GetTypeChain(Type t) =>
    t == null ? Enumerable.Empty<Type>() : GetTypeChain(t.BaseType).Prepend(t);

BindingFlags.Public好的，那么我们遵循这个链，对于每种类型，我们只获得公共属性BindingFlags.Instance（BindingFlags.DeclaredOnly对于它们中的每一个，我们检查是否已经存在同名的属性，并且仅当还没有同名的属性时才将新属性添加到结果中。

与GetVisibleProperties一切。现在，主要功能：CreateMapper.

我们将类型作为泛型参数传递，以便我们可以返回一个类型化的委托Action<P, Q>。首先，我们使用已经解析的GetVisibleProperties. 接下来，我们取名称集的交集：这些是两种类型中的属性的名称 ( commonProperties)。我还按字母顺序对它们进行排序，以便顺序相同。

我们通过System.Linq.Expressions，它允许您Expression在代码中构造表达式（如 ）。这是一种标准的代码生成技术，我们在网站上有很多使用这种技术的答案。

所以这里是辅助函数CreateCopyProperty。它创建了表达式的类似物to.Prop1 = from.Prop1;。我们预先定义了Expression-variablesfromVar并toVar对应于类型P和Q命名的“真实”变量from和to。Expression.Property(toVar, targetProperties[name])- 这是一个完整的模拟to.Prop1，其中属性是Prop1通过定义的PropertyInfo（这对于我们可能有重叠名称的情况是必要的）。Expression.Assign当然，创建分配的代码。例如，如果属性的类型不兼容，或者目标属性没有设置器，则创建表达式可能会引发异常。有可能不捕获此异常，但不清楚哪个属性是“应受责备”，所以我添加了一个 try / catch 块，并在新异常的文本中提到了有问题的属性的名称.

好的，接下来。我们有一组属性名称 ( commonProperties)，使用Select它来创建一组Expression's。这个集合需要打包成一个 using Expression.Block，它创建了一个花括号块的模拟：

{ to.Prop1 = from.Prop1; to.Prop2 = from.Prop2; ... }

现在我们从这个块中创建一个 lambda：

(from, to) => { to.Prop1 = from.Prop1; to.Prop2 = from.Prop2; ... }

在 的帮助下Expression.Lambda。

最后一个技巧是调用Compile，它Expression编译成一个真正的函数，我们返回给用户。