Является ли String.Format таким же эффективным, как StringBuilder

Ответ 1

ПРИМЕЧАНИЕ: Этот ответ был написан, когда .NET 2.0 была текущей версией. Это может больше не применяться к более поздним версиям.

String.Format использует StringBuilder внутри:

public static string Format(IFormatProvider provider, string format, params object[] args)
{
    if ((format == null) || (args == null))
    {
        throw new ArgumentNullException((format == null) ? "format" : "args");
    }

    StringBuilder builder = new StringBuilder(format.Length + (args.Length * 8));
    builder.AppendFormat(provider, format, args);
    return builder.ToString();
}

Приведенный выше код является фрагментом из mscorlib, поэтому возникает вопрос: "StringBuilder.Append() быстрее, чем StringBuilder.AppendFormat()"?

Без бенчмаркинга я бы сказал, что приведенный выше пример кода будет работать быстрее с использованием .Append(). Но это предположение, попробуйте сравнительный анализ и/или профилирование, чтобы получить правильное сравнение.

Этот парень, Джерри Диксон, провел несколько сравнительных тестов:

http://jdixon.dotnetdevelopersjournal.com/string_concatenation_stringbuilder_and_stringformat.htm

Обновлено:

К сожалению, ссылка выше с тех пор умерла. Однако на Путь назад машина все еще есть копия:

http://web.archive.org/web/20090417100252/http://jdixon.dotnetdevelopersjournal.com/string_concatenation_stringbuilder_and_stringformat.htm

В конце концов, это зависит от того, будет ли форматирование строки вызываться многократно, т.е. вы выполняете серьезную текстовую обработку более 100 мегабайт текста, или же он вызывается, когда пользователь время от времени нажимает кнопку. Если вы не выполняете какую-то огромную работу по пакетной обработке, я бы придерживался String.Format, это способствует удобочитаемости кода. Если вы подозреваете узкое место перфорации, прикрепите профилировщик к своему коду и посмотрите, где он на самом деле.

Ответ 2

Из документация MSDN:

Производительность операции конкатенации для объекта String или StringBuilder зависит от того, как часто происходит распределение памяти. Операция конкатенации строк всегда выделяет память, тогда как операция конкатенации StringBuilder выделяет только память, если буфер объекта StringBuilder слишком мал для размещения новых данных. Следовательно, класс String является предпочтительным для операции конкатенации, если фиксированное число объектов String конкатенировано. В этом случае отдельные операции конкатенации могут быть даже объединены в одну операцию компилятором. Объект StringBuilder предпочтительнее для операции конкатенации, если произвольное количество строк конкатенировано; например, если цикл объединяет случайное число строк пользовательского ввода.

Ответ 3

Я провел несколько быстрых тестов производительности, и для 100 000 операций, усредненных за 10 запусков, первый метод (String Builder) занимает почти половину времени второго (String Format).

Итак, если это нечасто, это не имеет значения. Но если это обычная операция, вы можете использовать первый метод.

Ответ 4

Я бы ожидал, что String.Format будет медленнее - он должен проанализировать строку и затем объединить ее.

Пара примечаний:

• Формат - это способ использования видимых пользователем строк в профессиональных приложениях; это позволяет избежать ошибок локализации.
• Если вы знаете длину результирующей строки заранее, используйте конструктор StringBuilder (Int32), чтобы предопределить емкость

Ответ 5

Если только потому, что string.Format точно не делает то, что вы можете подумать, вот повторение тестов через 6 лет после Net45.

Конкат по-прежнему самый быстрый, но на самом деле разница менее 30%. StringBuilder и Format отличаются только 5-10%. Я несколько раз тестировал 20% тестов.

Миллисекунды, миллион итераций:

• Конкатенация: 367
• Новый stringBuilder для каждого ключа: 452
• Cached StringBuilder: 419
• string.Format: 475

Урок, который я убираю, состоит в том, что разница в производительности тривиальна и поэтому не должна мешать вам писать простейший читаемый код. Что за мои деньги часто, но не всегда a + b + c.

const int iterations=1000000;
var keyprefix= this.GetType().FullName;
var maxkeylength=keyprefix + 1 + 1+ Math.Log10(iterations);
Console.WriteLine("KeyPrefix \"{0}\", Max Key Length {1}",keyprefix, maxkeylength);

var concatkeys= new string[iterations];
var stringbuilderkeys= new string[iterations];
var cachedsbkeys= new string[iterations];
var formatkeys= new string[iterations];

var stopwatch= new System.Diagnostics.Stopwatch();
Console.WriteLine("Concatenation:");
stopwatch.Start();

for(int i=0; i<iterations; i++){
    var key1= keyprefix+":" + i.ToString();
    concatkeys[i]=key1;
}

Console.WriteLine(stopwatch.ElapsedMilliseconds);

Console.WriteLine("New stringBuilder for each key:");
stopwatch.Restart();

for(int i=0; i<iterations; i++){
    var key2= new StringBuilder(keyprefix).Append(":").Append(i.ToString()).ToString();
    stringbuilderkeys[i]= key2;
}

Console.WriteLine(stopwatch.ElapsedMilliseconds);

Console.WriteLine("Cached StringBuilder:");
var cachedSB= new StringBuilder(maxkeylength);
stopwatch.Restart();

for(int i=0; i<iterations; i++){
    var key2b= cachedSB.Clear().Append(keyprefix).Append(":").Append(i.ToString()).ToString();
    cachedsbkeys[i]= key2b;
}

Console.WriteLine(stopwatch.ElapsedMilliseconds);

Console.WriteLine("string.Format");
stopwatch.Restart();

for(int i=0; i<iterations; i++){
    var key3= string.Format("{0}:{1}", keyprefix,i.ToString());
    formatkeys[i]= key3;
}

Console.WriteLine(stopwatch.ElapsedMilliseconds);

var referToTheComputedValuesSoCompilerCantOptimiseTheLoopsAway= concatkeys.Union(stringbuilderkeys).Union(cachedsbkeys).Union(formatkeys).LastOrDefault(x=>x[1]=='-');
Console.WriteLine(referToTheComputedValuesSoCompilerCantOptimiseTheLoopsAway);

Ответ 6

Я думаю, что в большинстве случаев такая ясность, а не эффективность, должна быть вашей самой большой проблемой. Если вы не сокрушаете тонны струн или не создаете что-то для мобильного устройства с более низким питанием, это, вероятно, не будет сильно зависеть от скорости вашего запуска.

Я обнаружил, что в тех случаях, когда я строю строки довольно линейным образом, ваш лучший вариант - либо прямые конкатенации, либо использование StringBuilder. Я предлагаю это в тех случаях, когда большая часть строкой, которую вы строите, является динамической. Так как очень мало текста является статичным, самое главное, что он ясно, где каждый кусок динамического текста помещается в случае, если он нуждается в обновлении в будущем.

С другой стороны, если вы говорите о большом фрагменте статического текста с двумя или тремя переменными в нем, даже если это немного менее эффективно, я думаю, что ясность, которую вы получаете от string.Format, стоит того, Я использовал это ранее на этой неделе, когда нужно разместить один бит динамического текста в центре документа на 4 страницы. Будет легче обновить этот большой фрагмент текста, если его в одном фрагменте, чем обновление трех частей, которые вы объедините вместе.

Ответ 7

String.Format использует StringBuilder внутренне... так логично, что приводит к мысли, что он будет немного менее результативным из-за большего количества накладных расходов. Однако простая конкатенация строк - это самый быстрый способ впрыска одной строки между двумя другими... в значительной степени. Это доказательство было продемонстрировано Рико Мариани в его первой спектакле "Опрос", много лет назад. Простым фактом является то, что конкатенации... когда количество частей струны известно (без ограничений.. вы можете объединить тысячу частей... пока вы знаете, что это всегда 1000 частей)... всегда быстрее, чем StringBuilder или String.Format. Они могут выполняться с единичным распределением памяти в виде серии копий памяти. Здесь является доказательством

И вот фактический код для некоторых методов String.Concat, которые в конечном итоге называют FillStringChecked, который использует указатели для копирования памяти (извлеченные через Reflector):

public static string Concat(params string[] values)
{
    int totalLength = 0;

    if (values == null)
    {
        throw new ArgumentNullException("values");
    }

    string[] strArray = new string[values.Length];

    for (int i = 0; i < values.Length; i++)
    {
        string str = values[i];
        strArray[i] = (str == null) ? Empty : str;
        totalLength += strArray[i].Length;

        if (totalLength < 0)
        {
            throw new OutOfMemoryException();
        }
    }

    return ConcatArray(strArray, totalLength);
}

public static string Concat(string str0, string str1, string str2, string str3)
{
    if (((str0 == null) && (str1 == null)) && ((str2 == null) && (str3 == null)))
    {
        return Empty;
    }

    if (str0 == null)
    {
        str0 = Empty;
    }

    if (str1 == null)
    {
        str1 = Empty;
    }

    if (str2 == null)
    {
        str2 = Empty;
    }

    if (str3 == null)
    {
        str3 = Empty;
    }

    int length = ((str0.Length + str1.Length) + str2.Length) + str3.Length;
    string dest = FastAllocateString(length);
    FillStringChecked(dest, 0, str0);
    FillStringChecked(dest, str0.Length, str1);
    FillStringChecked(dest, str0.Length + str1.Length, str2);
    FillStringChecked(dest, (str0.Length + str1.Length) + str2.Length, str3);
    return dest;
}

private static string ConcatArray(string[] values, int totalLength)
{
    string dest = FastAllocateString(totalLength);
    int destPos = 0;

    for (int i = 0; i < values.Length; i++)
    {
        FillStringChecked(dest, destPos, values[i]);
        destPos += values[i].Length;
    }

    return dest;
}

private static unsafe void FillStringChecked(string dest, int destPos, string src)
{
    int length = src.Length;

    if (length > (dest.Length - destPos))
    {
        throw new IndexOutOfRangeException();
    }

    fixed (char* chRef = &dest.m_firstChar)
    {
        fixed (char* chRef2 = &src.m_firstChar)
        {
            wstrcpy(chRef + destPos, chRef2, length);
        }
    }
}

Итак, тогда:

string what = "cat";
string inthehat = "The " + what + " in the hat!";

Наслаждайтесь!

Ответ 8

О, также самый быстрый был бы:

string cat = "cat";
string s = "The " + cat + " in the hat";

Ответ 9

Это действительно зависит. Для небольших строк с небольшим количеством конкатенаций на самом деле быстрее просто добавить строки.

String s = "String A" + "String B";

Но для большей строки (очень больших строк) более эффективно использовать StringBuilder.

Ответ 10

В обоих случаях выше я хочу вставить одну или несколько строк в середину предопределенной строки шаблона.

В этом случае я бы предложил String.Format является самым быстрым, потому что он предназначен для этой цели.

Ответ 11

Это действительно зависит от вашего шаблона использования.
Подробный тест между string.Join, string,Concat и string.Format можно найти здесь: String.Format не подходит для интенсивной регистрации

Ответ 12

Я бы предположил, что нет, поскольку String.Format не был предназначен для конкатенации, это был дизайн для форматирования вывода различных входных данных, таких как дата.

String s = String.Format("Today is {0:dd-MMM-yyyy}.", DateTime.Today);