C#中查询字符串中是否包含指定字符/字符串，使用IndexOf还是Contains?

C#中查询字符串中是否包含指定字符/串，使用IndexOf还是Contains?这是一个很常见的命题，以前也没有注意，今天QQ群里有人提起，于是就做了下试验，代码如下：

using System;
using System.Diagnostics;

namespace ConsoleApplication1
{
    class Program
    {
        private const int N = 10000000;
        private static Stopwatch watch = new Stopwatch();
        static void Main(string[] args)
        {

            string source = "abcdefghijklmnopqrstuvwxyz0123456789C#"
                          + "中查询字符串中是否包含指定字符/串，使用IndexOf还是Contains?.uonun";
            string target = "a";
            Console.WriteLine("目标为第一个字符时：");
            TestContains(source, target);
            TestIndexOf(source, target);
            Console.WriteLine();

            Console.WriteLine("目标为中部某个字符时：");
            target = "中";
            TestContains(source, target);
            TestIndexOf(source, target);
            Console.WriteLine();

            Console.WriteLine("目标为最后一个字符时：");
            target = "u";
            TestContains(source, target);
            TestIndexOf(source, target);

            Console.WriteLine("执行完毕，按任意键退出...");
            Console.ReadKey();

        }
        private static void TestIndexOf(string source, string target)
        {
            watch.Reset();
            watch.Start();
            for (int i = 0;i < N;i++)
            {
                source.IndexOf(target);
            }
            watch.Stop();
            Console.WriteLine("IndexOf: " + watch.ElapsedMilliseconds.ToString() + "ms");
            return;
        }

        private static void TestContains(string source, string target)
        {
            watch.Reset();
            watch.Start();
            for (int i = 0;i < N;i++)
            {
                source.Contains(target);
            }
            watch.Stop();
            Console.WriteLine("Contains: " + watch.ElapsedMilliseconds.ToString() + "ms");
            return;
        }
    }
}

得到的结果是：

目标为第一个字符时：
Contains: 973ms
IndexOf: 1343ms

目标为中部某个字符时：
Contains: 1813ms
IndexOf: 8602ms

目标为最后一个字符时：
Contains: 1433ms
IndexOf: 5094ms
执行完毕，按任意键退出...

可以看出，使用Contains方法的效率比IndexOf的效率高很多。

疑问：Contains 调用了 IndexOf，反倒比 IndexOf 还快？

正如评论中@Vampire_D 所说，Contains 调用了 IndexOf，如果 Contains 比 IndexOf 还快，简直不科学啊！不过仔细一看一对比你就会知道，正是 IndexOf 的第二个参数在捣鬼。

.NET 中 Contains 和 IndexOf 分别是这样实现的：

// Type: System.String
// Assembly: mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// MVID: 00788FED-9041-4DB2-AB5B-0952A06515B1
// Assembly location: C:\Windows\Microsoft.NET\Framework\v2.0.50727\mscorlib.dll

// .NET 中字符串的 Contains 和 IndexOf 方法的实现：

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

    public int IndexOf(string value)
    {
      return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this, value);
    }

    public int IndexOf(string value, int startIndex)
    {
      return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this, value, startIndex);
    }

    public int IndexOf(string value, int startIndex, int count)
    {
      if (startIndex < 0 || startIndex > this.Length)
        throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
      if (count < 0 || count > this.Length - startIndex)
        throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count"));
      else
        return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this, value, startIndex, count, CompareOptions.None);
    }

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

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

    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"));
      switch (comparisonType)
      {
        case StringComparison.CurrentCulture:
          return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this, value, startIndex, count, CompareOptions.None);
        case StringComparison.CurrentCultureIgnoreCase:
          return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this, value, startIndex, count, CompareOptions.IgnoreCase);
        case StringComparison.InvariantCulture:
          return CultureInfo.InvariantCulture.CompareInfo.IndexOf(this, value, startIndex, count, CompareOptions.None);
        case StringComparison.InvariantCultureIgnoreCase:
          return CultureInfo.InvariantCulture.CompareInfo.IndexOf(this, value, startIndex, count, CompareOptions.IgnoreCase);
        case StringComparison.Ordinal:
          return CultureInfo.InvariantCulture.CompareInfo.IndexOf(this, value, startIndex, count, CompareOptions.Ordinal);
        case StringComparison.OrdinalIgnoreCase:
          return TextInfo.IndexOfStringOrdinalIgnoreCase(this, value, startIndex, count);
        default:
          throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), "comparisonType");
      }
    }

可以看出，Contains 默认使用 CultureInfo.InvariantCulture 来比较字符/字符串，而 IndexOf 在不带第二个参数时，默认使用 CultureInfo.CurrentCulture 来比较字符/字符串，这直接导致了比较过程的复杂性，从而影响了两个方法的执行效率（以及结果——我没有去验证什么情况下结果会不一致）。

进一步地，我们来看看使用这两个不同的 CultureInfo 到底有什么不同？

CultureInfo.InvariantCulture：它是 CultureInfo 中的一个静态变量，直接在 CultureInfo 的静态构造里实例化了，并且只需要实例化一次。

// Type: System.Globalization.CultureInfo
// Assembly: mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// MVID: 00788FED-9041-4DB2-AB5B-0952A06515B1
// Assembly location: C:\Windows\Microsoft.NET\Framework\v2.0.50727\mscorlib.dll

//------------CultureInfo.InvariantCulture----------

    private static CultureInfo m_InvariantCultureInfo;

    static CultureInfo()
    {
      if (CultureInfo.m_InvariantCultureInfo == null)
        CultureInfo.m_InvariantCultureInfo = new CultureInfo((int) sbyte.MaxValue, false)
        {
          m_isReadOnly = true
        };
      CultureInfo.m_userDefaultCulture = CultureInfo.m_userDefaultUICulture = CultureInfo.m_InvariantCultureInfo;
      CultureInfo.m_userDefaultCulture = CultureInfo.InitUserDefaultCulture();
      CultureInfo.m_userDefaultUICulture = CultureInfo.InitUserDefaultUICulture();
    }

    public static CultureInfo InvariantCulture
    {
      get
      {
        return CultureInfo.m_InvariantCultureInfo;
      }
    }

//-----------CultureInfo.CurrentCulture--------
    public static CultureInfo CurrentCulture
    {
      get
      {
        return Thread.CurrentThread.CurrentCulture;
      }
    }

// other code...

再看 CultureInfo.CurrentCulture：它是当前线程的 CultureInfo，要获取这个属性的值会有一系列的操作，请见下面的代码，Thread.CurrentThread.CurrentCulture：

// Type: System.Threading.Thread
// Assembly: mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// MVID: 00788FED-9041-4DB2-AB5B-0952A06515B1
// Assembly location: C:\Windows\Microsoft.NET\Framework\v2.0.50727\mscorlib.dll

    public CultureInfo CurrentCulture
    {
      get
      {
        if (this.m_CurrentCulture == null)
          return CultureInfo.UserDefaultCulture;
        CultureInfo safeCulture = (CultureInfo) null;
        if (!Thread.nativeGetSafeCulture(this, Thread.GetDomainID(), false, ref safeCulture) || safeCulture == null)
          return CultureInfo.UserDefaultCulture;
        else
          return safeCulture;
      }
      [SecurityPermission(SecurityAction.Demand, ControlThread = true)] set
      {
        if (value == null)
          throw new ArgumentNullException("value");
        CultureInfo.CheckNeutral(value);
        CultureInfo.nativeSetThreadLocale(value.LCID);
        value.StartCrossDomainTracking();
        this.m_CurrentCulture = value;
      }
    }

因此在使用两个不同的 CultureInfo 进行字符/字符串比较时，所花的代价就很不同了，因此执行效率上就有了较大差别。 

结论：不特殊考虑 CultureInfo 时，Contains(string) 的执行效率比 IndexOf(string) 高