String.Join と文字列ビルダー:どちらが速いですか？

https://stackoverflow.com/questions/585860

06-09-2019
|

質問

で前の質問のフォーマットについて double[][] CSV形式に変換し、それは提案されましたそれを使って StringBuilder よりも速いでしょう String.Join. 。これは本当ですか？

解決

短い答え：場合によります。

長い答え: (区切り文字を使用して) 連結する文字列の配列がすでにある場合は、 String.Join が最も早い方法です。

String.Join すべての文字列を調べて必要な正確な長さを割り出し、もう一度戻ってすべてのデータをコピーします。つまり、 いいえ 余分なコピーが含まれます。ののみ欠点は、文字列を 2 回通過する必要があることです。これは、必要以上にメモリキャッシュを破壊する可能性があることを意味します。

もし、あんたが しないでください 文字列を事前に配列として用意しておくと、 おそらく より速く使える StringBuilder - しかし、そうでない状況もあるでしょう。を使用する場合は、 StringBuilder 大量のコピーを実行し、配列を構築してから呼び出すことを意味します。 String.Join もっと速いかもしれません。

編集：これは、への 1 回の呼び出しに関するものです。 String.Join vs 大量の呼び出し StringBuilder.Append. 。元の質問では、2 つの異なるレベルがありました。 String.Join したがって、ネストされた呼び出しのそれぞれによって中間文字列が作成されることになります。言い換えれば、それはさらに複雑で、推測するのが困難です。一般的なデータでは、どちらの方法でも（複雑さの点で）大幅に「勝利」するのを見ると驚かれるでしょう。

編集：家にいるときは、できるだけ苦痛なベンチマークを書きます。 StringBuilder. 。基本的に、各要素のサイズが前の要素の約 2 倍である配列があり、それを適切に実行できれば、(区切り文字ではなく要素の) 追加ごとにコピーを強制できるはずですが、これには必要があります。も考慮に入れてください)。その時点では、単純な文字列連結とほぼ同じくらい悪いですが、 String.Join 問題ないでしょう。

他のヒント

ここでは簡略化のためint[][]を使用して私のテストリグは、です。結果最初ます：

Join: 9420ms (chk: 210710000
OneBuilder: 9021ms (chk: 210710000

（double結果の更新：）

Join: 11635ms (chk: 210710000
OneBuilder: 11385ms (chk: 210710000

（* 150 2048 * 64再更新）

Join: 11620ms (chk: 206409600
OneBuilder: 11132ms (chk: 206409600

とOptimizeForTestingを有効にしてます：

Join: 11180ms (chk: 206409600
OneBuilder: 10784ms (chk: 206409600

そう速くはなく、大規模なので、リグ（など、リリースモードでは、コンソールで実行します）：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Collect()
        {
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
            GC.WaitForPendingFinalizers();
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
            GC.WaitForPendingFinalizers();
        }
        static void Main(string[] args)
        {
            const int ROWS = 500, COLS = 20, LOOPS = 2000;
            int[][] data = new int[ROWS][];
            Random rand = new Random(123456);
            for (int row = 0; row < ROWS; row++)
            {
                int[] cells = new int[COLS];
                for (int col = 0; col < COLS; col++)
                {
                    cells[col] = rand.Next();
                }
                data[row] = cells;
            }
            Collect();
            int chksum = 0;
            Stopwatch watch = Stopwatch.StartNew();
            for (int i = 0; i < LOOPS; i++)
            {
                chksum += Join(data).Length;
            }
            watch.Stop();
            Console.WriteLine("Join: {0}ms (chk: {1}", watch.ElapsedMilliseconds, chksum);

            Collect();
            chksum = 0;
            watch = Stopwatch.StartNew();
            for (int i = 0; i < LOOPS; i++)
            {
                chksum += OneBuilder(data).Length;
            }
            watch.Stop();
            Console.WriteLine("OneBuilder: {0}ms (chk: {1}", watch.ElapsedMilliseconds, chksum);

            Console.WriteLine("done");
            Console.ReadLine();
        }
        public static string Join(int[][] array)
        {
            return String.Join(Environment.NewLine,
                    Array.ConvertAll(array,
                      row => String.Join(",",
                        Array.ConvertAll(row, x => x.ToString()))));
        }
        public static string OneBuilder(IEnumerable<int[]> source)
        {
            StringBuilder sb = new StringBuilder();
            bool firstRow = true;
            foreach (var row in source)
            {
                if (firstRow)
                {
                    firstRow = false;
                }
                else
                {
                    sb.AppendLine();
                }
                if (row.Length > 0)
                {
                    sb.Append(row[0]);
                    for (int i = 1; i < row.Length; i++)
                    {
                        sb.Append(',').Append(row[i]);
                    }
                }
            }
            return sb.ToString();
        }
    }
}

私はそうは思いません。リフレクターてみると、String.Joinの実装は非常に最適化されて見えます。それは任意の再割り当てを必要としないので、それはまた、事前に作成される文字列の合計サイズを知っているという利点もあります。

私はそれらを比較するために、2つのテストメソッドを作成しています：

public static string TestStringJoin(double[][] array)
{
    return String.Join(Environment.NewLine,
        Array.ConvertAll(array,
            row => String.Join(",",
                       Array.ConvertAll(row, x => x.ToString()))));
}

public static string TestStringBuilder(double[][] source)
{
    // based on Marc Gravell's code

    StringBuilder sb = new StringBuilder();
    foreach (var row in source)
    {
        if (row.Length > 0)
        {
            sb.Append(row[0]);
            for (int i = 1; i < row.Length; i++)
            {
                sb.Append(',').Append(row[i]);
            }
        }
    }
    return sb.ToString();
}

Iは、サイズ[2048][64]の配列を渡し、各メソッドを50回実行しました。私は、2つの配列のためにこれをしませんでした。一つはゼロで満たされ、別のランダムな値で満たされました。私は私のマシン上で以下の結果を得た（P4 3.0 GHzの、シングルコア、無HT、CMDからリリースモードを実行している）：

// with zeros:
TestStringJoin    took 00:00:02.2755280
TestStringBuilder took 00:00:02.3536041

// with random values:
TestStringJoin    took 00:00:05.6412147
TestStringBuilder took 00:00:05.8394650

：10に反復回数を減らすと私に次のような結果を得ながら、

、[2048][512]するために、配列のサイズを増やします

// with zeros:
TestStringJoin    took 00:00:03.7146628
TestStringBuilder took 00:00:03.8886978

// with random values:
TestStringJoin    took 00:00:09.4991765
TestStringBuilder took 00:00:09.3033365

の結果が再現（ほぼ、小さな変動が異なるランダムな値に起因して）です。どうやらString.Joinは少し速く（非常に小さいマージンだけが）ほとんどの時間です。

これは、私がテストのために使用されるコードは、次のとおりです。

const int Iterations = 50;
const int Rows = 2048;
const int Cols = 64; // 512

static void Main()
{
    OptimizeForTesting(); // set process priority to RealTime

    // test 1: zeros
    double[][] array = new double[Rows][];
    for (int i = 0; i < array.Length; ++i)
        array[i] = new double[Cols];

    CompareMethods(array);

    // test 2: random values
    Random random = new Random();
    double[] template = new double[Cols];
    for (int i = 0; i < template.Length; ++i)
        template[i] = random.NextDouble();

    for (int i = 0; i < array.Length; ++i)
        array[i] = template;

    CompareMethods(array);
}

static void CompareMethods(double[][] array)
{
    Stopwatch stopwatch = Stopwatch.StartNew();
    for (int i = 0; i < Iterations; ++i)
        TestStringJoin(array);
    stopwatch.Stop();
    Console.WriteLine("TestStringJoin    took " + stopwatch.Elapsed);

    stopwatch.Reset(); stopwatch.Start();
    for (int i = 0; i < Iterations; ++i)
        TestStringBuilder(array);
    stopwatch.Stop();
    Console.WriteLine("TestStringBuilder took " + stopwatch.Elapsed);

}

static void OptimizeForTesting()
{
    Thread.CurrentThread.Priority = ThreadPriority.Highest;
    Process currentProcess = Process.GetCurrentProcess();
    currentProcess.PriorityClass = ProcessPriorityClass.RealTime;
    if (Environment.ProcessorCount > 1) {
        // use last core only
        currentProcess.ProcessorAffinity
            = new IntPtr(1 << (Environment.ProcessorCount - 1));
    }
}

1％の差は、プログラム全体の実行にかかる時間の面で重要なものになっていない限り、

、これはマイクロ最適化のように見えます。私は、1％のパフォーマンスの違いを心配最も/読み、理解していないのですコードを書くと思います。

アトウッドは、1ヶ月前これに関連のポスト種類を持っています：

http://www.codinghorror.com/blog/archives/001218.html の

はい。結合を複数回行うと、次のようになります。 たくさん もっと早く。

string.join を実行する場合、ランタイムは次のことを行う必要があります。

結果の文字列にメモリを割り当てます。
最初の文字列の内容を出力文字列の先頭にコピーします
2 番目の文字列の内容を出力文字列の末尾にコピーします。

2 つの結合を行う場合は、データを 2 回コピーする必要があります。

StringBuilder は、スペースに余裕を持って 1 つのバッファーを割り当てるため、元の文字列をコピーしなくてもデータを追加できます。バッファーにはスペースが残っているため、追加された文字列をバッファーに直接書き込むことができます。その後、最後に文字列全体を 1 回コピーするだけです。

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow