String.Contains方法在内部看起来像这样

public bool Contains(string value)
{
   return this.IndexOf(value, StringComparison.Ordinal) >= 0;
}

调用的 IndexOf 重载看起来像这样

public int IndexOf(string value, StringComparison comparisonType)
{
   return this.IndexOf(value, 0, this.Length, comparisonType);
}

这里对最终重载进行了另一个调用，然后使用签名调用相关的 CompareInfo.IndexOf 方法

public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType)

因此，调用最终重载将是最快的(尽管在大多数情况下可能被认为是微优化)。

我可能遗漏了一些明显的东西，但为什么 Contains 方法不直接调用最终重载，因为在中间调用中没有完成其他工作并且两个阶段都提供相同的信息？

唯一的优点是如果最终重载的签名发生变化，只需要进行一个更改(中间方法的更改)，还是设计上还有更多？

根据评论编辑(速度差异解释见更新2)

为了澄清我在某处犯错时遇到的性能差异: 我跑了 this benchmark (循环 5 次以避免抖动偏差)并使用此扩展方法与 String.Contains 方法进行比较

public static bool QuickContains(this string input, string value)
{
   return input.IndexOf(value, 0, input.Length, StringComparison.OrdinalIgnoreCase) >= 0;
}

循环看起来像这样

for (int i = 0; i < 1000000; i++)
{
   bool containsStringRegEx = testString.QuickContains("STRING");
}
sw.Stop();
Console.WriteLine("QuickContains: " + sw.ElapsedMilliseconds);

在基准测试中，QuickContains 似乎比我机器上的 String.Contains 快 50%。

更新 2(解释性能差异)

我在基准测试中发现了一些不公平的地方，这解释了很多。基准测试本身是为了测量不区分大小写的字符串，但由于 String.Contains 只能执行区分大小写的搜索，因此包含了 ToUpper 方法。这会扭曲结果，不是在最终输出方面，而是至少在非区分大小写搜索中简单测量 String.Contains 性能方面。

所以现在，如果我使用这个扩展方法

public static bool QuickContains(this string input, string value)
{
   return input.IndexOf(value, 0, input.Length, StringComparison.Ordinal) >= 0;
}

在 2 重载 IndexOf 调用中使用 StringComparison.Ordinal 并删除 ToUpper，QuickContains 方法实际上变为最慢的。 IndexOf 和 Contains 在性能方面几乎不相上下。很明显，ToUpper 调用扭曲了 Contains 和 IndexOf 之间存在这种差异的结果。

不确定为什么 QuickContains 扩展方法变得最慢。 (可能与 Contains 具有 [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")] 属性有关？)。

关于为什么不直接调用 4 重载方法的问题仍然存在，但该决定似乎没有影响性能(正如 Adrian 和 delnan 在评论中指出的那样)。

最佳答案

自从我研究汇编以来已经有一段时间(几年)了，而且我对 MSIL 和 JIT 几乎一无所知，所以这将是一个很好的练习 - 无法抗拒，所以这里只是一点点，可能是多余的， 经验数据。 IndexOf 重载是否被内联？

这是一个微型控制台应用程序:

class Program
{
    static void Main(string[] args)
    {
        "hello".Contains("hell");
    }
}

JIT 在优化的发布版本中生成此文件，任何 CPU，以 32 位运行。我缩短了地址，并删除了一些不相关的行:

--- ...\Program.cs 
            "hello".Contains("hell");
[snip]
17  mov         ecx,dword ptr ds:[0320219Ch] ; pointer to "hello"
1d  mov         edx,dword ptr ds:[032021A0h] ; pointer to "hell"
23  cmp         dword ptr [ecx],ecx 
25  call        680A6A6C                     ; String.Contains()
[snip]

0x00000025 处的调用 在这里:

字符串.包含

00  push        0                 ; startIndex = 0
02  push        dword ptr [ecx+4] ; count = this.Length (second DWORD of String)
05  push        4                 ; comparisonType = StringComparison.Ordinal
07  call        FF9655A4          ; String.IndexOf()
0c  test        eax,eax 
0e  setge       al                ; if (... >= 0)
11  movzx       eax,al 
14  ret 

果然，它似乎直接调用了带有四个参数的最终 String.IndexOf 重载:三个 pushed； edx 中的一个 (value: "hell"); this(“你好”)在 ecx 中。确认一下，这是 0x00000005 处的 call 所在的位置:

00  push        ebp 
01  mov         ebp,esp 
03  push        edi 
04  push        esi 
05  push        ebx 
06  mov         esi,ecx                  ; this ("hello")
08  mov         edi,edx                  ; value ("hell")
0a  mov         ebx,dword ptr [ebp+10h] 
0d  test        edi,edi                  ; if (value == null)
0f  je          00A374D0 
15  test        ebx,ebx                  ; if (startIndex < 0)
17  jl          00A374FB 
1d  cmp         dword ptr [esi+4],ebx    ; if (startIndex > this.Length)
20  jl          00A374FB 
26  cmp         dword ptr [ebp+0Ch],0    ; if (count < 0)
2a  jl          00A3753F 
[snip]

...这将是主体:

public int IndexOf(string value, 
                   int startIndex, 
                   int count, 
                   StringComparison comparisonType)
{
  if (value == null)
    throw new ArgumentNullException("value");
  if (startIndex < 0 || startIndex > this.Length)
    throw new ArgumentOutOfRangeException("startIndex",
             Environment.GetResourceString("ArgumentOutOfRange_Index"));
  if (count < 0 || startIndex > this.Length - count)
    throw new ArgumentOutOfRangeException("count",
             Environment.GetResourceString("ArgumentOutOfRange_Count"));
  ...
}

关于c# - 为什么 String.Contains 不直接调用最终重载？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17581565/