В чем разница между const и readonly в C#?

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

Это объясняет это. Резюме: const должна быть инициализирована во время объявления, readonly может быть инициализирован в конструкторе (и, следовательно, иметь другое значение в зависимости от используемого конструктора).

Обновлено: см. Gishu gotcha выше для тонкой разницы

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

Эрик Липперт из команды C# имеет Дополнительная информация по различным типам неизменяемости.

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

Помимо очевидной разницы в

• необходимость объявления значения во время определения для const VS readonly значения могут вычисляться динамически, но должны быть назначены до выхода из конструктора ... после этого он замораживается.
• 'const неявно являются static. Для доступа к ним используется нотация ClassName.ConstantName.

Есть небольшая разница. Рассмотрим класс, определенный в AssemblyA.

public class Const_V_Readonly
{
  public const int I_CONST_VALUE = 2;
  public readonly int I_RO_VALUE;
  public Const_V_Readonly()
  {
     I_RO_VALUE = 3;
  }
}

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

• в случае значения const это похоже на поиск-замену, значение 2 «запекается» в IL AssemblyB. Значит, если завтра обновлю I_CONST_VALUE до 20 в будущем. У AssemblyB будет еще 2, пока я его не перекомпилирую.
• в случае значения readonly это похоже на ref для ячейки памяти. Значение не запекается в IL AssemblyB. Это означает, что при обновлении области памяти AssemblyB получает новое значение без перекомпиляции. Итак, если I_RO_VALUE обновлен до 30, вам нужно только собрать AssemblyA. Перекомпилировать всех клиентов не нужно.

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

public const int CM_IN_A_METER = 100;

Но если у вас есть константа, которая может измениться (например, относительно точности) ... или если вы сомневаетесь, используйте readonly.

public readonly float PI = 3.14;

Обновление: Аку нужно упомянуть, потому что он первым указал на это. Также мне нужно подключить там, где я это узнал .. Эффективный C# - Билл Вагнер

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

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

Чтобы добавить, readonly для ссылочных типов делает только ссылку только для чтения, а не для значений. Например:

public class Const_V_Readonly
{
  public const int I_CONST_VALUE = 2;
  public readonly char[] I_RO_VALUE = new Char[]{'a', 'b', 'c'};

  public UpdateReadonly()
  {
     I_RO_VALUE[0] = 'V'; //perfectly legal and will update the value
     I_RO_VALUE = new char[]{'V'}; //will cause compiler error
  }
}

Одно дело добавить к тому, что люди сказали выше. Если у вас есть сборка, содержащая значение только для чтения (например, только для чтения MaxFooCount = 4;), вы можете изменить значение, которое видят вызывающие сборки, отправив новую версию этой сборки с другим значением (например, только для чтения MaxFooCount = 5;)

Но с константой он будет добавлен в код вызывающей стороны при компиляции вызывающей стороны.

Если вы достигли этого уровня владения C#, вы готовы к книге Билла Вагнера «Эффективный C#: 50 конкретных способов улучшить свой C#». Что подробно отвечает на этот вопрос (и на 49 других вещей).

Ключевое отличие состоит в том, что Const - это C-эквивалент #DEFINE. Номер буквально заменяется на прекомпилятор. Только чтение фактически рассматривается как переменная.

Это различие особенно актуально, когда у вас есть проект A, зависящий от общедоступной константы из проекта B. Предположим, что общедоступная константа изменяется. Теперь ваш выбор const / readonly повлияет на поведение в проекте A:

Константа: проект A не улавливает новое значение (если, конечно, он не перекомпилирован с новой константой), потому что он был скомпилирован с подставленными константами.

ReadOnly: Project A всегда будет запрашивать у проекта B значение переменной, поэтому он получит новое значение общедоступной константы в B.

Честно говоря, я бы рекомендовал вам использовать только чтение почти для всего, кроме действительно универсальных констант (например, Pi, Inches_To_Centimeters). Для всего, что может измениться, я советую использовать только чтение.

Надеюсь это поможет, Алан.

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

Пример:

public static class Text {
  public const string ConstDescription = "This can be used.";
  public readonly static string ReadonlyDescription = "Cannot be used.";
}

public class Foo 
{
  [Description(Text.ConstDescription)]
  public int BarThatBuilds {
    { get; set; }
  }

  [Description(Text.ReadOnlyDescription)]
  public int BarThatDoesNotBuild {
    { get; set; }
  }
}

Еще один Попался.

Поскольку const действительно работает только с базовыми типами данных, если вы хотите работать с классом, вы можете почувствовать себя «вынужденным» использовать ReadOnly. Однако остерегайтесь ловушек! ReadOnly означает, что вы не можете заменить объект другим объектом (вы не можете сделать так, чтобы он ссылался на другой объект). Но любой процесс, имеющий ссылку на объект, может изменять значения внутри объекта!

Так что не заблуждайтесь, думая, что ReadOnly подразумевает, что пользователь не может ничего изменить. В C# нет простого синтаксиса, чтобы предотвратить изменение внутренних значений класса (насколько мне известно).

Один из членов команды в нашем офисе дал следующие инструкции о том, когда использовать const, static и readonly:

• Используйте const, когда у вас есть переменная типа, которую вы можете знать во время выполнения (строковый литерал, int, double, enums, ...), что вы хотите, чтобы все экземпляры или потребители класса имели доступ к тому месту, где значение не должно изменяться.
• Используйте статический, когда у вас есть данные, к которым вы хотите, чтобы все экземпляры или потребители класса имели доступ к тому месту, где значение может изменяться.
• Используйте статические только для чтения, когда у вас есть переменная типа, которую вы не можете знать во время выполнения (объекты), что вы хотите, чтобы все экземпляры или потребители класса имели доступ к тому месту, где значение не должно изменяться.
• Используйте только чтение, если у вас есть переменная уровня экземпляра, известная вам во время создания объекта, которая не должна изменяться.

И последнее замечание: поле const статично, но обратное неверно.

Есть небольшая проблема с только для чтения. Поле только для чтения можно задать несколько раз в конструкторе (-ах). Даже если значение установлено в двух разных связанных конструкторах, оно все равно разрешено.

public class Sample {
    private readonly string ro;

    public Sample() {
        ro = "set";
    }

    public Sample(string value) : this() {
        ro = value; // this works even though it was set in the no-arg ctor
    }
}

Константы

• Константы по умолчанию статичны
• Они должны иметь значение во время компиляции (вы можете иметь, например, 3,14 * 2, но не можете вызывать методы)
• Может быть объявлено в функциях
• Копируются в каждую сборку, которая их использует (каждая сборка получает локальную копию значений)
• Может использоваться в атрибутах

Поля экземпляра только для чтения

• Должно быть установлено значение к моменту выхода из конструктора
• Оцениваются при создании экземпляра

Статические поля только для чтения

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

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

Резюме:

• Значение вашего свойства const устанавливается во время компиляции и не может быть изменено во время выполнения.
• Const не может быть помечен как статический - ключевое слово означает, что они статические, в отличие от полей только для чтения, которые могут.
• Константа не может быть ничем, кроме значений (примитивных) типов.
• Ключевое слово readonly отмечает поле как неизменяемое. Однако свойство можно изменить внутри конструктора класса.
• Ключевое слово readonly only также можно комбинировать со static, чтобы оно действовало так же, как const (по крайней мере на поверхности). Если посмотреть на ИЖ между двумя
• Поля const помечены как "буквальные" в IL, а только для чтения - "только для инициализации".

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

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

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

Еще одна проблема: значения, доступные только для чтения, могут быть изменены "хитрым" кодом через отражение.

var fi = this.GetType()
             .BaseType
             .GetField("_someField", 
                       BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(this, 1);

Могу ли я изменить частное наследуемое поле только для чтения в C# с помощью отражения?

const должен быть жестко запрограммированный, тогда как readonly может быть установить в конструкторе класса.

const: нигде нельзя поменять.

readonly: это значение можно изменить только в конструкторе. Невозможно изменить в обычных функциях.

Постоянный член определяется во время компиляции и не может быть изменен во время выполнения. Константы объявляются как поля с использованием ключевого слова const и должны быть инициализированы по мере объявления.

public class MyClass
{
    public const double PI1 = 3.14159;
}

Член readonly похож на константу в том смысле, что он представляет неизменное значение. Разница в том, что член readonly может быть инициализирован во время выполнения в конструкторе, а также может быть инициализирован по мере их объявления.

public class MyClass1
{
     public readonly double PI2 = 3.14159;

     //or

     public readonly double PI3;

     public MyClass2()
     {
         PI3 = 3.14159;
     }
}

const

• Их нельзя объявить как static (они неявно статичны)
• Значение константы оценивается во время компиляции
• константы инициализируются только при объявлении

только чтение

• Они могут быть либо уровнями экземпляра, либо статическими.
• Значение оценивается во время выполнения
• readonly может быть инициализирован в объявлении или кодом в конструкторе

Const и readonly похожи, но не совсем одинаковы. Поле const - это константа времени компиляции, что означает, что это значение может быть вычислено во время компиляции. Поле только для чтения включает дополнительные сценарии, в которых некоторый код должен быть запущен во время создания типа. После создания поле только для чтения не может быть изменено.

Например, члены const могут использоваться для определения таких членов, как:

struct Test
{
    public const double Pi = 3.14;
    public const int Zero = 0;
}

поскольку такие значения, как 3,14 и 0, являются константами времени компиляции. Однако рассмотрим случай, когда вы определяете тип и хотите предоставить несколько его готовых экземпляров. Например, вы можете определить класс Color и предоставить «константы» для общих цветов, таких как черный, белый и т. д. Это невозможно сделать с членами const, поскольку правые части не являются константами времени компиляции. Это можно сделать с помощью обычных статических членов:

public class Color
{
    public static Color Black = new Color(0, 0, 0);
    public static Color White = new Color(255, 255, 255);
    public static Color Red = new Color(255, 0, 0);
    public static Color Green = new Color(0, 255, 0);
    public static Color Blue = new Color(0, 0, 255);
    private byte red, green, blue;

    public Color(byte r, byte g, byte b) {
        red = r;
        green = g;
        blue = b;
    }
}

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

public class Color
{
    public static readonly Color Black = new Color(0, 0, 0);
    public static readonly Color White = new Color(255, 255, 255);
    public static readonly Color Red = new Color(255, 0, 0);
    public static readonly Color Green = new Color(0, 255, 0);
    public static readonly Color Blue = new Color(0, 0, 255);
    private byte red, green, blue;

    public Color(byte r, byte g, byte b) {
        red = r;
        green = g;
        blue = b;
    }
}

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

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

public class A
{
    public static const C = 0;
}

а другой разработчик написал код, основанный на A:

public class B
{
    static void Main() {
        Console.WriteLine(A.C);
    }
}

Теперь, может ли сгенерированный код полагаться на тот факт, что A.C является константой времени компиляции? То есть, можно ли просто заменить использование A.C значением 0? Если вы ответите на это «да», это означает, что разработчик A не может изменить способ инициализации A.C - это связывает руки разработчика A без разрешения. Если вы скажете «нет» на этот вопрос, то упустите важную оптимизацию. Возможно, автор A уверен, что A.C всегда будет нулем. Использование как const, так и readonly позволяет разработчику A указать намерение. Это улучшает поведение при управлении версиями, а также повышает производительность.

ReadOnly: значение будет инициализировано только один раз из конструктора класса. const: может быть инициализирован в любой функции, но только один раз

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

Помните: Для ссылочных типов в обоих случаях (статический и экземплярный) модификатор readonly только не позволяет вам назначить новую ссылку на поле. В частности, он не делает неизменяемым объект, на который указывает ссылка.

Дополнительные сведения см. В разделе Часто задаваемые вопросы по C# по этой теме: http://blogs.msdn.com/csharpfaq/archive/2004/12/03/274791.aspx

Существует заметная разница между полями const и readonly в C# .Net.

const по умолчанию статический и должен быть инициализирован постоянным значением, которое не может быть изменено позже. В конструкторах также не допускается изменение значения. Его нельзя использовать со всеми типами данных. Например, DateTime. Его нельзя использовать с типом данных DateTime.

public const DateTime dt = DateTime.Today;  //throws compilation error
public const string Name = string.Empty;    //throws compilation error
public readonly string Name = string.Empty; //No error, legal

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

class A
{
    public readonly int Id;

    public A(int i)
    {
        Id = i;
    }
}

Затем поле readonly может быть инициализировано конкретными мгновенными значениями, как показано ниже:

A objOne = new A(5);
A objTwo = new A(10);

Здесь экземпляр objOne будет иметь значение поля readonly как 5, а objTwo - 10. Что невозможно при использовании const.

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

Только чтение: Значение можно изменить через Ctor во время выполнения. Но не через функцию-член

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

CONST

1. Ключевое слово const можно применять к полям или локальным переменным
2. Мы должны назначить поле const во время объявления
3. Память не выделена, потому что значение const после компиляции встраивается в сам IL-код. Это похоже на поиск всех вхождений переменной const и замену ее значением. Таким образом, код IL после компиляции будет иметь жестко запрограммированные значения вместо константных переменных.
4. Константы в C# по умолчанию статические.
5. Значение постоянно для всех объектов.
6. Существует проблема управления версиями dll - это означает, что всякий раз, когда мы меняем общедоступную переменную или свойство const (на самом деле, теоретически это не должно изменяться), любая другая dll или сборка, использующая эту переменную, должна быть перестроена.
7. Только встроенные типы C# могут быть объявлены как постоянные
8. Поле Const не может быть передано как параметр ref или out

Только для чтения

1. Ключевое слово readonly применяется только к полям, а не к локальным переменным
2. Мы можем назначить поле только для чтения во время объявления или в конструкторе, а не в каких-либо других методах.
3. динамическая память выделена для полей только для чтения, и мы можем получить значение во время выполнения.
4. Только для чтения принадлежит созданному объекту, доступ к которому осуществляется только через экземпляр класса. Чтобы сделать его членом класса, нам нужно добавить ключевое слово static перед readonly.
5. Значение может отличаться в зависимости от используемого конструктора (поскольку принадлежит объекту класса).
6. Если вы объявляете непримитивные типы (ссылочный тип) как неизменяемые только для чтения, ссылка будет неизменной, а не содержащийся в ней объект.
7. Поскольку значение получается во время выполнения, проблем с управлением версиями dll с полями / свойствами только для чтения не возникает.
8. Мы можем передать поле только для чтения в качестве параметров ref или out в контексте конструктора.

Const: Абсолютное постоянное значение в течение срока службы приложения.

Только чтение: Его можно изменить во время работы.

• когда использовать const или readonly

  • const

    • Константа время компиляции: константа абсолютный, значение задается при объявлении, находится в самом коде IL

  • readonly

    • Константа время выполнения: может быть установлена ​​в конструкторе / init через файл конфигурации, то есть App.config, но после инициализации ее нельзя изменить