这是由C＃编译器完成的优化吗？

我通过lambda表达式创建了一批匿名函数。我想使用TaskId来区分匿名函数。下面是代码：这是由C＃编译器完成的优化吗？

int count = 3; 
int i; 
for (int j = 0; j < 10; j++) 
{ 
    i = 0; 
    Func<bool, Task<int>> func = async (b) => 
    { 
     return j; 
    }; 
    while (i++ < count) 
    { 
     var task = func(true); 
     Console.WriteLine(String.Format("Task Result:{0} TaskId:{1}", 
      task.Result, task.Id)); 
    } 
}

这里是输出

Task Result:0 TaskId:1 
Task Result:0 TaskId:1 
Task Result:0 TaskId:1 
Task Result:1 TaskId:2 
Task Result:1 TaskId:2 
Task Result:1 TaskId:2 
Task Result:2 TaskId:3 
Task Result:2 TaskId:3 
Task Result:2 TaskId:3 
Task Result:3 TaskId:4 
Task Result:3 TaskId:4 
Task Result:3 TaskId:4 
Task Result:4 TaskId:5 
Task Result:4 TaskId:5 
Task Result:4 TaskId:5 
Task Result:5 TaskId:6 
Task Result:5 TaskId:6 
Task Result:5 TaskId:6 
Task Result:6 TaskId:7 
Task Result:6 TaskId:7 
Task Result:6 TaskId:7 
Task Result:7 TaskId:8 
Task Result:7 TaskId:8 
Task Result:7 TaskId:8 
Task Result:8 TaskId:9 
Task Result:8 TaskId:9 
Task Result:8 TaskId:9 
Task Result:9 TaskId:10 
Task Result:9 TaskId:11 
Task Result:9 TaskId:12

正如你所看到的，改变的taskid因为结果是大于8我不知道到知道这样做的原因现象。感谢您的帮助:)

来源

2014-10-20 Simon Wu

有趣的是，从我可以告诉它重用任务实例（object.ReferenceEquals在比较'task'到上一个值时为true）一段时间，但它不清楚为什么。 – 2014-10-20 04:30:23

@mikez是的。但我不知道为什么返回值会影响重用。 – 2014-10-20 05:09:32

任务正在缓存某处。在连续两次的方法中运行该代码。对于<= 8，相同的任务id会重复，但在此之上它们是新的。 – 2014-10-20 05:17:56

这不是编译器本身，而是执行缓存的.NET框架。查看AsyncMethodBuilder的代码，编译器使用该代码管理生成的异步方法的状态机。它看起来像SetResult在GetTaskForResult中做了一些缓存。还有用于缓存的基本价值类型，包括这一些非常具体的代码：

// For Int32, we cache a range of common values, e.g. [-1,4). 
else if (typeof(TResult) == typeof(Int32)) 
{ 
    // Compare to constants to avoid static field access if outside of cached range. 
    // We compare to the upper bound first, as we're more likely to cache miss on the upper side than on the 
    // lower side, due to positive values being more common than negative as return values. 
    Int32 value = (Int32)(object)result; 
    if (value < AsyncTaskCache.EXCLUSIVE_INT32_MAX && 
     value >= AsyncTaskCache.INCLUSIVE_INT32_MIN) 
    { 
     Task<Int32> task = AsyncTaskCache.Int32Tasks[value - AsyncTaskCache.INCLUSIVE_INT32_MIN]; 
     return JitHelpers.UnsafeCast<Task<TResult>>(task); // UnsafeCast avoids a type check we know will succeed 
    } 
}

而且我们看到的是：

/// <summary>The minimum value, inclusive, for which we want a cached task.</summary> 
internal const Int32 INCLUSIVE_INT32_MIN = -1; 
/// <summary>The maximum value, exclusive, for which we want a cached task.</summary> 
internal const Int32 EXCLUSIVE_INT32_MAX = 9;

这就是为什么8是神奇的截止。值得注意的是-1也应该得到缓存，并从我的测试中得到。

来源

2014-10-20 05:25:27

很好的答案。非常感谢！ – 2014-10-20 05:31:33

ambda表达式存储变量而不是值。你的表情是异步的，所以我认为线程搞乱了结果。尝试没有异步魔法，它会显示正确的结果。

来源

2014-10-20 04:02:01

该代码是一个示例。我真的很想知道为什么会发生混乱。 – 2014-10-20 04:57:01

这是由C＃编译器完成的优化吗？

回答

相关问题