how - readonly c# const




Estático readonly vs const (10)

Eu li sobre campos const e static readonly . Nós temos algumas classes que contém apenas valores constantes. Usado para várias coisas no nosso sistema. Então, eu estou querendo saber se minha observação está correta:

Esses valores constantes devem sempre ser static readonly para tudo o que é público? E use somente const para valores internos / protegidos / privados?

O que você recomenda? Eu devo talvez não usar campos static readonly , mas sim usar propriedades talvez?


Const: Const nada mais é que "constante", uma variável cujo valor é constante, mas em tempo de compilação. E é obrigatório atribuir um valor a ele. Por padrão, uma const é estática e não podemos alterar o valor de uma variável const em todo o programa.

ReadOnly Estático: Um valor da variável do tipo Readonly Estático pode ser atribuído no tempo de execução ou atribuído em tempo de compilação e alterado no tempo de execução. Mas o valor dessa variável só pode ser alterado no construtor estático. E não pode ser alterado mais. Pode mudar apenas uma vez em tempo de execução

Referência: c-sharpcorner


A palavra-chave readonly é diferente da palavra-chave const . Um campo const só pode ser inicializado na declaração do campo. Um campo readonly pode ser inicializado na declaração ou em um construtor. Portanto, campos readonly podem ter valores diferentes dependendo do construtor usado. Além disso, enquanto um campo const é uma constante de tempo de compilação, o campo readonly pode ser usado para constantes de tempo de execução

Referência rápida e clara do MSDN aqui


Constantes são como o nome indica, campos que não mudam e são geralmente definidos estaticamente em tempo de compilação no código.

As variáveis ​​somente leitura são campos que podem mudar sob condições específicas.

Eles podem ser inicializados quando você os declara como uma constante, mas geralmente eles são inicializados durante a construção do objeto dentro do construtor.

Eles não podem ser alterados após a inicialização, nas condições mencionadas acima.

A leitura estática soa como uma escolha ruim para mim desde então, se ela é estática e nunca muda, então use-a public const, se ela puder mudar, ela não é uma constante e, dependendo das suas necessidades, você pode ler apenas uma variável regular.

Além disso, outra distinção importante é que uma constante pertence à classe, enquanto a variável somente leitura pertence à instância!


Este é apenas um complemento para as outras respostas. Não vou repeti-los (agora, quatro anos depois).

Existem situações em que um const e um non-const possuem semânticas diferentes. Por exemplo:

const int y = 42;

static void Main()
{
  short x = 42;
  Console.WriteLine(x.Equals(y));
}

imprime True , enquanto:

static readonly int y = 42;

static void Main()
{
  short x = 42;
  Console.WriteLine(x.Equals(y));
}

escreve False .

O motivo é que o método x.Equals tem duas sobrecargas, uma que aceita um short ( System.Int16 ) e outra que recebe um object ( System.Object ). Agora a questão é se um ou ambos se aplicam ao meu argumento.

Quando y é uma constante de tempo de compilação (literal), o caso const , torna-se importante que exista uma conversão implícita de int para short contanto que o int seja uma constante e desde que o compilador C # verifique se seu valor está dentro o alcance de um short (que 42 é). Veja Conversões Implícitas de Expressões Constantes na Especificação da Linguagem C #. Portanto, ambas as sobrecargas devem ser consideradas. A sobrecarga Equals(short) é preferida (qualquer short é um object , mas nem todos os object são short ). Então y é convertido em short e essa sobrecarga é usada. Então Equals compara dois de valor idêntico, e isso dá true .

Quando y não é uma constante, nenhuma conversão implícita de int para short existe. Isso porque, em geral, um int pode ser muito grande para caber em um short . (Uma conversão explícita existe, mas eu não disse Equals((short)y) , então isso não é relevante.) Vemos que apenas uma sobrecarga se aplica, a Equals(object) . Então, y é encaixotado para o object . Então Equals vai comparar um System.Int16 a um System.Int32 , e como os tipos de tempo de execução nem sequer concordam, isso produzirá false .

Concluímos que, em alguns casos (raros), alterar um membro do tipo const para um campo static readonly (ou o contrário, quando isso for possível) pode alterar o comportamento do programa.


Há uma pequena diferença entre os campos const e static readonly em C # .Net

const deve ser inicializado com valor em tempo de compilação.

const é por padrão estático e precisa ser inicializado com valor constante, que não pode ser modificado posteriormente. Não pode ser usado com todos os tipos de dados. Por ex DateTime. Não pode ser usado com o tipo de dados DateTime.

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

readonly pode ser declarado como estático, mas não é necessário. Não há necessidade de inicializar no momento da declaração. Seu valor pode ser atribuído ou alterado usando o construtor uma vez. Portanto, existe a possibilidade de alterar o valor do campo readonly uma vez (não importa, se é estático ou não), o que não é possível com const.


Minha preferência é usar const sempre que puder, o que, como mencionado acima, é limitado a expressões literais ou algo que não requer avaliação.

Se eu me aquecer contra essa limitação, então recuo para a leitura estática , com uma ressalva. Eu geralmente usaria uma propriedade estática pública com um getter e um campo readonly estático de backup como Marc menciona here .


Uma coisa a notar é const é restrita a tipos primitivos / valor (a exceção sendo strings)


const:

  1. valor deve ser dado mediante declaração
  2. compilar a constante de tempo

somente leitura:

  1. O valor pode ser dado na declaração ou durante o tempo de execução usando construtores. O valor pode variar dependendo do construtor usado.
  2. Correr tempo constante

public static readonly campos public static readonly são um pouco incomuns; propriedades public static (com apenas um get ) seriam mais comuns (talvez apoiadas por um campo private static readonly ).

const valores const são gravados diretamente no site de chamada; isso é de dois gumes:

  • é inútil se o valor for buscado em tempo de execução, talvez da configuração
  • se você mudar o valor de um const, você precisa reconstruir todos os clientes
  • mas pode ser mais rápido, pois evita uma chamada de método ...
  • ... que às vezes poderia ter sido embutido pelo JIT de qualquer maneira

Se o valor nunca irá mudar, então const está tudo bem - Zero etc fazem consts razoáveis; p Além disso, static propriedades static são mais comuns.


Const : os valores da variável const têm que definir junto com a declaração e depois disso não serão alterados. const são implicitamente estáticos, portanto, sem criar uma instância de classe, podemos acessá-los. isso tem um valor em tempo de compilação

ReadOnly : valores de variáveis ​​readonly que podemos definir ao declarar, bem como usar o construtor em tempo de execução. readonly variáveis ​​não podem acessar sem instância de classe.

Static readonly : valores de variáveis ​​readonly estáticos que podemos definir enquanto declaramos, assim como somente através de um construtor estático, mas não com qualquer outro construtor. Também podemos acessar essas variáveis ​​sem criar uma instância de classe (como variáveis ​​estáticas).

readonly estático será melhor escolha se tivermos que consumir as variáveis ​​em diferentes assemblies.Por favor, verifique os detalhes completos no link abaixo

https://www.stum.de/2009/01/14/const-strings-a-very-convenient-way-to-shoot-yourself-in-the-foot/







constants