Это правильная ситуация, чтобы использовать константу?

Так что мой профессор отзывался о проекте, над которым я работал. Он установил несколько отметок для этого кода:

if (comboVendor.SelectedIndex == 0) {
  createVendor cv = new createVendor();
  cv.ShowDialog();
  loadVendors();
}

Это в выпадающем списке «обработчик изменения индекса». Он используется, когда пользователь хочет создать нового поставщика, моя опция top (индекс 0, который никогда не меняется) открывает диалоговое окно «Создать нового поставщика». Таким образом, содержимое моего поля со списком выглядит так:

Create New Vendor...
Existing Vendor
Existing Vendor 2
Existing Vendor 3

Его проблема с кодом первой строки:

if (comboVendor.SelectedIndex == 0)

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

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

Фактически правильный способ сделать это в C # - вообще не полагаться на порядок ComboItems .

public partial class MyForm : Form
{
    private readonly object VENDOR_NEW = new object();

    public MyForm()
    {
        InitializeComponents();
        comboVendor.Items.Insert(0, VENDOR_NEW);
    }

    private void comboVendor_Format(object sender, ListControlConvertEventArgs e)
    {
        e.Value = (e.ListItem == VENDOR_NEW ? "Create New Vendor" : e.ListItem);
    }

    private void comboVendor_SelectedIndexChanged(object sender, EventArgs e)
    {
        if(comboVendor.SelectedItem == VENDOR_NEW)
        {
            //Special logic for selecting "create new vendor"
        }
        else
        {
            //Usual logic
        }
    }
}

Порядок в поле со списком может измениться. Что, если вы добавите еще один параметр, например «Создать специального поставщика ...», перед вашим «Создать нового продавца ...»

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

Использование константы также более читабельно, чем литерал.

if (comboVendor.SelectedIndex == NewVendorIndex)

Большинство скомпилированных языков подставляют константу во время компиляции, поэтому нет снижения производительности.

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

Реальный ответ - то, что он выбрал это, чтобы преподать вам урок.

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

Я бы сказал, что он неплохо справляется.

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

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

Снимаю шляпу перед вашим профессором.

[...] моя верхняя опция (индекс 0, которая никогда не меняется) открывает диалоговое окно «Создать нового поставщика».

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

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

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

Я бы согласился Использование нуля здесь "магия". Представьте, что вы читаете этот код впервые. Вы не знаете, почему ноль особенный, а литерал ничего не говорит вам о том, почему ноль особенный. Если вместо этого вы сказали, if(comboVendor.SelectedIndex == CreateNewVendorIndex)то начинающему читателю становится совершенно ясно, что означает код.

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

Это крайняя позиция; реалистичной позицией было бы сказать, что использование литералов - это красный флаг, который указывает, что код может быть не таким ясным, как мог бы быть. Иногда это уместно.

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

То, что это никогда не изменится, является отличной причиной, чтобы сделать его постоянным . Вот почему константы называются константами; потому что они никогда не меняются.

и это не то, что вам нужно настроить.

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

Тот факт, что вы можете увидеть причину, по которой это может измениться в будущем, является хорошей причиной, чтобы не делать ее постоянной. Скорее это должно быть непостоянное целочисленное поле только для чтения. Константа должна быть величиной, которая гарантированно останется неизменной на все времена . Пи и атомный номер золота являются хорошими константами. Номера версий не являются; они меняют каждую версию. Цена на золото, очевидно, ужасная константа; это меняется каждую секунду. Делайте только постоянные вещи, которые никогда не изменятся .

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

Теперь мы подошли к сути вопроса.

Это, пожалуй, самая важная строка в вашем вопросе, поскольку она указывает на то, что у вас есть какое-то глубоко ошибочное понимание (1) памяти и (2) оптимизации. Вы в школе, чтобы учиться, и сейчас самое время получить правильное понимание основ. Можете ли вы объяснить подробно, почему вы считаете, что «держать в памяти один ноль»? Прежде всего, почему вы считаете, что оптимизация использования четырех байтов памяти в процессе с как минимум двумя миллиардами байтов адресуемой пользователем памяти имеет значение? Во-вторых, какой именно ресурс вы потребляете здесь ? Что вы подразумеваете под "памятью"?

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

Он прав. Вы правы. Ты не прав.

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

Как говорится, вы правы. В этом конкретном случае я действительно не думаю, что константа оправдана. Вы ищете первый элемент в списке, который всегда равен нулю. Это никогда не будет 23. Или -pi. Вы специально ищете ноль. Я действительно не думаю, что вам нужно загромождать код, делая его константой.

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

Я бы заменил на 0константу, чтобы прояснить смысл, например NewVendorIndex. Вы никогда не знаете, изменится ли ваш заказ.

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

Хорошее обучение для корпоративного мира? Вполне возможно.

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

Более распространенной практикой для комбинированного списка .NET является присвоение элементу «Выбрать ..» пустого значения, в то время как фактические элементы имеют значимые значения, а затем выполните:

if (string.IsNullOrEmpty(comboVendor.SelectedValue))

скорее, чем

if (comboVendor.SelectedIndex == 0)

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

Хотя его точка зрения хороша. Это может быть его способ познакомить вас с преимуществами констант:

1-Они защищают ваш код в некоторой степени от случайного вмешательства

2-Как @DeadMG говорит в своем ответе, что если во многих местах используется одно и то же литеральное значение, оно может ошибочно появиться с другим значением - поэтому константы сохраняют согласованность.

3-константы сохраняют тип, поэтому вам не нужно использовать что-то вроде 0F для обозначения нуля.

4-Для удобства чтения COBOL использует ZERO в качестве зарезервированного слова для нулевого значения (но также позволяет использовать буквальный ноль) - поэтому иногда полезно давать значение имени, например: (Источник: ms-Constants

class CalendarCalc
{
    const int months = 12;
    const int weeks = 52; //This is not the best way to initialize weeks see comment
    const int days = 365;

    const double daysPerWeek = (double) days / (double) weeks;
    const double daysPerMonth = (double) days / (double) months;
}

или как в вашем случае (как показано в ответе @Michael Krussel)

Вам нужно будет только ввести его в константу, если он имеет сложное происхождение или если он повторяется часто. Иначе буквальное в порядке. Поместить все в константу - это полное излишество.

На самом деле, как уже упоминалось, что если его позиция изменится? Что вы могли бы / должны сделать, это использовать код, а не полагаться на индекс.

Итак, когда вы создаете свой список выбора, он заканчивается как HTML

<select>
    <option value='CREATE'>Create New Vendor...</option>
    <option value='1'>Existing Vendor</option>
    <option value='2'>Existing Vendor 2</option>
    <option value='3'>Existing Vendor 3</option>
</select>

Затем вместо того, чтобы проверять selectedIndex === 0, убедитесь, что это значение CREATECODEбудет константным и использовалось бы как для этого теста, так и при создании списка выбора.

Я бы полностью избавился от этого. Просто поместите кнопку создания нового рядом со списком со списком. Дважды щелкните элемент в списке для редактирования или нажмите кнопку. Не используйте новую функциональность в поле со списком. Тогда магическое число удаляется совсем.

В общем, любое буквенное число в коде должно быть определено как константа, чтобы поместить контекст вокруг числа. Что значит ноль? В этом случае 0 = NEW_VENDOR. В других случаях это может означать что-то иное, поэтому для удобочитаемости и удобства сопровождения всегда полезно обрисовать контекст.

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

Причина, по которой я пишу, - обратиться к вашему комментарию по поводу «использования памяти». В C #, как и в большинстве языков, константы «сворачиваются» компилятором. Например, скомпилируйте следующую программу и проверьте IL. Вы обнаружите, что все эти цифры даже не попадают в IL, не говоря уже о памяти компьютера:

public class Program
{
    public static int Main()
    {
        const int a = 1000;
        const int b = a + a;
        const int c = b + 42;
        const int d = 7928345;
        return (a + b + c + d) / (-a - b - c - d);
    }
}

результирующий IL:

.method public hidebysig static 
    int32 Main () cil managed 
{
    .maxstack 1
    .locals init (
        [0] int32 CS$1$0000
    )

    IL_0000: nop
    IL_0001: ldc.i4.m1  // the constant value -1 to be returned.
    IL_0002: stloc.0
    IL_0003: br.s IL_0005

    IL_0005: ldloc.0
    IL_0006: ret
}

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

Связанный пункт: постоянное сворачивание применяется к строковым литералам. Многие считают, что такой вызов вызывает слишком много ненужной неэффективной конкатенации строк:

public class Program
{
    public static int Main()
    {
        const string a = "a";
        const string b = a + a;
        const string c = "C";
        const string d = "Dee";
        return (a + b + c + d).Length;
    }
}

Но проверьте IL:

IL_0000: nop
IL_0001: ldstr "aaaCDee"
IL_0006: callvirt instance int32 [mscorlib]System.String::get_Length()
IL_000b: stloc.0
IL_000c: br.s IL_000e
IL_000e: ldloc.0
IL_000f: ret

Итог: операторы в константных выражениях приводят к константным выражениям, а компилятор выполняет все вычисления; это не влияет на производительность во время выполнения.