Ao chamar um método, devemos usar base.methodname e this.methodname?

Em C #, com um conjunto de classes herdado - ao chamar um método, devemos usar as palavras-chave 'base.methodname e this.methodname' ... independentemente de ser um método substituído ou não?

É provável que o código sofra alterações em termos de lógica e talvez algumas condições semelhantes ao IF-ELSE possam ocorrer posteriormente. Portanto, naquele momento, o desenvolvedor deve ser obrigado a revisitar cada linha de código e garantir que ele / ela faça a escolha certa de qual método está sendo chamado --- base.methodname () ou this.methodname () ELSE the. NET estrutura chamará o padrão (acho que seu base.methodname ()) e toda a lógica pode ir para um lance.

Usar a basepalavra-chave não é uma questão de preferência, é uma questão de correção. Se você deseja chamar a implementação da classe base no método substituído, você deve usar base. Se você não quiser chamar assim, não poderá usar base.

A thispalavra-chave, por outro lado, é uma questão de preferência na maioria dos casos. Eu acho que isso apenas desorganiza desnecessariamente o código, então não o uso se não for necessário. Onde é útil é se você tiver um parâmetro de método com o mesmo nome que campo (ou propriedade). Eu usaria thisnesse caso. Mas se estou escrevendo um novo código, costumo usar convenções de nomenclatura que evitam esse problema.

Eu sugeriria que, se você está chamando explicitamente um método base de uma classe na qual esse método é substituído, você tem um sério problema com lógica e legibilidade. basedeve realmente aparecer apenas onde é chamada a implementação básica de um método substituído a partir desse método substituído.

Em qualquer outro lugar, deveria estar this(se o método não for substituído, ele irá para a classe base de qualquer maneira) e não há nada de errado em permitir que o compilador deduza isso.

thispalavra-chave: não existe uma regra rígida e rápida para aplicar a thispalavra-chave, pois é uma preferência pessoal, mas seu código pode ficar confuso.

Prós e contras do uso dessa palavra-chave em C #

basepalavra-chave (reutilização): já existem respostas indicando o uso da base. Eu gostaria de acrescentar um ponto.

A funcionalidade comum para todas as classes derivadas viria na classe base e você pode chamar o método base seguido pela implementação específica no método na classe derivada, obtendo reutilização.

Além do mencionado, você pode usar "this" ao chamar uma função de extensão.

public static class ExtensionForMyClass {  
public static void SomeFunction (this MyClass inst) {} 
}

Você não pode fazer:

SomeFunction();

de dentro do corpo do MyClass. Somente:

this.SomeFunction();

Não há motivo real para criar extensões estáticas para a classe que você está criando. O único cenário em que isso foi útil para mim é quando eu tinha funções de extensão baseadas na interface que minha classe está implementando, e não na própria classe.

Eu recomendaria soltar o this.prefixo, exceto nos casos em que adiciona simetria. Por exemplo:

public class Foo: IComparable {
    int value1, value 2;

    public int CompareTo(object _that) {
        if (_that == null) return 1;
        if (Object.ReferenceEquals(this, _that)) return 0;

        Foo that = (foo) _that;
        var result = this.value1.CompareTo(that.value1)
        if (result != 0) return result;

        result = this.value2.CompareTo(that.value2)
        if (result != 0) return result;

        return 0
    }
}