Производительность выходного параметра С#

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

РЕДАКТИРОВАТЬ: Остальное в стороне, эффективно. Это действительно актуально только для больших типов значений, которых в любом случае следует избегать:)

Я не согласен с утверждением Конрада о том, что «возвращаемые значения для всех типов> 32 бит в любом случае обрабатываются аналогично или идентичным аргументам out на машинном уровне». Вот небольшое тестовое приложение:

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;

struct BigStruct
{
    public Guid guid1, guid2, guid3, guid4;
    public decimal dec1, dec2, dec3, dec4;
}

class Test
{
    const int Iterations = 100000000;

    static void Main()
    {
        decimal total = 0m;
        // JIT first
        ReturnValue();
        BigStruct tmp;
        OutParameter(out tmp);

        Stopwatch sw = Stopwatch.StartNew();
        for (int i=0; i < Iterations; i++)
        {
            BigStruct bs = ReturnValue();
            total += bs.dec1;
        }
        sw.Stop();
        Console.WriteLine("Using return value: {0}",
                          sw.ElapsedMilliseconds);

        sw = Stopwatch.StartNew();
        for (int i=0; i < Iterations; i++)
        {
            BigStruct bs;
            OutParameter(out bs);
            total += bs.dec1;
        }
        Console.WriteLine("Using out parameter: {0}",
                          sw.ElapsedMilliseconds);
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static BigStruct ReturnValue()
    {
        return new BigStruct();
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static void OutParameter(out BigStruct x)
    {
        x = new BigStruct();
    }
}

Результаты:

Using return value: 11316
Using out parameter: 7461

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

Не стесняйтесь критиковать тестовое приложение — возможно, я что-то упустил!

Не проблема производительности, а то, что возникло ранее - вы не можете использовать их с вариантностью в C# 4.0.

Лично я предпочитаю использовать out параметры в достаточном количестве в своем частном коде (т.е. внутри класса, имея метод, возвращающий несколько значений без использования отдельного типа), но стараюсь избегать их в общедоступный API, за исключением шаблона bool Try{Something}(out result).

Нет никаких последствий для производительности. out в основном то же самое, что и любая старая передача аргумента, с технической точки зрения. Хотя может показаться правдоподобным, что копируются огромные объемы данных (например, для больших структур), на самом деле это то же самое, что и для возвращаемых значений.

На самом деле возвращаемые значения для всех типов > 32 бит в любом случае обрабатываются так же, как out аргументы на машинном уровне.

Обратите внимание, что последний оператор не предполагает, что возвращаемое значение параметра == out в .NET. Бенчмарк Джона показывает, что это явно (и, к сожалению) не так. На самом деле, чтобы сделать его идентичным, оптимизация именованного возвращаемого значения используется в компиляторах C++. Что-то подобное потенциально может быть сделано в будущих версиях JIT для повышения производительности возврата больших структур (однако, поскольку большие структуры довольно редко встречаются в .NET, эта оптимизация может оказаться ненужной).

Однако (и с моими очень ограниченными знаниями сборки x86) возврат объектов из вызовов функций обычно влечет за собой выделение достаточного пространства в месте вызова, помещение адреса в стек и заполнение его путем копирования возвращаемого значения внутрь. Это в основном то же самое, что и out, только опускает ненужную временную копию значения, поскольку к целевой ячейке памяти можно получить прямой доступ.

Основной причиной отказа от параметров out является читаемость кода, а не производительность.

Для типов значений в любом случае нет реальной разницы (они всегда копируются), а для ссылочных типов это в основном то же самое, что и передача по ссылке.

В девяти случаях из десяти вам лучше создать свой собственный тупой класс записи, а не использовать параметр out — его проще читать и понимать, когда вы вернетесь к коду позже.

Out параметры передаются по ссылке. Таким образом, в стеке передается только указатель.

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

Использование параметра out не влияет на производительность. Параметр Out в основном является ссылочным параметром, поэтому и вызывающий, и вызываемый объект указывают на один и тот же участок памяти.