Best Practice sobre o uso local do campo privado x Property

StackOverflow https://stackoverflow.com/questions/833047

Pergunta

Quando dentro de uma classe tem um fiels privadas e expor esse campo em uma propriedade pública, qual deles devo usar de dentro da classe?

Abaixo, você é um exemplo do que eu estou tentando descobrir. Deve manioulate Private Campo _Counter ou a propriedade Contador?

Test Public Class 

Private _Counter As Integer

Public Property Counter() As Integer
    Get
        Return _Counter
    End Get
    Set(ByVal value As Integer)
        _Counter = value
    End Set
End Property

Private Sub Dosomething()

    'What is the best practice?
    'Direct access to private field or property?

    'On SET
    _Counter += 1
    'OR
    Me.Counter += 1

    'On Get
    Console.WriteLine(_Counter)
    Console.WriteLine(Me.Counter)

End Sub

End Class

Obrigado antecipadamente pela ajuda. Edu

Foi útil?

Solução

Na minha opinião, usando um acessor público internamente é o excesso de encapsulamento: borra o código. Com essa abordagem, as operações de outra forma simples invocação acessores que pode conter uma lógica mais complexa, por isso é mais difícil de analisar o código das operações.

Na minha experiência de programação, eu raramente tinha uma situação em que ele iria ajudar muito. Em vez disso, eu prefiro acessar campos diretamente, e apenas se for realmente necessário, para abstrair o acesso criando um privada acessor, que pode ser usado tanto pelo acessor público e outras funções. O raciocínio é que, se você precisa anexar alguma lógica especial no acessor público, as chances são de que a lógica não pode ser a mesma para acesso interno.

Note-se também que a maioria das IDEs modernos (como o Eclipse) permitem ver imediatamente todas as referências a um campo particular, e refatorar o código para usar uma função em vez de um acesso directo.

Outras dicas

IMO você deve estar usando o Propriedade acessor sempre que possível. Isso é porque você não tem que se preocupar com qualquer lógica interna , que pode estar disponível quando você tem um uma propriedade.

Um bom exemplo de onde isso acontece é no código por trás em um Linq DataContext.

verificar isso ... 

[Column(Storage="_ReviewType", DbType="TinyInt NOT NULL")]
public byte ReviewType
{
    get
    {
        return this._ReviewType;
    }
    set
    {
        if ((this._ReviewType != value))
        {
            this.OnReviewTypeChanging(value);
            this.SendPropertyChanging();
            this._ReviewType = value;
            this.SendPropertyChanged("ReviewType");
            this.OnReviewTypeChanged();
        }
    }
}

Observe tudo o que a lógica do 'setter'?

É por isso que é importante começar a entrar a prática de invocar os seus propriedades em vez de campos, IMO.

Obrigado a todos pelas respostas e sugestões.

Depois de considerar todas as sugestões aqui além de outras pesquisas é a minha impressão de que para esta situação no campo privado contra Assessor é mais uma escolha pessoal. Então, basicamente, o mais importante é que não importa o que você escolhe ser consistente.

Dito; minha regra pessoal é inclinando-se para o seguinte:

  1. Acesse seus campos particulares diretamente.

  2. Se acessores acessando usar a palavra-chave ME. para melhorar a legibilidade

  3. Use o acessor somente se implementa a lógica lógica vital que também se aplica ao acesso privado. Desta forma, você sabe que se você estiver usando o acessor é porque não é "algo mais a ele"

  4. Evite o uso de campos protegidos. As classes derivadas devem sempre usar o acessor, nunca mais o acesso directo ao campo.

Deixe-me saber o que você pensa.

SideNote:

Depois disto, eu acho que está faltando um novo escopo para os campos de nível de classe. A palavra-chave como “restrito”, onde este campo somente pode ser acessado a partir de sua getter / setter. Desta forma, você sempre acessar diretamente os campos privados, mas se você precisa se certificar de determinado campo só pode ser acessado pelo seu assessor que altere o privado como Restrito. (Como sobre "Restricted, RestrictedRead e RestrictedWrite"?)

Eu prefiro usar a propriedade sempre que possível. Isso lhe dá a flexibilidade no futuro para modificar o que a propriedade retorna / sets sem ter que passar e encontrar todos os locais que estavam usando a variável privada.

Use o campo privado, porque você não está fazendo algo em específico no setter.

Eu também recomendaria para remover a propriedade-setter, desta forma você forçar o estado do contador a ser definida pelo método indicado DoSomething ()

Dependendo da situação, pode ser preferível permitir a modificação direta de um campo em uma classe só em privado, e ou através de algum método que associa semântica com a modificação. Desta forma, fica mais fácil raciocinar sobre esta classe e que o valor particular, desde que você pode estar certo que a sua modificado apenas em uma determinada maneira. Além disso, em algum ponto, uma acção como incrementando e int pode ter consequências necessários adicionais, altura em que faz mais sentido para expor o acesso a ele por meio de métodos.

I sempre usar os assessores da propriedade, porque o que estou seguro no caso de eu adicionar lógica no getter ou setter no futuro, sabendo com certeza que nenhum código ignora-lo.

Se você está preocupado com a sobrecarga de chamar os assessores da propriedade quando eles simplesmente ir diretamente para o campo de atuação, não. A maioria dos compiladores vai in-line esse tipo de coisa, dando-lhe efetivamente o mesmo desempenho. Pelo menos, você é muito pouco provável que precisam dos nanossegundos extras de tempo você pode ganho, indo diretamente para o campo.

É melhor ficar com os assessores da propriedade, porque a) você pode ser muito consistente em todo o seu código que torna mais maintainble e b) você obtém os benefícios apontados por outros aqui.

Além disso, eu não costumo acrescentar a palavras-chave Me. (ou this.), a menos que haja um problema de escopo (que eu tento evitar ao escolher meus identificadores com cuidado). Eu não ficar confuso com isso porque minhas funções e subs são nunca tanto tempo que eu não tenho certeza se eu estou trabalhando com uma variável local (baseada em pilha) ou um membro da classe. Quando eles ficam muito tempo para contar facilmente, eu refatorar.

O cartaz original é exatamente correto.

campos 1) acessar sua privados diretamente.

  • Faz refatoração mais fácil.

2) Se acessores acessando usar a palavra-chave ME. para melhorar a legibilidade

  • listando explicitamente âmbito requer pensamento menos pelo leitor

3) Use o acessor somente se implementa a lógica lógica vital que também se aplica ao acesso privado. Desta forma, você sabe que se você estiver usando o acessor é porque não é “algo mais a ele”

  • Esta é a única razão para violar a regra # 1.

4) Evite utilizar protegido Fields. As classes derivadas devem sempre usar o acessor, nunca mais o acesso directo ao campo.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top