expression.bind 和 expression.assign 有什么区别（或者：MemberBinding 有什么特别之处）

Question

所以，这涉及到具体细节，但我希望这里的人可能有见解。

这是我设法收集的内容（当然，我可能对其中任何一个有误，所以请纠正我）

表达式.绑定

根据我的研究，包括 [topic][1] 上的 MSDN 条目，似乎 Expression.Bind 方法用于生成 MemberAssignment 类型的表达式，它是 MemberBinding 表达式的特定子类型。该方法采用 MemberInfo 和它应该绑定到的表达式。生成的 MemberAssignment 表达式表示成员的初始化。

表达式.赋值

是一种创建表示赋值操作的 BinaryExpression 的方法

这是我的问题：为什么我们不能在为 Expression.MemberInit 方法提供绑定时只使用 Expression.Assign？而不是：

    MemberAssignment binding = Expression.Bind(PropAccessMethodInfo, TargetExpression)

例如，我们可以这样做：

    MemberExpression getProperty = Expression.Property(FindObjectExpression, PropAccessMethodInfo)
    Expression binding = Expression.Assign(getProperty, TargetExpression)

我知道编译器会抱怨，但我想我想问这里是否存在语法问题。 换句话说，Expression.Bind / MemberBindings 是否在幕后为我们提供了一些额外的东西？ 或者，它们只是使管理成员初始化更容易的语法糖吗？

更具体地说，它是否可以帮助跟踪业务对象与 .NET EF4 中的底层实体之间的关系？它是否适合实体框架中的“使用代理”或有助于更改跟踪或业务对象和基于 EF 的数据访问层之间的桥梁？

正如您可能预见的那样，我正在尝试以编程方式将我的业务对象的创建从底层组件实体和此类表达式（尤其是 MemberInit 方法）连接到创建位。

但是，我不确定 EF / .NET 是否足够智能以使用这些绑定进行跟踪？或者，我是否可以重用这些相同的绑定到 BizEnt 跟踪/桥接器。

我希望这是有道理的。如果有不清楚的地方，我很乐意提供更多信息。

谢谢！！

Answer 1

对象初始化器是一个复杂的语法糖...它只是语法糖，因为在 IL 级别没有任何类似于对象初始化器的东西...没有特殊指令...只有 C# 编译器编写指令以一定的顺序，但不使用 OI 也可以编写相同的代码。可悲的是，很少有人描述这种糖的确切作用。

现在我会告诉你为什么它是复杂的语法糖！

你可以这样想：

foo = new Foo { Bar = 5 };

被翻译成

foo = new Foo();
foo.Bar = 5;

但实际上你知道它不是...假设foo 是一个属性...当然它不会被访问两次（一次写入用于保存new Foo()，一次读取用于访问@ 987654326@)...

所以代码可以/应该等于：

Foo tmp = new Foo();
foo = tmp;
tmp.Bar = 5;

但事实上并非如此！它可能更类似于

Foo tmp = new Foo();
tmp.Bar = 5;
foo = tmp;

不同的是，如果Foo.Bar的setter抛出异常，foo就不会被设置！

你可以试试：http://ideone.com/PjD7zF

源代码：

using System;

class Program
{
    class Foo
    {
        public Foo()
        {
            Console.WriteLine("Building Foo");
        }

        public int Bar
        {
            get
            {
                Console.WriteLine("Getting Foo.Bar");
                return 0;
            }

            set
            {
                Console.WriteLine("Setting Foo.Bar: boom!");
                throw new Exception();
            }
        }
    }

    static Foo foo2;

    static Foo foo
    {
        get
        {
            Console.WriteLine("Getting foo");
            return foo2;
        }

        set
        {
            Console.WriteLine("Setting foo");
            foo2 = value;
        }
    }

    static void Main(string[] args)
    {
        try
        {
            foo = new Foo { Bar = 100 };

            // Not executed, only to disassemble and check 
            // that it isn't using special instructions!
            foo = new Foo();
            foo.Bar = 200;
        }
        catch (Exception ex)
        {
            Console.WriteLine("Exception: {0}", ex);
        }

        Console.WriteLine("Finished try/catch");

        Console.WriteLine("foo initialized: {0}", foo != null);
    }
}

这种不那么微妙的差异，加上语法糖的复杂性，肯定足以创建一个专门为此而构建的“特殊”Expression（Expression.MemberInit）。

Expression.Bind 然后是必要的，因为他们想准确地模拟对象初始化器的工作，并且在对象初始化器中您无权访问新对象的“this”。你不能写：

// wrong
foo = new Foo { this.Bar = 5 };

他们不希望你能写出这样的表达式

foo = new Foo { somethingElse.Prop = 10 } 

如果Expression.MemberInit 简单地接受Expression.Assign 的数组，这将是可能的。

第二点...Expression.MemberInit 在 .NET 3.5 中（这是必要的，因为成员初始化在 LINQ 中非常常用），Expression.Assign 仅在 .NET 4.0 中。表达式树是为 LINQ 诞生和构建的（至少 LINQ 减去 LINQ to Objects，因为 LINQ to Objects 不使用表达式树）。 Expression.Assign 不是必需的，因此没有实施。 Expression.MemberInit是必须的，所以实现了。

第三点...成员初始化在 LINQ 中很常见，因此必须从成员初始化的“基础”部分（临时变量、一些赋值...）构建所有表达式肯定更困难（并且这些表达式在调试时肯定更复杂）比具有“一体化”的预构建方法。

第四点... LINQ 提供程序通常不会实现所有可能的Expression(s)，并且经常不得不处理表达式将在完全不同的环境中远程执行的事实（请参阅在 SQL Server 上执行 LINQ 查询的示例 LINQ-to-SQL）。 Expression.MemberInit 比 Expression.Assign 更受限制，因此更容易由 LINQ 提供程序实现。

所以选择其中一些原因...它们都非常好，并且可能其中任何一个单独足以决定实施Expression.MemberInit。他们四个在一起？