С# исключение объявления переменной

Предположим, что у меня есть такой код:

public string SomeMethod(int Parameter)
{
  string TheString = "";

  TheString = SomeOtherMethod(Parameter);

  return TheString;
}

Конечно, этот код эквивалентен этому:

public string SomeMethod(int Parameter)
{
  return SomeOtherMethod(Parameter);
}

Я думаю, что первая версия более читаема и что я пишу свой код, даже подумал, что я использую переменную, когда знаю, что могу ее избежать. Мой вопрос заключается в следующем: компилятор компилирует код таким же образом (т.е. такую же производительность) или второй вариант действительно лучше с точки зрения производительности.

Спасибо.

Ответы

Ответ 1

Я бы сказал, что первая форма менее читаема и содержит избыточный инициализатор. Зачем инициализировать переменную "", если вы собираетесь дать ей другое значение? По крайней мере, измените его на:

public string SomeMethod(int parameter)
{
  string returnValue = SomeOtherMethod(parameter);    
  return returnValue;
}

или если вы действительно хотите отделить объявление от инициализации:

public string SomeMethod(int parameter)
{
  string returnValue;
  returnValue = SomeOtherMethod(parameter);    
  return returnValue;
}

(Обратите внимание, что я также скорректировал имя, чтобы следовать соглашениям об именах .NET и дать более значимое имя локальной переменной - "TheString" не имеет никакого полезного значения.)

Вы действительно не увидите никаких проблем с производительностью при использовании локальной переменной, но я действительно рекомендую вам подумать о читаемости. В чем цель локальной переменной здесь? Вы предположительно описываете метод как: "Возвращает результат вызова SomeOtherMethod с заданным параметром" - в этот момент однострочная версия реализует именно это описание.

Ответ 2

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

public string SomeMethod(int Parameter)
{
    string result;
    result = SomeOtherMethod(Parameter);
    return result;
}

Я не уверен, что переписывание кода таким образом делает его более читаемым, но это означает, что вы можете добавить точку останова и увидеть значение result до возвращения метода. Это может быть полезно при отладке.

Обратите внимание, что вы можете комбинировать первую и вторую строки и все еще получать это преимущество:

public string SomeMethod(int Parameter)
{
    string result = SomeOtherMethod(Parameter);
    return result;
}

Я думаю, что эта последняя версия хорошо читаема и легко отлаживается.

Ответ 3

Ответ уже опубликован, хотя позвольте мне дать другую попытку:

Есть 3 вещи, которые вы ищете:

Считываемость, производительность, полезность (например, отладка, ведение журнала и т.д.)

1. Читаемость несколько относительна. Что Эрик Липперт/Джон Скит находит что-то более читаемым, то же самое не будет применимо ко мне. Все больше и больше вы код, многие вещи и ваша перспектива изменится в сторону просмотра кода.

Оба варианта, которые вы дали, являются читаемыми, для меня второй - более читаемым.

2. Производительность. В первом выборе, поскольку вы можете мне знать о неизменности строки, что если вы повторно инициализируете строку, она не очистит более раннее имя (интернирование) и он создаст новую строку, и переменная укажет на нее.

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

3. Отладка перспективы: вы хотите иметь локальную переменную, если ищете этот материал.