c# - 通过将状态存储到作用域局部变量中来避免关闭快速路径

Question

我正在分析 OptionsManager.Get(string name) :

/// <summary>
/// Returns a configured <typeparamref name="TOptions"/> instance with the given <paramref name="name"/>.
/// </summary>
public virtual TOptions Get(string name)
{
    name = name ?? Options.DefaultName;

    if (!_cache.TryGetValue(name, out TOptions options))
    {
        // Store the options in our instance cache. Avoid closure on fast path by storing state into scoped locals.
        IOptionsFactory<TOptions> localFactory = _factory;
        string localName = name;
        options = _cache.GetOrAdd(name, () => localFactory.Create(localName));
    }

    return options;
}

以下实际上是什么意思？

Avoid closure on fast path by storing state into scoped locals

什么是“快速 channel ”？
创建指向 _factory 的局部变量有什么好处？ ，与仅使用 _factory 相比?

Answer 1

@madreflections 概要基本上是正确的。
更长的故事
lambda 只是一个匿名方法(它又只是一个没有名称的方法)，C# 引入了 lamdas 作为创建匿名方法的简洁方式。但是，如果匿名方法需要访问自由变量(不属于匿名方法参数或本地范围的变量)，它需要一种方法来捕获它们。这是通过闭包完成的。
闭包基本上只是编译器生成的一个类，用于获取自由变量的副本以在匿名方法中访问。
备注 :即使使用自由变量，编译器也可能并不总是生成闭包，有时它可以在引用实例字段或属性的情况下生成实例方法。但是，如果它确实需要捕获一个变量，则会生成一个闭包。
当一个 关闭生成编译器不仅为闭包类创建代码，它还需要实例化该类并分配任何变量。根据这些变量的范围，将决定在代码中的哪个位置初始化类并检测依赖项。
由于闭包只是普通的旧类，因此它们需要被实例化，而这又是一个分配，因此会带来很小的开销。在提供源代码的情况下，开发人员权衡了开销的成本，并决定提高效率。
这种效率是在知道 的情况下实现的。闭包将在它“需要”捕获自由变量 的最外层范围内实例化.编译器使用基于范围的回退方法，并且有点复杂。但是，通过以直接内部范围中显示的方式分配局部变量，编译器知道在该范围内创建闭包是安全的。这反过来意味着创建的小开销仅限于 if 的代码块范围的那个分支。陈述。
一些无意义的例子

// instance field
readonly Version _something = new Version();

public virtual void Test1(int someValue)
{ 
   // some weird branch
   if (DateTime.Now == DateTime.MaxValue)
   {
      Method(() => _something.Build + someValue);
   }
}

public virtual void Test2(int someValue)
{
   // some weird branch
   if (DateTime.Now == DateTime.MaxValue)
   {
      // some locals to let the compiler create the closure in the immediate scope
      var localSomething = _something;
      var localValue = someValue;
      Method(() => localSomething.Build + localValue);
   }
}

public virtual void Test3(int someValue)
{
   // some weird branch
   if (DateTime.Now == DateTime.MaxValue)
   {
      // closure needed, it can just create an anonymous method in the class
      // and reference _something directly
      Method(() => _something.Build);
   }
}

// something with a delegate parameter.
private int Method(Func<int> func) => func();

编译后
备注 : 这是编译器所做的粗略的互操作。对于所有血腥细节 look at this Example

public class CallingClass
{
   [CompilerGenerated]
   private sealed class Closure1
   {
      public CallingClass copyOfCallingClass;

      public int someValue;

      internal int Method()
      {
         return copyOfCallingClass._something.Build + someValue;
      }
   }

   [CompilerGenerated]
   private sealed class Closure2
   {
      public Version localSomething;

      public int localValue;

      internal int Method()
      {
         return localSomething.Build + localValue;
      }
   }

   [CompilerGenerated]
   private int NewMethod()
   {
      return _something.Build;
   }

   private readonly Version _something = new Version();

   public virtual void Test1(int someValue)
   {
      // generated closure plumbing
      Closure1 Closure1 = new Closure1();
      Closure1.copyOfCallingClass = this;
      Closure1.someValue = someValue;
      if (DateTime.Now == DateTime.MaxValue)
      {
         Method(new Func<int>(Closure1.Method));
      }
   }

   public virtual void Test2(int someValue)
   {
      if (DateTime.Now == DateTime.MaxValue)
      {
         // generated closure plumbing
         Closure2 closure2 = new Closure2();
         closure2.localSomething = _something;
         closure2.localValue = someValue;
         Method(new Func<int>(closure2.Method));
      }
   }

   public virtual void Test3(int someValue)
   {
      if (DateTime.Now == DateTime.MaxValue)
      {
         // pointer to the new generated method
         Method(new Func<int>(NewMethod));
      }
   }

   private int Method(Func<int> func)
   {
      return func();
   }
}

免责声明 :虽然闭包是一个相当平庸的话题，但编译器如何选择实现这一点及其规则本身是微妙的，因此需要深入研究规范。这只是作为一个高级摘要。