Использует StringBuilder, Удаляют метод больше памяти, эффективной, чем создание нового StringBuilder в цикле?

В то время как Ваше профилирование, Вы могли также попытаться просто обнулить длину StringBuilder при вводе цикла.

formattedOutput.Length = 0;

Опция 2 должна (я верить), на самом деле превосходят опцию 1 по характеристикам. Действие вызова Remove "вынуждает" StringBuilder сделать копию строки, это уже возвращается. Строка на самом деле изменяема в StringBuilder, и StringBuilder не делает копию, если это не должно. С опцией 1 это копирует, прежде в основном убрать массив - с опцией 2 никакая копия не требуется.

Единственный недостаток опции 2 - то, что, если строка заканчивает тем, что была длинна, будет несколько копий, сделанных при добавлении - тогда как опция 1 сохраняет первоначальный размер буфера. Если это будет случаем, однако, укажите начальную возможность избежать дополнительного копирования. (В Вашем примере кода строка закончит тем, что была больше, чем значение по умолчанию 16 символов - инициализация, это со способностью, скажем, 32 уменьшит дополнительные требуемые строки.)

Кроме производительности, однако, опция 2 является просто инструментом для очистки.

Так как Вы заинтересованы только с памятью, я предложил бы:

foreach (string outputString in outputStrings)
    {    
        string output = "prefix " + outputString + " postfix";
        ExistingOutputMethodThatOnlyTakesAString(output)  
    }

Названный вывод переменной является тем же размером в Вашей исходной реализации, но никакие другие объекты не необходимы. StringBuilder использует строки и другие объекты внутренне, и Вы будете созданы много объектов, которые должны быть GC'd.

Оба строка от опции 1:

string output = formattedOutput.ToString();

И строка от опции 2:

ExistingOutputMethodThatOnlyTakesAString(
           formattedOutputInsideALoop.ToString());

создаст неизменный объект со значением префикса + outputString + постфикс. Эта строка является тем же размером, неважно, как Вы создаете его. То, что Вы действительно спрашиваете, - который является большей эффективной памятью:

    StringBuilder formattedOutput = new StringBuilder(); 
    // create new string builder

или

    formattedOutput.Remove(0, output.Length); 
    // reuse existing string builder

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

Если действительно необходимо знать, какой из этих двух более эффективен в приложении (это будет, вероятно, варьироваться на основе размера списка, префикса и outputStrings), я рекомендовал бы Профилировщику МУРАВЬЕВ красного логического элемента http://www.red-gate.com/products/ants_profiler/index.htm

Jason

Ненависть для высказывания этого, но как насчет того, чтобы просто тестировать его?

Этот материал легко узнать собой. Выполните Perfmon.exe и добавьте счетчик для Памяти.NET + Генерал 0 Наборов. Выполните тестовый код миллион раз. Вы будете видеть, что опция № 1 требует половины количества потребностей наборов опций № 2.

Мы говорили об этом прежде с Java, вот [Выпуск] результаты версии C#:

Option #1 (10000000 iterations): 11264ms
Option #2 (10000000 iterations): 12779ms

Обновление: В моем ненаучном анализе, позволяющем эти два метода выполниться при контроле всех счетчиков производительности памяти в perfmon, не привел ни к какому виду заметного различия ни с одним методом (кроме наличия некоторого скачка счетчиков только, в то время как любой тест выполнялся).

И вот то, что я раньше тестировал:

class Program
{
    const int __iterations = 10000000;

    static void Main(string[] args)
    {
        TestStringBuilder();
        Console.ReadLine();
    }

    public static void TestStringBuilder()
    {
        //potentially a collection with several hundred items:
        var outputStrings = new [] { "test1", "test2", "test3" };

        var stopWatch = new Stopwatch();

        //Option #1
        stopWatch.Start();
        var formattedOutput = new StringBuilder();

        for (var i = 0; i < __iterations; i++)
        {
            foreach (var outputString in outputStrings)
            {
                formattedOutput.Append("prefix ");
                formattedOutput.Append(outputString);
                formattedOutput.Append(" postfix");

                var output = formattedOutput.ToString();
                ExistingOutputMethodThatOnlyTakesAString(output);

                //Clear existing string to make ready for next iteration:
                formattedOutput.Remove(0, output.Length);
            }
        }
        stopWatch.Stop();

        Console.WriteLine("Option #1 ({1} iterations): {0}ms", stopWatch.ElapsedMilliseconds, __iterations);
            Console.ReadLine();
        stopWatch.Reset();

        //Option #2
        stopWatch.Start();
        for (var i = 0; i < __iterations; i++)
        {
            foreach (var outputString in outputStrings)
            {
                StringBuilder formattedOutputInsideALoop = new StringBuilder();

                formattedOutputInsideALoop.Append("prefix ");
                formattedOutputInsideALoop.Append(outputString);
                formattedOutputInsideALoop.Append(" postfix");

                ExistingOutputMethodThatOnlyTakesAString(
                   formattedOutputInsideALoop.ToString());
            }
        }
        stopWatch.Stop();

        Console.WriteLine("Option #2 ({1} iterations): {0}ms", stopWatch.ElapsedMilliseconds, __iterations);
    }

    private static void ExistingOutputMethodThatOnlyTakesAString(string s)
    {
        // do nothing
    }
} 

Опция 1 в этом сценарии незначительно быстрее, хотя опцию 2 легче считать и поддержать. Если Вы, оказывается, не выполняете эту операцию миллионы времен вплотную, я придерживался бы Опции 2, потому что я подозреваю, что опция 1 и 2 о том же при выполнении в единственном повторении.

Я сказал бы что опция № 2 если определенно более простой. С точки зрения производительности, походит на что-то, что необходимо было бы просто протестировать и видеть. Я предположил бы, что это не имеет достаточного значения для выбора менее простой опции.

Я думаю, что опция 1 была бы немного большей памятью, эффективной, поскольку новый объект не создается каждый раз. Однако GC делает довольно хорошее задание чистки ресурсов как в опции 2.

Я думаю, что можно попадать в прерывание преждевременной оптимизации (корень всего зла - Knuth). Ваш IO собирается взять намного больше ресурсов, чем строковый разработчик.

Я склоняюсь, идут с более ясной/более чистой опцией, в этой опции 2 случая.

Ограбить

1. Измерьте его
2. Предварительно выделите максимально близко тому, сколько памяти Вы думаете, что Вам будет нужно
3. Если скорость является Вашим предпочтением, то рассмотрите довольно прямую многопоточную переднюю сторону к середине, середина для окончания параллельного подхода (разверните разделение труда как требуется),
4. измерьте его снова

что более важно для Вас?

1. память

2. скорость

3. ясность