我在.NET的List源码中偶然发现了这段代码：
// Following trick can reduce the range check by one
if ((uint) index >= (uint)_size) {
ThrowHelper.ThrowArgumentOutOfRangeException();
}
显然，这比if (index < 0 || index >= _size)更有效率 (?)。
对于这个技巧背后的原理，我很好奇。单一分支指令真的比两个转换为uint更昂贵吗？还是有其他优化措施可以使此代码比额外的数值比较更快？
针对问题的本质：是的，这是微小的优化，不，我没有打算在我的代码中随处使用它 - 我只是好奇；)
从MS Partition I第12.1节（支持的数据类型）:
有符号整数类型(int8、int16、int32、int64和本机int)及其对应的无符号整数类型(unsigned int8、unsigned int16、unsigned int32、unsigned int64和本机unsigned int) 仅在解释整数的位时存在差异。对于那些将无符号整数与有符号整数区别对待的操作(例如，比较或算术溢出)，有单独的指令来将整数视为无符号的(例如，cgt.un和add.ovf.un)。
也就是说，从int到uint的转换只是一种简单的记录方式——从现在开始，在堆栈 / 寄存器中的值现在被认为是无符号整数而不是有符号整数。
因此，一旦代码被JIT编译，这两个转换应该是“免费”的，然后可以执行无符号比较操作。
blt或blt.s和blt.un或blt.un.s之间，C#生成的CIL根本不需要涉及任何实际的转换。 - Jon Hanna_size > int.MaxValue，则优化也会中断。如果 _size 是非负常量，或者编译器可以从先前的代码推断出 _size 的值始终介于0和 int.MaxValue 之间（包括边界），则编译器可以执行优化。是的，现代编译器通常执行这种数据流分析，尽管显然它们可以做多少有限（因为完整问题是图灵完备的）。 - Ilmari Karonen假设我们有:
public void TestIndex1(int index)
{
if(index < 0 || index >= _size)
ThrowHelper.ThrowArgumentOutOfRangeException();
}
public void TestIndex2(int index)
{
if((uint)index >= (uint)_size)
ThrowHelper.ThrowArgumentOutOfRangeException();
}
让我们编译这些代码并查看ILSpy：
.method public hidebysig
instance void TestIndex1 (
int32 index
) cil managed
{
IL_0000: ldarg.1
IL_0001: ldc.i4.0
IL_0002: blt.s IL_000d
IL_0004: ldarg.1
IL_0005: ldarg.0
IL_0006: ldfld int32 TempTest.TestClass::_size
IL_000b: bge.s IL_0012
IL_000d: call void TempTest.ThrowHelper::ThrowArgumentOutOfRangeException()
IL_0012: ret
}
.method public hidebysig
instance void TestIndex2 (
int32 index
) cil managed
{
IL_0000: ldarg.1
IL_0001: ldarg.0
IL_0002: ldfld int32 TempTest.TestClass::_size
IL_0007: blt.un.s IL_000e
IL_0009: call void TempTest.ThrowHelper::ThrowArgumentOutOfRangeException()
IL_000e: ret
}
很容易看出第二个版本的代码更少，少了一个分支。
实际上，根本没有类型转换，只需要选择使用blt.s和bge.s，或者使用blt.s.un，后者将传递的整数作为无符号处理，而前者将其视为有符号处理。
（对于不熟悉CIL的人来说，由于这是一个关于C#并且使用了CIL答案的问题，bge.s、blt.s和blt.s.un分别是bge、blt和blt.un的“短”版本。其中blt从堆栈中弹出两个值，并在将它们视为有符号值时第一个小于第二个时跳转，而blt.un从堆栈中弹出两个值，并在将它们视为无符号值时第一个小于第二个时跳转）。
这完全是微观优化，但有时微观优化是值得做的。考虑到方法体中的其余代码，这可能意味着某些东西落入即时编译器内联的限制范围内或者没有，而如果他们费心为超出范围的异常编写一个辅助程序，他们可能会尽可能确保内联发生，而额外的4个字节可能会产生重大影响。
事实上，这种内联差异很可能比减少一个分支更重要。并不是经常有必要费力确保内联发生，但像List<T>这样频繁使用的类的核心方法肯定是其中之一。
_size 已经保证大于 0，所以 (index < 0 || index < _size) == ((uint)index >= (uint)_size)。当然，一个能够使用代码契约作为其优化决策的编译器肯定可以做到这一点，但是即使是优化超过（移动目标的）内联限制也是一个特殊情况。 - Jon Hanna0 < index < _size（甚至对于C＃来说也是相当合理的，因为它不会在布尔和整数类型之间隐式转换），那么这里的优化仍然是不要使用它。 - Jon Hanna_size是一个整数，私有于列表中，并且index是需要进行有效性测试的此函数的参数。_size始终>=0。if(index < 0 || index > size) throw exception
if((uint)index > (uint)_size) throw exception
与前面的例子相比，此处只有一个比较操作。因为强制类型转换只是重新解释位并使得>实际上是一次无符号比较，所以不需要额外的CPU周期。
为什么它能够工作？
只要索引值大于等于0，结果就是简单/平凡的。
如果索引值小于0，那么(uint)index 将把其转换成一个非常大的数：
例如：0xFFFF在int中表示-1，在uint中表示65535，因此
(uint)-1 > (uint)x
x为正数，那么始终为真。
OverflowException，在未检查的上下文中使用T-MaxValue。因此，这将返回uint.Maxvalue：unchecked { uint ui = (uint)-1; };。但不能保证。如果您尝试使用checked，则会在-1常量处获得编译器错误，如果使用变量，则会在运行时出现OverflowException。顺便说一句，我指的是“如果索引<0，则（uint）index将使其变成一个非常大的数字：....” - Tim Schmelter(uint)-1 等于 uint.MaxValue，但未经检查的 (uint)-2 并不等于它 -- 相反，它等于 uint.MaxValue-1。两者都是"非常大"的 -- 实际上，严格大于 int.MaxValue -- 尽管如此。 - Ilmari Karonen checked 而不是 unchecked ，则此技巧将无效。最好情况下，它会变慢（因为每个强制转换都需要检查是否溢出）（或者至少不会更快），最坏的情况是，如果您尝试将-1作为 index （而不是您的异常）传递，您将收到一个 OverflowException 。
如果您想以更“正确”和更“一定能行”的方式编写它，您应该放置一个
unchecked
{
// test
}
围绕测试展开的全方位内容。
checked上下文中执行此操作而不是正常的unchecked时，它确实会抛出异常。但这并没有真正回答问题。 - Jon Hannacmp dword ptr [rsp+64h],0 / jl 00000000000000A2，所以转换操作会明确地比较整数是否小于0，如果是，则跳转。 - xanatosint强制转换为uint并存储不会在该级别引起任何异常，所以测试必须是明确的，但这里的区别可能只是jl和jb之间的区别。 - Jon Hanna是的，这更有效率。当进行检查数组索引范围时，JIT也会使用同样的技巧。
转换和推理如下：
i >= 0 && i < array.Length 变成 (uint)i < (uint)array.Length，因为 array.Length <= int.MaxValue，所以array.Length 和 (uint)array.Length有相同的值。如果 i 是负数，则 (uint)i > int.MaxValue，检查失败。
实际上，在现实生活中并不更快。请查看：https://dotnetfiddle.net/lZKHmn
结果表明，由于英特尔的分支预测和并行执行，更明显和易读的代码实际上运行得更快...
以下是代码：
using System;
using System.Diagnostics;
public class Program
{
const int MAX_ITERATIONS = 10000000;
const int MAX_SIZE = 1000;
public static void Main()
{
var timer = new Stopwatch();
Random rand = new Random();
long InRange = 0;
long OutOfRange = 0;
timer.Start();
for ( int i = 0; i < MAX_ITERATIONS; i++ ) {
var x = rand.Next( MAX_SIZE * 2 ) - MAX_SIZE;
if ( x < 0 || x > MAX_SIZE ) {
OutOfRange++;
} else {
InRange++;
}
}
timer.Stop();
Console.WriteLine( "Comparision 1: " + InRange + "/" + OutOfRange + ", elapsed: " + timer.ElapsedMilliseconds + "ms" );
rand = new Random();
InRange = 0;
OutOfRange = 0;
timer.Reset();
timer.Start();
for ( int i = 0; i < MAX_ITERATIONS; i++ ) {
var x = rand.Next( MAX_SIZE * 2 ) - MAX_SIZE;
if ( (uint) x > (uint) MAX_SIZE ) {
OutOfRange++;
} else {
InRange++;
}
}
timer.Stop();
Console.WriteLine( "Comparision 2: " + InRange + "/" + OutOfRange + ", elapsed: " + timer.ElapsedMilliseconds + "ms" );
}
}
在探索英特尔处理器时，我发现执行时间没有任何差异，可能是由于有多个整数执行单元。
但是，在没有分支预测或整数执行单元的16MHZ实时微处理器上进行此操作时，存在明显差异。
较慢代码的100万次迭代需要1761毫秒。
int slower(char *a, long i)
{
if (i < 0 || i >= 10)
return 0;
return a[i];
}
100万次迭代，更快的代码只需要1635毫秒
int faster(char *a, long i)
{
if ((unsigned int)i >= 10)
return 0;
return a[i];
}
int到uint的类型转换）：http://www.codeproject.com/Articles/8052/Type-casting-impact-over-execution-performance-in - Tim Schmelter_size永远不会是负数。 - BlueRaja - Danny Pflughoeft