Constantes

Até agora, lidamos muito com variáveis e, como o nome indica, as variáveis sempre podem ser alteradas. O oposto disso é uma constante, introduzida em C# com a palavra-chave const. Ao declarar uma constante, você deve atribuir imediatamente um valor a ela e depois disso, nenhuma alteração pode ser feita no valor dessa constante. Isso é ótimo quando você tem um valor que nunca muda, e você quer ter certeza de que ele não é manipulado pelo seu código, mesmo por acidente.

Você encontrará muitas constantes no próprio framework, por exemplo na classe Math, onde uma constante para PI foi definida:

Console.WriteLine(Math.PI);

Mas, claro, a parte interessante é declarar algumas constantes próprias. Uma constante pode ser definida no escopo de um método, assim:

static void Main(string[] args)
{
    const int TheAnswerToLife = 42;
    Console.WriteLine("The answer to life, the universe and everything: " +  TheAnswerToLife);
}

No entanto, a maioria das constantes é declarada no nível da classe, para que possam ser acessadas (mas não alteradas, é claro) de todos os métodos da classe e até mesmo fora da classe, dependendo da visibilidade. Uma constante funcionará como um membro estático da classe, o que significa que você pode acessá-la sem instanciar a classe. Com isso em mente, vamos tentar um exemplo completo onde duas constantes são definidas - uma constante privada e pública:

using System;

namespace Constants
{
    class Program
    {
    static void Main(string[] args)
    {
        Console.WriteLine("The fake answer to life: " + SomeClass.TheFakeAnswerToLife);
        Console.WriteLine("The real answer to life: " +  SomeClass.GetAnswer());
    }
    }

    class SomeClass
    {
    private const int TheAnswerToLife = 42;
    public const int TheFakeAnswerToLife = 43;

    public static int GetAnswer()
    {
        return TheAnswerToLife;
    }
    }
}

Observe como eu defino uma classe (SomeClass) com duas constantes. O primeiro é privado, portanto só pode ser acessado da própria classe, mas o outro é público. Assim, em nosso código principal do programa, eu acesso as duas constantes de maneira diferente - primeiro diretamente, já que a resposta falsa está disponível publicamente e, em segundo lugar, com a ajuda do método GetAnswer().

Quais tipos podem ser usados como constantes?

Como as constantes devem ser declaradas imediatamente e não podem ser alteradas posteriormente, o valor atribuído a uma constante deve ser uma expressão constante e o compilador deve poder avaliar o valor já em tempo de compilação. Isso significa que números, valores booleanos e strings podem ser usados muito bem para uma constante, enquanto, por exemplo, um objeto DateTime não pode ser usado como uma constante.

Como o compilador precisa saber o valor imediatamente, isso também significa que existem algumas limitações para o que você pode fazer ao definir o valor. Por exemplo, estes são exemplos perfeitos do que você PODE fazer:

const int a = 10;  
const float b = a * 2.5f;

const string s1 = "Hello, world!";  
const string s2 = s1 + " How are you?";

Por outro lado, você não pode usar o resultado de uma chamada de método ou um membro de classe que não seja constante, uma vez que estas não são expressões constantes. Aqui vem alguns exemplos do que você NÃO PODE fazer:

// NOT possible:
const int a = Math.Cos(4) * 2;
// Possible:
const string s1 = "Hello, world!";
// NOT possible:
const string s2 = s1.Substring(0, 6) + " Universe";

A diferença está no que o compilador pode saber quando alcança seu código, por exemplo, números, cadeias de caracteres e outras constantes, em contraste com o que deve ser executado para obter o valor.

Uma alternativa constante: o campo readonly

Se você estiver procurando por uma versão ligeiramente menos restritiva de uma constante de classe, convém dar uma olhada na palavra-chave readonly . Ele não está disponível no nível do método, mas pode ser usado no nível de classe, para definir um campo que só pode ser modificado durante a declaração ou a execução do método construtor da classe. Portanto, assim que o objeto estiver disponível para uso, o campo readonly terá o mesmo valor para sempre e não poderá ser modificado pelo usuário. Vamos experimentar:

class SomeClass
{
    private readonly DateTime rightNow;
    public readonly DateTime later = DateTime.Now.AddHours(2);

    public SomeClass()
    {
    this.rightNow = DateTime.Now;
    }
}

Então, temos dois campos readonly: o primeiro é privado, o segundo é público (geralmente temos propriedades para isso, mas tenha comigo aqui). O primeiro é declarado sem um valor (podemos fazer isso com campos readonly, diferentemente das constantes), enquanto o outro é inicializado imediatamente. Você também notará que estamos usando a classe DateTime como o tipo de dados e atribuímos um valor não constante a ela. Em outras palavras, fazemos muitas coisas que não podemos fazer com constantes, tornando os campos readonly uma boa alternativa às constantes.

Observe como eu atribuo um valor ao campo rightNow no construtor da classe SomeClass. Como já foi mencionado, esta é a última chance de atribuir um valor a um campo readonly. Depois disso, se você estiver em um método dentro ou fora da classe de definição, você receberá um erro de compilação se tentar atribuir um valor a um campo readonly.

Resumo

Uma constante pode ser definida dentro do escopo de um método ou no nível de classe. Ele permite que você defina um valor que já é conhecido em tempo de compilação e que não pode ser alterado mais tarde. Tipos típicos usados para constantes são números inteiros, flutuantes, cadeias de caracteres e booleanos. Se você está procurando mais flexibilidade, tente o campo readonly, conforme descrito acima.