Инициализировать поля класса в конструкторе или при объявлении?

Мои правила:

1. Не инициализируйте значения по умолчанию в декларации (null, false, 0, 0.0…).
2. Предпочитайте инициализацию в объявлении, если у вас нет параметра конструктора, изменяющего значение поля.
3. Если значение поля изменяется из-за параметра конструктора, поместите инициализацию в конструкторы.
4. Будьте последовательны в своей практике (самое важное правило).

Предполагая тип в вашем примере, определенно предпочитаю инициализировать поля в конструкторе. Исключительные случаи:

• Поля в статических классах / методах
• Поля набраны как static / final / et al.

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

Что, если бы я сказал вам, это зависит от обстоятельств?

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

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

В системе реального времени я сомневаюсь, нужна ли мне вообще переменная или константа.

А в C++ я часто почти не выполняю инициализацию в любом месте и перемещаю ее в функцию Init (). Почему? Что ж, в C++, если вы инициализируете что-то, что может вызвать исключение во время создания объекта, вы открываете себя для утечек памяти.

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

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

В C# это не имеет значения. Два приведенных вами примера кода совершенно эквивалентны. В первом примере компилятор C# (или это CLR?) Создаст пустой конструктор и инициализирует переменные, как если бы они были в конструкторе (в этом есть небольшой нюанс, который Джон Скит объясняет в комментариях ниже). Если конструктор уже существует, то любая инициализация "выше" будет перемещена в его верх.

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

Установка значения в объявлении дает небольшое преимущество в производительности. Если вы установите его в конструкторе, он фактически будет установлен дважды (сначала значение по умолчанию, затем сброс в ctor).

Семантика C# здесь немного отличается от Java. В C# присвоение в объявлении выполняется перед вызовом конструктора суперкласса. В Java это делается сразу после этого, что позволяет использовать this (особенно полезно для анонимных внутренних классов) и означает, что семантика двух форм действительно совпадает.

Если можете, сделайте поля окончательными.

Думаю, есть один нюанс. Однажды я совершил такую ​​ошибку: внутри производного класса я попытался «инициализировать при объявлении» поля, унаследованные от абстрактного базового класса. В результате существовало два набора полей, один из которых является «базовым», а другой - недавно объявленными, и мне потребовалось немало времени на отладку.

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

Есть много разных ситуаций.

Мне просто нужен пустой список

Ситуация ясная. Мне просто нужно подготовить свой список и предотвратить создание исключения, когда кто-то добавляет элемент в список.

public class CsvFile
{
    private List<CsvRow> lines = new List<CsvRow>();

    public CsvFile()
    {
    }
}

Я знаю ценности

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

public class AdminTeam
{
    private List<string> usernames;

    public AdminTeam()
    {
         usernames = new List<string>() {"usernameA", "usernameB"};
    }
}

или же

public class AdminTeam
{
    private List<string> usernames;

    public AdminTeam()
    {
         usernames = GetDefaultUsers(2);
    }
}

Пустой список с возможными значениями

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

public class AdminTeam
{
    private List<string> usernames = new List<string>();

    public AdminTeam()
    {
    }

    public AdminTeam(List<string> admins)
    {
         admins.ForEach(x => usernames.Add(x));
    }
}

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

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

Также существует вопрос согласованности со статической инициализацией поля, которая должна быть встроенной для лучшей производительности. В Руководстве по проектированию каркаса для Конструктор Дизайн говорится следующее:

✓ CONSIDER initializing static fields inline rather than explicitly using static constructors, because the runtime is able to optimize the performance of types that don’t have an explicitly defined static constructor.

«Рассмотреть» в этом контексте означает сделать это, если нет веской причины не делать этого. В случае полей статического инициализатора хорошей причиной будет то, что инициализация слишком сложна для встроенного кодирования.

Важно быть последовательным, но вот вопрос, который стоит задать себе: "У меня есть конструктор для чего-нибудь еще?"

Обычно я создаю модели для передачи данных, в которых сам класс ничего не делает, кроме работы как хранилище для переменных.

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

Итак, как говорили многие другие, это зависит от вашего использования. Будьте проще и не делайте ничего лишнего, что вам не нужно.

Рассмотрим ситуацию, когда у вас более одного конструктора. Будет ли инициализация отличаться для разных конструкторов? Если они будут одинаковыми, то зачем повторять для каждого конструктора? Это соответствует заявлению kokos, но может не иметь отношения к параметрам. Скажем, например, вы хотите сохранить флаг, который показывает, как был создан объект. Тогда этот флаг будет инициализироваться по-разному для разных конструкторов независимо от параметров конструктора. С другой стороны, если вы повторяете ту же инициализацию для каждого конструктора, вы оставляете возможность (непреднамеренно) изменить параметр инициализации в некоторых конструкторах, но не в других. Итак, основная концепция здесь заключается в том, что общий код должен иметь общее расположение и не может повторяться в разных местах. Поэтому я бы сказал, что всегда указывайте это в декларации, пока у вас не возникнет конкретная ситуация, когда это больше не работает для вас.

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

class MyGeneric<T>
{
    T data;
    //T data = ""; // <-- ERROR
    //T data = 0; // <-- ERROR
    //T data = null; // <-- ERROR        

    public MyGeneric()
    {
        // All of the above errors would be errors here in constructor as well
    }
}

И специальный метод инициализации универсального поля значением по умолчанию следующий:

class MyGeneric<T>
{
    T data = default(T);

    public MyGeneric()
    {           
        // The same method can be used here in constructor
    }
}

Когда вам не нужна логика или обработка ошибок:

• Инициализировать поля класса при объявлении

Когда вам нужна логика или обработка ошибок:

• Инициализировать поля класса в конструкторе

This works well when the initialization value is available and the initialization can be put on one line. However, this form of initialization has limitations because of its simplicity. If initialization requires some logic (for example, error handling or a for loop to fill a complex array), simple assignment is inadequate. Instance variables can be initialized in constructors, where error handling or other logic can be used.

От https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html.