Какой смысл постоянной в C #

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

Если что-то из этого окажется не так, то в этом суть.

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

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

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

Если вы объявляете pi константой, то каждый раз, когда он видит pi / 2 , компилятор может выполнить вычисление и вставить 1.57 ... непосредственно в скомпилированный код.Если вы объявите pi как переменную, то каждый раз, когда ваша программа будет использовать pi / 2 , компьютеру придется ссылаться на переменную pi и умножать ее на 0,5, что, очевидно, медленнее.

Я также должен добавить, что в C # есть readonly , который предназначен для значений, которые компилятор не может вычислить, но которые не могут измениться во время выполнения вашей программы. Например, если вам нужна константа ProgramStartTime , вам нужно будет объявить ее только для чтения DateTime ProgramStartTime = DateTime.Now , потому что она должна быть вычислена при запуске программы.

Наконец, вы можете создать свойство, доступное только для чтения, задав ему метод получения, но не установщик, например:

int Months {get {return 12; }} , но, будучи свойством, оно не обязательно должно иметь одно и то же значение каждый раз, когда вы его читаете, например:

int DaysInFeb February {get {return IsLeapYear? 29: 28}}

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

Кроме того, он выявляет неожиданные ошибки из-за побочных эффектов передачи значения (которое вы собираетесь рассматривать как константу) в метод, который принимает параметр 'ref' и может неожиданно изменить значение.

Разница между «не может измениться» и «не изменится» становится очевидной только тогда, когда возникает одна из следующих ситуаций:

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

Очень похожие вопросы возникают при разговоре о доступности данных. Идея состоит в том, что вы хотите, чтобы ваш код предоставлял ровно столько гибкости, сколько вы намереваетесь, потому что в противном случае кто-то (возможно, вы) придет и сделает что-то, чего вы не планировали, что приведет к ошибкам!

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

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

И отметив его как постоянное, вы также проясните ваше намерение.

Строго говоря, "const" не требуется. В Python, например, нет ни «const», ни «private»; вы указываете свое намерение в соответствии с соглашением об именах THIS_IS_A_CONSTANT и _this_is_private.

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

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

Но константы в C # (скорее, в .net) имеют совсем другую семантику (с точки зрения реализации) по сравнению с обычными переменными.

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

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

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

Представьте, что вы делаете видеоигру, которая полагается на знание FPS (кадров в секунду) в 100 различных файлах кода. Итак, представьте, что FPS был 50 ... и у вас было число "50" во всех этих файлах и функциях ... тогда вы понимаете, что хотели сделать его 60 FPS ... вместо того, чтобы изменять эти 100 файлов, вы просто измените это:

const int FRAMES_PER_SECOND = 60;

и в этих файлах / функциях вы должны использовать переменную FRAMES_PER_SECOND.

Между прочим, это не имеет ничего общего с C # ... константы существуют на множестве языков.

Вы должны определить переменную как "const", если вы знаете, что ее значение будет оставаться постоянным во всем приложении. Итак, как только вы определяете константу, ее значение должно быть определено во время компиляции, и это значение будет сохранено в метаданных сборки. Еще несколько важных моментов abt Const:

1. Константа может быть определена только для типов, которые ваш компилятор рассматривает как первичные типы.
2. Константы всегда считаются частью определяющего типа.
3. Они всегда считаются статическими членами.
4. Значения констант всегда встраиваются непосредственно в код, поэтому константы не требуют выделения памяти во время выполнения.

Из-за этого встраивания значения в метаданные, когда кто-то изменяет значение константы (в сборке, где константа определена) из-за управления версиями или какого-либо другого требования , тогда пользователь dll имеет перекомпилировать собственную сборку. И этой проблемы можно избежать с помощью ключевого слова readonly.

Это случай явного выражения вашего намерения.

Если вы намереваетесь изменить значение, не используйте 'const'. Если вы не собираетесь изменять значение, используйте 'const'.

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

В любом случае, использовать const не обязательно. Если вы думаете, что можете справиться с «постоянством» самостоятельно (не желая, чтобы компилятор обнаруживал ошибку), тогда не используйте «const» ;-).

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

for(int i=0; i<100; i++) {}

следует выполнять

const loopCount = 100;
....
for (int i=0; i<loopCount; i++) {}

​​Я думаю, что использование const - хорошая причина заменить это. И действительно, для этого есть гораздо больше причин:

1. Оптимизация для компилятора - память, производительность.
2. Скажите программисту, который следит за вашей работой, это ПОСТОЯННО
3. Если вам нужно провести рефакторинг, измените свое мнение в цифре, вы знаете, куда идти. И убедитесь, что никакие другие места в коде не повлияют на это.

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

const double PI = 3.14159;

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

По нескольким причинам:

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