[C#].NET中字符串的 ToLower，ToUpper，ToLowerInvariant，ToUpperInvariant 性能测试及分析

我最近在研读《CLR via C#》，其中有一个章节讲String类型，Jeffrey说当进行不区分大小写的字符串对比时，应当尽量多的使用ToUpperInvariant，因为一方面CLR对转换为大写的操作进行了专门的优化，使其性能更加卓越；另一方面ToUpperInvariant和ToLowerInvariant忽略了对语言文化的处理，因此性能比ToUpper和ToLower要快得多。

从理论层面上来讲，这应该是正确的。但是究竟能快多少呢？或者说这种性能提升值不值得我们付出专门的精力来关注呢？

我们下面就进行一个测试，看看它们究竟能对性能产生多大影响。

首先，我实例化了一个 char 类型数组，并使用 Char Code 在 0 到 133 之间的随机字符填满，我们就得到了一个随机的测试用例，其中包含半角符号、小写英文字母和大写英文字母。

然后我要分别测试 Char 类型的四个静态函数和 String 类型的四个实例函数，我猜测 String 类型中的实例函数实际上也是通过 Char 类型中相对应的静态函数实现的。

为了避免CLR的内存优化对测试结果产生影响，每执行一项测试之前，都将在堆中创建新的示例，并从测试用例中复制成员。

除此之外，为了尽量保证测试结果的正确性，我将循环执行并记录测试代码 N 次，之后取它们的去权平均值。

=====================我是分割线=====================

下面是测试代码：

填充数组：

static void Fill()
 {
    //实例化一个容纳10000个字符的数组
    letters = new char[maxElementsCount];
    //填充数组
    for (int i = 0; i < maxElementsCount; i++)
    {
        var charcode = R.Next(0, 133);
        letters[i] = Convert.ToChar(charcode);
    }
}

执行 Char 静态方法测试的执行函数：

 static double Invoke(Action<char[]> func,string testname)
{
    char[] source = new char[maxElementsCount];
    letters.CopyTo(source, 0);
    DateTime start = DateTime.Now; //当前时间
    DateTime end = DateTime.Now;
    Console.WriteLine("开始测试 "+ testname + " [开始时间：" + start.ToString() + "]");
    func(source);
    end = DateTime.Now;
    var during = (end - start).TotalMilliseconds;
    Console.WriteLine("测试 " + testname + " 完成，耗时" + during + "毫秒[结束时间：" + end.ToString() + "]");
    return during;
}

执行 String 实例方法的执行函数：

static double InvokeString(Action<string> func, string testname)
{
    string source = new string(letters);
    DateTime start = DateTime.Now; //当前时间
    DateTime end = DateTime.Now;
    Console.WriteLine("开始测试 " + testname + " [开始时间：" + start.ToString() + "]");
    func(source);
    end = DateTime.Now;
    var during = (end - start).TotalMilliseconds;
    Console.WriteLine("测试 " + testname + " 完成，耗时" + during + "毫秒[结束时间：" + end.ToString() + "]");
    return during;
}

测试方法：

static void Run(int maxElementsCount)
{
    Fill();

    char_tolower.Add(Invoke(s =>
    {
        for (int i = 0; i < s.Length; i++)
        {
            char.ToLower(s[i]);
        }
    }, "Char.ToLower"));

    char_toupper.Add(Invoke(s =>
    {
        for (int i = 0; i < s.Length; i++)
        {
            char.ToUpper(s[i]);
        }
    }, "Char.ToUpper"));

    char_tolowerinvariant.Add(Invoke(s =>
    {
        for (int i = 0; i < s.Length; i++)
        {
            char.ToLowerInvariant(s[i]);
        }
    }, "Char.ToLowerInvariant"));

    char_toupperinvariant.Add(Invoke(s =>
    {
        for (int i = 0; i < s.Length; i++)
        {
            char.ToUpperInvariant(s[i]);
        }
    }, "Char.ToUpperInvariant"));

    string_tolower.Add(InvokeString(s =>
    {
        s.ToLower();
    }, "String.ToLower"));

    string_toupper.Add(InvokeString(s =>
    {
        s.ToUpper();
    }, "String.ToUpper"));

    string_tolowerinvariant.Add(InvokeString(s =>
    {
        s.ToLowerInvariant();
    }, "String.ToLowerInvariant"));

    string_toupperinvariant.Add(InvokeString(s =>
    {
        s.ToUpperInvariant();
    }, "String.ToUpperInvariant"));
}

 以下是循环执行1000次的去权平均数：

 从结果中我们可以看出，ToLowerInvariant 和 ToUpperInvariant 因为忽略的语言信息，性能的确是比关注语言信息的 ToLower 和 ToUpper 要快一些。但是Char.ToUpper的性能比Char.ToLower的性能竟然还要差，这可能是由于随机的测试数据不够随机造成的。

此外，还可以得出 String 类型的四个实例函数并非通过 Char 中的静态函数实现的 ， 这应该是因为.NET CLR 中定义的 String 是一个单独的基元类型，而并非是 Char 数组 ， 因此经过了单独的实现，并且性能明显要好过 Char 的数组。

但是我这里用的测试数据是一个长达 100万 字的字符串，在这种情况下的性能损失不足0.1毫秒，实在是不值一提。我测试用的电脑是 i5 4代处理器，相信在计算能力更强的处理器上，这个数值将被无限的缩小。因此我们在实际开发中几乎不需要特别关注应当用哪个方法，特别是如果在做国际化的应用时，ToLowerInvariant 和 ToUpperInvariant 虽然能够带来性能的提升，但是也可能导致隐形BUG，并不值得推广。此外，在开发中我们应当尽量少的使用 Char 类型，一个 Char 类型对象要单独占用一个栈内存地址，且只能存储一个字符，实在是太不合算。