Question

This question及其答案很好地解释了隐式捕获闭包的概念。但是，我偶尔会看到代码似乎应该生成有问题的警告，实际上并没有。例如：

public static void F()
{
  var rnd1 = new Random();
  var rnd2 = new Random();
  Action a1 = () => G(rnd1);
  Action a2 = () => G(rnd2);
}

private static void G(Random r)
{
}

我的期望是，我被警告a1隐式捕获rnd2，a2隐式捕获rnd1。但是，我根本没有得到任何警告（链接问题中的代码确实为我生成了它）。这是ReSharper的一部分（v9.2）的错误，还是由于某种原因不会在这里发生隐式捕获？

Answer 1

我认为Resharper由于某种原因无法在这种情况下发现隐式捕获的变量。您可以使用一些反汇编程序验证自己，编译器使用rnd1和rnd2生成单个类。在你的例子中，它不是很清楚，但让我们从Eric Lippert博客文章（https://blogs.msdn.microsoft.com/ericlippert/2007/06/06/fyi-c-and-vb-closures-are-per-scope/）中拿这个例子来描述一个危险的隐式捕获的例子：

Func<Cheap> M() {            
    var c = new Cheap();
    var e = new Expensive();
    Func<Expensive> shortlived = () => e;
    Func<Cheap> longlived = () => c;            
    shortlived();
    // use shortlived
    // use longlived
    return longlived;
}

class Cheap {

}

class Expensive {

}

很明显，longlived委托捕获了Expensive变量，并且在它死亡之前不会被收集。但是（至少对我来说），Resharper不会警告你这件事。但不能把它命名为“bug”，但肯定有一个改进的地方。

Answer 2

当编译器捕获闭包中匿名方法使用的局部变量时，它通过生成特定于包含委托定义的方法范围的辅助类来实现。即使在该范围内有多个委托，每个范围也存在一个这样的方法。请参阅Eric Lippert的解释{{3}}。

借用您的示例，请考虑以下程序：

using System;

namespace ConsoleApplication
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            F();
        }

        public static void F()
        {
            var rnd1 = new Random();
            var rnd2 = new Random();
            Action a1 = () => G(rnd1);
            Action a2 = () => G(rnd2);
        }

        private static void G(Random r)
        {
        }
    }
}

查看编译器生成的IL，我们看到以下F()的实现：

.method public hidebysig static 
    void F () cil managed 
{
    // Method begins at RVA 0x205c
    // Code size 56 (0x38)
    .maxstack 2
    .locals init (
        [0] class ConsoleApplication.Program/'<>c__DisplayClass1_0' 'CS$<>8__locals0',
        [1] class [mscorlib]System.Action a1,
        [2] class [mscorlib]System.Action a2
    )

    IL_0000: newobj instance void ConsoleApplication.Program/'<>c__DisplayClass1_0'::.ctor()
    IL_0005: stloc.0
    IL_0006: nop
    IL_0007: ldloc.0
    IL_0008: newobj instance void [mscorlib]System.Random::.ctor()
    IL_000d: stfld class [mscorlib]System.Random ConsoleApplication.Program/'<>c__DisplayClass1_0'::rnd1
    IL_0012: ldloc.0
    IL_0013: newobj instance void [mscorlib]System.Random::.ctor()
    IL_0018: stfld class [mscorlib]System.Random ConsoleApplication.Program/'<>c__DisplayClass1_0'::rnd2
    IL_001d: ldloc.0
    IL_001e: ldftn instance void ConsoleApplication.Program/'<>c__DisplayClass1_0'::'<F>b__0'()
    IL_0024: newobj instance void [mscorlib]System.Action::.ctor(object, native int)
    IL_0029: stloc.1
    IL_002a: ldloc.0
    IL_002b: ldftn instance void ConsoleApplication.Program/'<>c__DisplayClass1_0'::'<F>b__1'()
    IL_0031: newobj instance void [mscorlib]System.Action::.ctor(object, native int)
    IL_0036: stloc.2
    IL_0037: ret
} // end of method Program::F

注意第一条IL指令： IL_0000: newobj instance void ConsoleApplication.Program/'<>c__DisplayClass1_0'::.ctor() ，它调用编译器生成的辅助类的默认构造函数 - 负责捕获闭包中的局部变量的类。

以下是编译器生成的帮助程序类的IL：

.class nested private auto ansi sealed beforefieldinit '<>c__DisplayClass1_0'
    extends [mscorlib]System.Object
{
    .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = (
        01 00 00 00
    )
    // Fields
    .field public class [mscorlib]System.Random rnd1
    .field public class [mscorlib]System.Random rnd2

    // Methods
    .method public hidebysig specialname rtspecialname 
        instance void .ctor () cil managed 
    {
        // Method begins at RVA 0x20a3
        // Code size 8 (0x8)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [mscorlib]System.Object::.ctor()
        IL_0006: nop
        IL_0007: ret
    } // end of method '<>c__DisplayClass1_0'::.ctor

    .method assembly hidebysig 
        instance void '<F>b__0' () cil managed 
    {
        // Method begins at RVA 0x20ac
        // Code size 13 (0xd)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: ldfld class [mscorlib]System.Random ConsoleApplication.Program/'<>c__DisplayClass1_0'::rnd1
        IL_0006: call void ConsoleApplication.Program::G(class [mscorlib]System.Random)
        IL_000b: nop
        IL_000c: ret
    } // end of method '<>c__DisplayClass1_0'::'<F>b__0'

    .method assembly hidebysig 
        instance void '<F>b__1' () cil managed 
    {
        // Method begins at RVA 0x20ba
        // Code size 13 (0xd)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: ldfld class [mscorlib]System.Random ConsoleApplication.Program/'<>c__DisplayClass1_0'::rnd2
        IL_0006: call void ConsoleApplication.Program::G(class [mscorlib]System.Random)
        IL_000b: nop
        IL_000c: ret
    } // end of method '<>c__DisplayClass1_0'::'<F>b__1'

} // end of class <>c__DisplayClass1_0

请注意，此帮助程序类包含 rnd1和rnd2的字段。

IL级别的F()的“最终”实现类似于以下内容：

public static void F()
{
    var closureHelper = new ClosureHelper();
    closureHelper.rnd1 = new Random();
    closureHelper.rnd2 = new Random();
    Action a1 = closureHelper.MethodOne;
    Action a2 = closureHelper.MethodTwo;
}

实施ClosureHelper的地方类似于：

internal class Program
{
    public class ClosureHelper
    {
         public Random rnd1;
         public Random rnd2;

         void MethodOne()
         {
              Program.G(rnd1);
         }

         void MethodTwo()
         {
              Program.G(rnd2);
         }
    }
}

至于ReSharper为什么不警告你在这种情况下发生隐式捕获，我不知道。

为什么没有 ReSharper告诉我“隐式捕获关闭”？

2 个答案:

为什么*没有* ReSharper告诉我“隐式捕获关闭”？

2 个答案:

为什么没有 ReSharper告诉我“隐式捕获关闭”？