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

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

Когда бы вы использовали один поверх другого?

+1240
источник поделиться
36 ответов
  • 1
  • 2

Помимо очевидного различия

  • необходимость объявлять значение во время определения для 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 "запекается" в AssemblyB IL. Это означает, что если завтра я I_CONST_VALUE до 20 в будущем. AssemblyB все еще будет иметь 2, пока я не перекомпилирую его.
  • в случае readonly для ref readonly значения, это как ref к ячейке памяти. Значение не запекается в AssemblyB IL. Это означает, что если ячейка памяти обновляется, AssemblyB получает новое значение без перекомпиляции. Поэтому, если I_RO_VALUE обновлен до 30, вам нужно только собрать AssemblyA. Все клиенты не должны быть перекомпилированы.

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

public const int CM_IN_A_METER = 100;

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

public readonly float PI = 3.14;

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

+1184
источник

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

+263
источник
другие ответы

Связанные вопросы


Похожие вопросы

Константы

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

Поля экземпляров Readonly

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

Статические поля readonly

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

Просто для добавления, 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
  }
}
+54
источник

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

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

+37
источник

const: Невозможно изменить где-либо.

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

+30
источник

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


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
    }
}
+25
источник

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

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

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

public class MyClass1
{
     public readonly double PI2 = 3.14159;

     //or

     public readonly double PI3;

     public MyClass2()
     {
         PI3 = 3.14159;
     }
}

Const

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

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

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

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

Эрик Липперт команды С# имеет больше информации о разных типах неизменяемости

+20
источник

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

Резюме:

  • Значение вашего свойства const устанавливается во время компиляции и не может меняться во время выполнения
  • Константа не может быть помечена как статическая - ключевое слово обозначает, что они являются статическими, в отличие от полей readonly, которые могут.
  • Const не может быть ничего, кроме значений (примитивных) типов
  • Ключевое слово readonly помечает поле как неизменяемое. Однако свойство может быть изменено внутри конструктора класса
  • Ключевое слово только для чтения можно также комбинировать со статикой, чтобы заставить его действовать так же, как const (по крайней мере на поверхности). Существует заметная разница, когда вы смотрите на IL между двумя
  • константные поля помечены как "буквальные" в IL, а readonly - "initonly",
+15
источник

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

Константа: Дефект статический. Значение не может быть изменено нигде (Ctor, Function, runtime etc no-where)

+9
источник

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

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

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

+8
источник

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

+6
источник

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

Пример:

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; }
  }
}
+5
источник

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

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

Последнее замечание: константное поле статично, но инверсия неверна.

+5
источник

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

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

+4
источник

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

public static readonly uint l1 = (uint) DateTime.Now.Ticks;
+4
источник

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

public static readonly uint timeStamp = (uint)DateTime.Now.Ticks;
+4
источник

Другой gotcha.

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

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

+3
источник

Значительная разница между полями const и readonly в С#.Net

const по умолчанию статический и должен быть инициализирован с постоянным значением, которое впоследствии не может быть изменено. Изменение значения также не допускается в конструкторах. Он не может использоваться со всеми типами данных. Для ex-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. Для ex -

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.

+3
источник

ПОСТ

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

ReadOnly

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

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

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

+2
источник

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

+2
источник

Constant

Нам нужно указать значение в поле const, когда оно определено. Затем компилятор сохраняет значение констант в метаданных сборки. Это означает, что константу можно определить только для примитивного типа типа boolean, char, byte и т.д. Константы всегда считаются статическими членами, а не членами экземпляра.

Readonly

Поля Readonly могут быть разрешены только во время выполнения. Это означает, что мы можем определить значение для значения, используя конструктор для типа, в котором объявлено поле. Проверка выполняется компилятором, что поля readonly не записываются каким-либо другим методом, кроме конструктора.

Подробнее о объясняется здесь в этой статье

+2
источник

Const:

Переменной, объявленной как const (read: constant), должно быть присвоено значение при объявлении, и это значение может не измениться позднее.

public const string ConnectionString = "YourConnectionString";

Значение в переменной const - это то, что называется значением времени компиляции.

Статическая:

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

    public class MyClass  {
       public static string MyMethod() { ... } 
}

Мы должны вызвать этот метод так:

var result = MyClass.MyMethod();

Readonly:

Поле только для чтения - это поле, в котором присваивание этому полю может происходить только как часть объявления класса или конструктора.

public class TestClass
{
    public readonly string ConnectionString = "TestConnection";

    public TestClass()
    {
        ConnectionString = "DifferentConnection";
    }

    public void TestMethod ()
    {
        ConnectionString = "NewConnection";//Will not compile
    }
}

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

+2
источник

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

+1
источник

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

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

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

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

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 отбрасывать его, возможно, путем замены значений черного и белого. Излишне говорить, что это вызовет ужас для других клиентов класса 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;
    }
}

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

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

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

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

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

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

+1
источник

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

+1
источник

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

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

Подробнее см. в разделе Часто задаваемые вопросы по С# на эту тему: http://blogs.msdn.com/csharpfaq/archive/2004/12/03/274791.aspx

+1
источник

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

+1
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос