Quando si chiama un metodo dovremmo usare base.methodname e this.methodname?

L'utilizzo della parola chiave base non è una questione di preferenza, è una questione di correttezza. Se si desidera chiamare l'implementazione della classe base nel metodo sottoposto a override, è necessario utilizzare base . Se non vuoi chiamarlo, non puoi usare base .

La parola chiave this , d'altra parte, è una questione di preferenza nella maggior parte dei casi. Penso che solo inutilmente ingombra il codice, quindi non lo uso se non dovessi farlo. Dove è utile è se hai un parametro metodo con lo stesso nome di campo (o proprietà). Vorrei usare this in questo caso. Ma se sto scrivendo un nuovo codice, tendo ad usare le convenzioni di denominazione che evitano questo problema.

Suggerirei che se si richiama esplicitamente un metodo di base da una classe in cui tale metodo viene sovrascritto, si ha un problema serio con la logica e la leggibilità. base dovrebbe apparire solo dove chiama l'implementazione di base di un metodo sottoposto a override da quel metodo sottoposto a override.

Ovunque, dovrebbe essere this (se il metodo non è sovrascritto, andrà comunque alla classe base) e non c'è nulla di male nel permettere al compilatore di dedurlo.

this parola chiave: non esiste una regola semplice e veloce per applicare la parola chiave this in quanto è una preferenza personale, ma il tuo codice potrebbe essere ingombrante.

Pro e contro dell'utilizzo di questa parola chiave in C #

base parola chiave (riutilizzabilità): ci sono già risposte che indicano l'uso della base. Vorrei aggiungere un punto.

Le funzionalità comuni per tutte le classi derivate verrebbero nella classe base e puoi chiamare il metodo base seguito dall'implementazione specifica nel metodo nella classe derivata per ottenere la riutilizzabilità.

Oltre a menzionato, puoi usare "questo" quando chiami una funzione di estensione.

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

Non puoi fare:

SomeFunction();

dal corpo di MyClass. Solo:

this.SomeFunction();

Non esiste un vero motivo per creare estensioni statiche per la classe che stai creando. L'unico scenario in cui mi è stato utile è quando ho avuto funzioni di estensione basate sull'interfaccia che la mia classe sta implementando, non sulla classe stessa.

Suggerirei di eliminare il prefisso this. , tranne nei casi in cui aggiunge simmetria. Per esempio:.

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
    }
}