Quais são as melhores práticas atuais consideradas em relação à palavra-chave "this" na frente do campo e métodos em c #?

A menos que seja necessário diferenciar entre uma variável e um campo com o mesmo nome, nunca coloco this.na frente de um campo ou de qualquer acesso de membro em C #. Eu vejo isso como diferente do m_prefixo que costumava ser comum em C ++, e acho que se você realmente precisa especificar que é um membro, sua classe é muito grande.

No entanto, há várias pessoas no meu escritório que discordam totalmente.

O que é considerado as melhores práticas atuais this.?

EDIT: Para esclarecer, eu nunca uso m_e só uso this.quando absolutamente necessário.

De acordo com as diretrizes de design do Framework , ao se referir a campos públicos ou protegidos:

NÃO use um prefixo para nomes de campos.

Por exemplo, m_é um prefixo.

Portanto, a exposição pública de um campo se presta ao uso da thispalavra - chave, conforme explicado no MSDN

Para qualificar membros ocultos por nomes semelhantes, por exemplo: Copiar

public Employee(string name, string alias) 
{
   this.name = name;
   this.alias = alias;
}

Ao se referir a campos particulares, você pode usar o m_se desejar. Mas, para campos públicos, recomendo seguir as melhores práticas.

Pessoalmente, não gosto de sublinhados nos nomes das variáveis. Eu também tento ser consistente. Portanto, this.name = name;é uma boa regra geral trabalhar em ambos os cenários público / privado.

Em nossa equipe, adotamos o padrão de usar o qualificador this.ou Me.object em classes maiores para ajudar os desenvolvedores juniores a distinguir mais prontamente o escopo exato / imediato de uma variável apenas olhando para ela.

Em termos de código, é uma afetação totalmente desnecessária, mas não bloqueia nada, pois gera o mesmo código MISL exato no final. Nós o adotamos apenas porque abordava um problema imediato que descobrimos com alguns dos juniores. Além disso, não considero útil incluí-lo.

O StyleCop aplicará o uso de this.So, se você considerar isso como a melhor prática (o que eu faço), o uso da this.é a melhor prática.

O estilo que você adota depende de você e de seus próprios padrões de codificação, "melhor" é o que você definir. Apenas seja consistente. Usá-lo inconsistentemente apenas leva à confusão.

Meu raciocínio é que o uso this.ressalta o fato de você estar referenciando propriedades da instância; portanto, por exemplo, ajuda a destacar o fato de você estar as mutando (se houver this.x = ...), o que é algo que você talvez queira saber. Também destaca o fato de que sempre que você vê this.seu método nunca pode ser estático. Usar algumas convenções como m_também fará isso, mas é um esforço manual, se você transformar uma m_estática ou refatorar algum método para passar o valor de fora da classe, lembre-se de alterar o nome, se estiver usando thiso compilador o forçará a fazer a alteração.

Simplificando, usar thisé mais fácil, porque se você errar, seu código não será compilado; se você usá- m_lo, é um esforço manual e não está aproveitando as ferramentas.

Uma das coisas boas sobre o uso m_é que, assim que você digita o pouco mintellisense, é apresentada uma lista de todas as suas variáveis ​​privadas; pessoalmente, acho que isso é uma vantagem a seu favor; Eu também usaria s_estática privada e c_constantes privadas por razões semelhantes. É uma notação húngara, mas, no sentido em que foi criada, acrescenta um significado útil ao nome da variável, para que qualquer outro programador possa dizer coisas a partir do nome que podem não ser totalmente óbvias.

Certamente não concordo em não ter nenhuma maneira de distinguir entre variáveis ​​membro e não membro, porque elas são diferentes e quando leio código em que as pessoas não fazem algo para distinguir, é realmente mais difícil de ler. Usandothis. apenas parece mais chapa da caldeira do que o necessário. Mas, na verdade, é gosto pessoal, se você codifica uma maneira por um tempo, acaba pensando que está certo e tudo o mais está errado. A única coisa que realmente importa se o esquema é sadio é que todos na equipe sejam consistentes.

thisé explícito. É um sinal óptico que você não pode perder.

Eu quase sempre prefiro código explícito ao código implícito. É por isso que uso com thisfrequência. Considero uma prática recomendada.

Eu sempre uso "isso". O raciocínio é baseado em dois fatos simples:

• Ler código é mais difícil do que escrever código.
• Você lê código com mais frequência do que escreve código.

O uso de "this" torna bastante explícito para quem lê (ou seja, não apenas o autor, mas pode incluir o autor em seis meses após o esquecimento completo das especificações da implementação) de que sim, este é um membro da classe que ' estamos falando aqui. "m_" e similares são apenas uma convenção e, como qualquer outra convenção, podem ser mal utilizados (ou não utilizados) - não há nada para impor "m _" / etc no momento da compilação ou no tempo de execução. "this" é mais forte: você pode colocar "m_" em uma variável local e o compilador não irá reclamar; você não pode fazer isso com "isso".

Se alguma coisa eu considero lamentável que o uso de "this" não tenha sido tornado obrigatório nas especificações de idioma.

Como um bom bônus, ao depurar, você pode passar o mouse sobre (ou adicionar um relógio) ao "this" e obter inspeção de todos os outros membros da classe - informações valiosas.

A thispalavra-chave é usada particularmente para distinguir duas variáveis ​​que existem, especialmente quando você tem um construtor ou método com uma variável com o mesmo nome, mas pode ter o mesmo tipo.

Exemplo:

public class Example {

    string reason;
    string cause;

    Example (string reason, string cause) {
        this.reason = reason;
        this.cause = cause;
    }

    //<Setter> if you want to explicitly write your onw
    public void setReason(stirng reason) {
        this.reason = reason;
    }
}

Isso (por exemplo this.reason = reason) basicamente atribui o valor dos parâmetros às variáveis ​​da classe. thisbasicamente pega a classe reasondo bloco de parâmetros.

Eu também estive pensando sobre isso há algum tempo. Depois de fazer uma extensa codificação em javascript, eu me peguei usando com this.mais frequência no meu código c # (antes disso eu o usava quase exclusivamente em construtores ou métodos semelhantes para evitar ambiguidade). Isso torna o código um pouco mais claro para pouco esforço adicional, além disso, você não acaba mutilando os nomes dos membros da classe com prefixos e ainda pode voltar a usar os membros do "caminho curto" quando o contexto é claro ou em declarações particularmente complexas. Acabei de adicionar this., quando tenho um método mais longo, uma lista mais longa de argumentos ou muitas variáveis ​​locais declaradas e acho que o código pode se beneficiar de alguma clareza adicional, mesmo se forçado.

Mas eu pessoalmente odeio absolutamente o m_estilo do prefixo, não tanto devido ao húngaro, mas porque sublinhado é uma dor de digitar;) Portanto, não o considero uma alternativa. Admito que há pontos fortes no que se refere ao intellisense, mas você pode argumentar novamente que, se não conseguir se lembrar das primeiras letras de uma variável de membro, sua classe será grande.

Eu prevejo um único prefixo sublinhado para os alunos. _someVar;

Por quê? Você sabe à primeira vista que é um membro, não uma variável de pilha. Apenas conveniência durante uma rápida olhada. E leva menos confusão em comparação com a palavra-chave "this".

Usar coisas como o this.prefixo / palavra-chave que não são necessárias nem alteram o resultado são sempre subjetivas. No entanto, acho que podemos concordar que a maioria de nós deseja diferenciar campos de variáveis ​​locais. Alguns usam um prefixo de sublinhado (que acho feio e uma espécie de notação húngara), outros usam othis. palavra chave. Eu sou um dos últimos. É tudo uma questão de legibilidade e compreensão. Não me importo de digitar um pouco mais, se for mais claro ou mais legível. Quero diferenciar campos e variáveis ​​em um piscar de olhos.

Eu sempre defino campos nomeados semelhantes a myFielde nomes de parâmetros e nomes de variáveis ​​locais também semelhantes a myField. Sem sublinhados, sem prefixos. Eu uso em thistodos os lugares que me refiro a um campo. Dessa maneira, posso distinguir campos de variáveis ​​e argumentos locais sem nenhum tipo de prefixo. Obviamente, em um caso como esse, a thispalavra-chave é necessária:

public Person(string firstName)
{
    this.firstName = firstName;
}

Minhas propriedades, portanto, se parecem com isso (sim, eu sempre coloco o campo com a propriedade e não em nenhum lugar não relacionado na parte superior do meu arquivo):

private string firstName;
public string FirstName
{
    get { return this.firstName; }
}

Ele lê bem: retorne esse primeiro nome .

EDIT: Minha resposta claramente não é uma resposta. Então aqui está uma edição. As diretrizes de codificação da Microsoft declaram:

2.6 Nomeação

Não use um prefixo para variáveis ​​de membro ( , m , s_, etc.). Se você quiser distinguir> entre variáveis ​​locais e membros, deve usar "this". Em C # e "Me". No VB.NET.

Pode ser encontrado em: http://blogs.msdn.com/b/brada/archive/2005/01/26/361363.aspx

Portanto, parece que pelo menos da MS não há uma diretriz clara, embora outra resposta afirme que o StyleCop a torna uma diretriz. Não há autoridade sobre essas coisas, então eu sugiro que você se decida ou, nesse caso, ceda à sua equipe. Não é grande coisa.

Minha resposta original, eu pessoalmente concordo com você, mas talvez um teste de compreensão de leitura colocando os dois métodos um contra o outro seria valioso. Caso contrário, essas coisas de estilo são apenas confusas.

Minha salva a seguir: Minha opinião é que as pessoas estão complicando desnecessariamente seu estilo de código e, se precisarem indicar que algo é uma variável no nível de classe, pode haver outros problemas estruturais sérios no código, como o método de receita antigo colocando variáveis ​​privadas no topo da classe, o que força você a rolar constantemente para cima e para baixo.

isso me parece uma daquelas convenções "o que é isso" versus as convenções de nomenclatura "o que faz" corretas. A brevidade deve ser favorecida acima de ser explícita. Esta é uma lição que é repetida frequentemente por idiomas dinâmicos. Não precisamos de todo o cotão!

esta. muitas vezes pode levar a ruídos indesejados.

Aqui está a minha solução:

• parameter_names_
• local_variables
• ANY_CONSTANT
• _private_members
• NonPrivateProperties
• _NonPrivateProperty // Suporte
• propriedade privada
• _privateProperty // suporte