Может ли кто-нибудь сказать, что является точкой константы в С#?
Например, в чем преимущество выполнения
const int months = 12;
в отличие от
int months = 12;
Я получаю, что константы не могут быть изменены, но почему бы не просто... не изменить его значение после его инициализации?
Если компилятор знает, что значение является постоянным и никогда не изменится, оно может скомпилировать значение непосредственно в вашей программе.
Если вы объявляете pi константой, то каждый раз, когда она видит pi / 2, компилятор может выполнить вычисление и вставить 1.57... непосредственно в скомпилированный код. Если вы объявляете pi как переменную, то каждый раз, когда ваша программа использует pi / 2, компьютер должен будет ссылаться на переменную pi и умножать ее на 0,5, что явно медленнее.
Я также должен добавить, что С# имеет readonly, который предназначен для значений, которые компилятор не может вычислить, но которые не могут меняться в течение всего времени выполнения вашей программы. Например, если вы хотите константу ProgramStartTime, вам нужно объявить ее readonly DateTime ProgramStartTime = DateTime.Now, потому что она должна быть оценена при запуске программы.
Наконец, вы можете создать свойство только для чтения, предоставив ему геттер, но не установщик, например:
int Months { get { return 12; } }, но, будучи свойством, он не должен иметь одинаковое значение каждый раз, когда вы его читаете, например:
int DaysInFebruary { get { return IsLeapYear ? 29 : 28 } }
Разница между "не может измениться" и "не изменится" только реально становится очевидной, когда получается одна из следующих ситуаций:
Очень похожие вопросы возникают при разговоре о доступности данных. Идея состоит в том, что вы хотите, чтобы ваш код обеспечивал такую гибкость, как вы намереваетесь, потому что иначе кто-то (возможно, вы) придет и сделает то, чего вы не намеревались, что приводит к ошибкам!
Если вы никогда не ошибаетесь, никто в какой-либо команде, с которой вы работаете, никогда не ошибается, вы никогда не забудете точную цель переменной, которую вы определили, даже после возврата кода, который вы не просматривали в течение нескольких месяцев или лет, и вы и все, с кем работаете, 100% надежно узнаете, понимаете и следуете своему намерению никогда не изменять значение const, если вы не потрудились использовать встроенную конструкцию языка, которая четко указывает и обеспечивает стабильность, то нет, нет точка.
Если какая-либо из этих вещей когда-либо оказывается не такой, то точка.
Что касается меня, я считаю, что даже когда я нахожусь в моем самом ясном, помня, что более семи вещей сразу почти невозможно, поэтому я возьму всю помощь, которую я смогу предотвратить, особенно когда стоимость - одно ключевое слово. Если вы умнее меня, и вам никогда не придется работать в команде с кем-то менее умным, чем с вами, тогда делайте все, что захотите.
В некоторых случаях могут быть некоторые оптимизации компилятора, которые могут быть выполнены на основе константы (постоянная сворачивание, для одной, которая сворачивает выражения, состоящие из констант во время компиляции). Но обычно это не главное.
Имейте в виду, что вы не единственный человек, использующий значение. Вы не только не можете изменить его, но никто не использует ваш код (например, в библиотеке), это может изменить его.
И обозначение его как константы также делает ваше намерение понятным.
Что это. Вы говорите компилятору, что он никогда не может измениться, и компилятор может оптимизировать гораздо лучше, зная, что он неизменен.
Использование констант Программисты имеют преимущество Чтения по фактическому значению, например
const double PI = 3.14159;
Он также ускоряет вычисление по сравнению с переменными путем вставки значений во время компиляции и не выводится из области регистров/памяти.
По нескольким причинам:
Объявление значения 'const' приводит компилятор в игру, чтобы помочь вам обеспечить соблюдение личной дисциплины, не допуская никаких изменений этого значения.
Кроме того, он будет ловить неожиданные ошибки из-за побочных эффектов передачи значения (которое вы собираетесь рассматривать как константа) в метод, который принимает параметр "ref" и может неожиданно изменить значение неожиданно.
Строго говоря, "const" не требуется. Например, у Python нет ни "const", ни "private"; вы указываете свое намерение с помощью соглашения об именах из THIS_IS_A_CONSTANT и _this_is_private.
С#, однако, имеет философию проектирования ловушек ошибок во время компиляции, а не время выполнения.
Все о читаемости, различной семантике для программиста верно, и вы должны знать все это.
Но константы в С# (скорее в .net) имеют очень разную семантику (в терминах реализации) по сравнению с обычными переменными.
Поскольку постоянное значение никогда не изменяется, константы всегда считаются частью определяющий тип. Другими словами, константы всегда считаются статическими членами, а не членов экземпляра. Определение константы вызывает создание метаданных. Когда код ссылается на постоянный символ, компиляторы вставляют значение в испускаемый код промежуточного языка (IL).
Эти ограничения означают, что константы не имеют хорошей истории с версией перекрестной сборки, поэтому вы должны использовать их только тогда, когда знаете, что значение символа никогда не изменится.
"Точка" - это то, что вы можете использовать одну переменную масштаба программы и иметь только одно пятно для ее изменения.
Представьте, если вы делали видеоигру, которая полагалась на знание FPS (кадров в секунду) в 100 различных файлах кода. Поэтому притворитесь, что FPS было 50... и у вас было число "50" во всех этих файлах и функциях... тогда вы понимаете, что хотите сделать это 60 FPS... вместо того, чтобы менять эти 100 файлов, вы просто измените это:
const int FRAMES_PER_SECOND = 60;
и в этих файлах/функциях вы должны использовать переменную FRAMES_PER_SECOND.
Кстати, это не имеет ничего общего с константами С#... в тоннах языков.
Это пример явного вашего намерения.
Если вы намерены изменить значение, не используйте 'const'. Если вы не собираетесь изменять значение, используйте "const".
Таким образом, как компилятор, так и сторонняя сторона (или самостоятельно, если вы прочтете свой код через долгое время), могут знать, что вы намеревались. Если вы или кто-то ошибаетесь при изменении значения, компилятор может его обнаружить.
И вообще, использовать 'const' необязательно. Если вы думаете, вы можете обрабатывать "постоянство" самостоятельно (не желая компилятора обнаруживать ошибку), тогда не используйте "const"; -).
Вы должны определить переменную как "const", когда знаете, что значение этого параметра останется постоянным через ваше приложение. Поэтому, как только вы определяете константу, это значение должно быть определено во время компиляции, и это значение будет сохранено в метаданных сборки. Некоторые более важные моменты abt Const:
Из-за этого вложения значения в метаданные, когда кто-то меняет значение const (в сборке, где определяется константа) из-за версии или какого-либо другого требования то пользователь dll должен перекомпилировать свою собственную сборку. И эту проблему можно избежать, используя ключевое слово "readonly".
Одним из правил, которым следуют многие программисты, является: Никогда не перекодируйте любые переменные/кроме 0. это означает, что вместо выполнения
for(int i=0; i<100; i++) {}
должен делать
const loopCount = 100;
....
for (int i=0; i<loopCount; i++) {}
Я думаю, что использование const является хорошей причиной для замены этого. И действительно, есть еще много причин для этого: