使用 C# 表达式树，我可以创建匿名类型对象映射吗？答案

【问题标题】：Using C# Expression Trees, can I create an anonymous to typed object map?使用 C# 表达式树，我可以创建匿名类型对象映射吗？
【发布时间】：2015-08-29 17:41:53
【问题描述】：

这是在数据层上，因此性能非常重要。否则我会使用 Automapper。如果是 IDBConnection，我会使用 Dapper。

我想将匿名对象的简单创作带到 POCO，并使用编译表达式来表达它。

代码

public class Foo
{
    public string Bar{get;set;}
    public string Baz{get;set;}
}

public void doStuff()
{
     var obj = new{Bar= "My Name, Baz = "Some other data"};

     //can I recreate this assignment to foo using expressions?
     var foo = new Foo{
         Bar = obj.Bar,
         Baz = obj.Baz
     }
}

（不完整）到目前为止我...

var props = o.GetType().GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)

    foreach (var prop in props)
                {
                    var targetProp = typeof(T).GetProperty(prop.Name);
                    var targetExp = Expression.Parameter(typeof(T), "target");
                    var valueExp = Expression.Parameter(prop.PropertyType, "property");



                    var propExp = Expression.Property(targetExp, targetProp);
                    var assignExp = Expression.Assign(propExp, valueExp);

                    var setter = Expression.Lambda<Action<T, object>>(assignExp, targetExp, valueExp).Compile();
                }

当前问题

如何将 setter 组合成返回编译的委托？
如何在循环属性时创建 Lambda[Action] 泛型类型？

感谢您的任何意见。

【问题讨论】：

不清楚这里的上下文是什么——这已经是一个接受匿名类型作为类型参数、typeof(Foo) 作为参数的泛型方法了吗？
顺便说一句，找出 like 的作用的最简单方法是编写一个 lambda 表达式编译成表达式树，然后反编译它。
第一部分：该方法类似于“T MapFrom(object obj)”，其中保证对象始终是同一个匿名对象。第二部分：好主意。我现在就试试。
为什么不创建一次映射委托，然后重用它？
一定要试试 FastMapper/Mapster。它们生成动态 IL 来映射对象，因此性能比 Automapper 好一个数量级。

标签： c# lambda linq-expressions

【解决方案1】：

给你：

using System;
using System.Linq;
using System.Linq.Expressions;

namespace Tests
{
    public static class Utils
    {
        public static Func<TInput, TOutput> CreateMapFunc<TInput, TOutput>()
        {
            var source = Expression.Parameter(typeof(TInput), "source");
            var body = Expression.MemberInit(Expression.New(typeof(TOutput)),
                source.Type.GetProperties().Select(p => Expression.Bind(typeof(TOutput).GetProperty(p.Name), Expression.Property(source, p))));
            var expr = Expression.Lambda<Func<TInput, TOutput>>(body, source);
            return expr.Compile();
        }
    }
    public static class MapFunc<TInput, TOutput>
    {
        public static readonly Func<TInput, TOutput> Instance = Utils.CreateMapFunc<TInput, TOutput>();
    }
    public struct Unit<T>
    {
        public readonly T Value;
        public Unit(T value) { Value = value; }
        public U MapTo<U>() { return MapFunc<T, U>.Instance(Value); }
    }
    public static class Extensions
    {
        public static Unit<T> Unit<T>(this T source) { return new Unit<T>(source); }
    }
    // Test
    public class Foo
    {
        public string Bar { get; set; }
        public string Baz { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var obj = new { Bar = "My Name", Baz = "Some other data" };
            //var foo = new Foo { Bar = obj.Bar, Baz = obj.Baz };
            var foo = obj.Unit().MapTo<Foo>();
        }
    }
}

如果有人对它的工作原理感兴趣：

主要部分是CreateMapFunc 函数，它使用MemberInitExpression 构建和编译一个lambda 表达式。它确实应该是 MapFunc<TInput, TOutput> 类中的私有函数——我将它放在一个单独的类中只是为了显示原始问题的答案。

MapFunc<TInput, TOutput> 类是一个单例，充当已编译函数委托的缓存。

Unit<T> 充当中介，需要（连同扩展方法）来允许推断传递的匿名对象的类型并仅指定目标类型。

【讨论】：

不错！这是我希望的用法。