“Correção const” em C #

Question

O ponto de const-exactidão é para ser capaz de proporcionar uma vista de um exemplo, que não podem ser alterados pelo utilizador. O compilador suporta esta apontando quando você quebra constness de dentro de uma função const, ou tentar usar uma função não-const de um objeto const. Então, sem copiar a abordagem const, existe uma metodologia que posso usar em C # que tem os mesmos fins?

Estou ciente de imutabilidade, mas que realmente não transitar para recipiente objetos para citar apenas um exemplo.

Answer 1

Eu me deparei com esta questão muitas vezes demasiado e acabou usando interfaces.

Eu acho que é importante para deixar cair a ideia de que C # é qualquer forma, ou até mesmo uma evolução do C ++. Eles são duas línguas diferentes que partilham quase a mesma sintaxe.

Eu costumo expressar 'const correção' em C #, definindo um read-only visualizar de uma classe:

public interface IReadOnlyCustomer
{
    String Name { get; }
    int Age { get; }
}

public class Customer : IReadOnlyCustomer
{
    private string m_name;
    private int m_age;

    public string Name
    {
        get { return m_name; }
        set { m_name = value; }
    }

    public int Age
    {
        get { return m_age; }
        set { m_age = value; }
    }
}

Answer 2

Para obter o benefício de const-loucura (ou pureza em termos de programação funcional), você precisará projetar suas classes de uma maneira que eles são imutáveis, assim como a classe String de c # é.

Esta abordagem é muito melhor do que apenas marcar um objeto como somente leitura, uma vez que com classes imutáveis ??você pode passar dados ao redor facilmente em ambientes multitarefa.

Answer 3

Eu só queria nota para você que muitos dos recipientes System.Collections.Generics ter um método AsReadOnly que vai lhe dar de volta uma coleção imutável.

Answer 4

C # não tem essa característica. Você pode passar argumentos por valor ou por referência. própria referência é imutável, a menos que você especificar ref modificador. Mas os dados referenciado não é imutável. Então, você precisa ter cuidado se você quer evitar efeitos colaterais.

MSDN:

Passando parâmetros

Answer 5

Interfaces são a resposta, e são realmente mais poderoso do que "const" em C ++. const é um one-size-fits-all solução para o problema onde "const" é definido como "faz membros não programar ou chamar algo que os membros conjuntos". Isso é um bom atalho para const-ness em muitos cenários, mas não todos eles. Por exemplo, considere uma função que calcula um valor com base em alguns membros, mas também armazena em cache os resultados. Em C ++, que é considerado não-const, embora do ponto de vista do usuário é essencialmente const.

Interfaces dar-lhe mais flexibilidade na definição do subconjunto específico de capacidades que você deseja fornecer de sua classe. Quer const-ness? Basta fornecer uma interface com nenhum método de mutação. Quer permitir que definir algumas coisas, mas não outros? Fornecer uma interface com apenas esses métodos.

Answer 6

Concordo com alguns dos outros olham para usar readonly campos que você inicializar no construtor, para criar objetos imutáveis.

    public class Customer
    {
    private readonly string m_name;
    private readonly int m_age;

    public Customer(string name, int age)
    {
        m_name = name;
        m_age = age;
    }

    public string Name
    {
        get { return m_name; }
    }

    public int Age
    {
        get { return m_age; }
    }
  }

Alternativamente, você pode também adicionar escopo de acesso nas propriedades, ou seja, get público e conjunto protegido?

    public class Customer
    {
    private string m_name;
    private int m_age;

    protected Customer() 
    {}

    public Customer(string name, int age)
    {
        m_name = name;
        m_age = age;
    }

    public string Name
    {
        get { return m_name; }
        protected set { m_name = value; }
    }

    public int Age
    {
        get { return m_age; }
        protected set { m_age = value; }
    }
  }

Answer 7

• O const palavra-chave pode ser usada para constantes de tempo de compilação, como tipos primitivos e strings
• O somente leitura palavra-chave pode ser usada para constantes de tempo de execução, tais como tipos de referência

O problema com somente de leitura é que só permite a referência (ponteiro) ser constante. A coisa referenciada (apontado) ainda pode ser modificado. Esta é a parte mais complicada, mas não há maneira de contornar isso. Para implementar os objectos constantes tornando-os não expor quaisquer métodos mutáveis ??ou propriedades, mas isso é estranho.

Veja também Effective C #: 50 maneiras específicas para melhorar seu C # (item 2 -. Prefere somente leitura para const)