匿名方法、范围和序列化

Question

假设我有以下代码：

public class Foo
{
    private int x;
    private int y;

    public Bar CreateBar()
    {
        return new Bar(x, () => y);
    }
}

[Serializable]
public class Bar
{
    private int a;
    private Func<int> b;

    public Bar(int a, Func<int> b)
    {
        this.a = a;
        this.b = b;
    }
}

在这种情况下，对象和值的范围会发生什么情况？ 由于 x 是值类型，因此它按值传递给 Bar，因此其范围不需要发生任何变化。 但 y 会怎样呢？ y 的值需要保留下来，以便在实际计算 b 时返回。 是否所有 Foo 都保留下来以便稍后评估 y ？ 我只能假设 Foo 没有被 GC 处理。

现在假设我们将 Bar 序列化到磁盘，然后再将其反序列化。 实际上已经连载了哪些内容？ 它也序列化了 Foo 吗？ 到底发生了什么魔力，使得在 Bar 反序列化后可以对 b 进行求值？ 你能解释一下 IL 中发生了什么吗？

Answer 1

当它反映要序列化的对象时尝试序列化时出现错误。

我的示例：

[Serializable]
    public class SerializeTest
    {
        //public SerializeTest(int a, Func<int> b)
        //{
        //    this.a = a;
        //    this.b = b;
        //}

        public SerializeTest()
        {

        }

        public int A 
        {
            get
            {
                return a;
            }

            set
            {
                a = value;
            }
        }
        public Func<int> B 
        {
            get
            {
                return b;
            }
            set
            {
                b = value;
            }
        }


        #region properties

        private int a;
        private Func<int> b;



        #endregion

        //serialize itself
        public string Serialize()
        {
            MemoryStream memoryStream = new MemoryStream();

            XmlSerializer xs = new XmlSerializer(typeof(SerializeTest));
            using (StreamWriter xmlTextWriter = new StreamWriter(memoryStream))
            {
                xs.Serialize(xmlTextWriter, this);
                xmlTextWriter.Flush();
                //xmlTextWriter.Close();
                memoryStream = (MemoryStream)xmlTextWriter.BaseStream;
                memoryStream.Seek(0, SeekOrigin.Begin);
                StreamReader reader = new StreamReader(memoryStream);

                return reader.ReadToEnd();
            }
        }

        //deserialize into itself
        public void Deserialize(string xmlString)
        {
            String XmlizedString = null;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                using (StreamWriter w = new StreamWriter(memoryStream))
                {
                    w.Write(xmlString);
                    w.Flush();

                    XmlSerializer xs = new XmlSerializer(typeof(SerializeTest));
                    memoryStream.Seek(0, SeekOrigin.Begin);
                    XmlReader reader = XmlReader.Create(memoryStream);

                    SerializeTest currentConfig = (SerializeTest)xs.Deserialize(reader);

                    this.a = currentConfig.a;
                    this.b = currentConfig.b;

                    w.Close();
                }
            }
        }

    }

class Program
    {
        static void Main(string[] args)
        {

            SerializeTest test = new SerializeTest() { A = 5, B = ()=>67};
            string serializedString =  test.Serialize();


}
}

这是执行此操作的链接...稍微复杂一点： 序列化匿名委托

Answer 2

我认为 Foo 对象中的 x 和 y 将被捕获为值类型。 因此，为该 lambda 表达式创建的闭包不应保留对 Foo 对象的引用。 因此，编译器可能会为该闭包创建一个类：

internal class CompilerGeneratedClassName
{
   private int x;
   private int y;
   public CompilerGeneratedClassName(int x, int y)
   {
     this.x = x;
     this.y = y;
   }

   public int CompilerGeneratedMethodName()
   {
     return this.y;
   }     
}

并

return new Bar(x, () => y); 

可能被替换为

return new Bar(x,new CompilerGeneratedClassName(x,y).CompilerGeneratedMethodName);

因此，我认为该闭包不会导致对 Foo 对象的引用。 所以 Foo 对象可以被 GC 处理。 我可能是错的。 您可以做的一件事是编写一个小程序，对其进行编译，然后在 ILDASM 工具中检查生成的 IL。

Answer 3

创建一个快速测试项目来输出值，然后查看它们。 它应该回答问题，并且可能会让您在这个过程中学到一些额外的东西。 （这是大多数回答你问题的人所做的。）

Answer 4

更新：查看实际发生的情况，而不必求助于 IL： 使用反射器来理解匿名方法和捕获的变量

---

当你使用时：

public Bar CreateBar()
{
    return new Bar(x, () => y);
}

你隐含着this.y; 因此，就委托而言，它包含对 Foo 的引用。 因此，Bar 的实例（通过委托）使整个 Foo 保持活动状态（不会被垃圾回收），直到 Bar 可用于收藏。

特别是，（在这种情况下）编译器不需要生成额外的类来处理捕获的变量； 唯一需要的是 Foo 实例，因此可以在 Foo 上生成一个方法。 如果委托涉及局部变量（this 除外），情况会更加复杂。

就序列化而言......好吧，我要说的第一件事是序列化委托是一个非常非常糟糕的主意。 但是，BinaryFormatter 将遍历委托，并且您（理论上）最终可以得到一个序列化的 Bar、一个序列化的 Foo 和一个序列化委托来链接它们 - 但仅如果您将 Foo 标记为 [Serialized]。

但我强调 - 这是一个坏主意。 我很少使用 BinaryFormatter（出于多种原因），但我看到使用它的人的一个常见问题是“为什么它尝试序列化（某种随机类型）”。 通常，答案是“您正在发布一个事件，并且它正在尝试序列化订阅者”，在这种情况下，最常见的修复方法是将事件的字段标记为 [NonSerialized]。

---

而不是看IL； 研究此问题的另一种方法是在 .NET 1.0 模式下使用反射器（即不交换匿名方法）； 然后你可以看到：

public Bar CreateBar()
{
    return new Bar(this.x, new Func<int>(this.<CreateBar>b__0));
}
[CompilerGenerated]
private int <CreateBar>b__0()
{
    return this.y;
}

如你所见； 传递给 Bar 的是当前实例 (this) 上隐藏方法（称为 b__0()）的委托。 因此它是传递给Bar的当前Foo的实例。