When calling a method should we use base.methodname and this.methodname?

Question

In C#, with an inherited class set -- when calling a method should we use keywords 'base.methodname and this.methodname'... irrespective of whether it is a overridden method or not?

The code is likely to undergo changes in terms of logic and maybe some IF-ELSE like conditions may come in at a later date. So at that time, the developer has to be compelled to revisit each line of code and ensure that he/she makes the right choice of which method is being called --- base.methodname() or this.methodname() ELSE the .NET framework will call the DEFAULT (I think its base.methodname()) and the entire logic can go for a toss.

Answer 1

Using the base keyword is not a question of preference, it's a question of correctness. If you want to call the base class implementation in overridden method, you have to use base. If you don't want to call that, you can't use base.

The this keyword, on the other hand, is a question of preference in most cases. I think it only unnecessarily clutters the code, so I don't use it if I don't have to. Where it's useful is if you have a method parameter with the same name as field (or property). I would use this in such case. But if I'm writing new code, I tend to use naming conventions that avoid this problem.

Answer 2

I would suggest that if you're explicitly calling a base method from a class in which that method is overridden, you have a serious problem with both logic and readability. base should really only appear where calling the base implementation of an overridden method from that overridden method.

Everywhere else, it should be this (if the method isn't overridden then it will go to the base class anyway) and there is nothing wrong with allowing the compiler to infer that.

Answer 3

this keyword : There is no hard and fast rule to apply this keyword as it is a personal preference but your code could get cluttered.

Pros and cons of using this keyword in C#

base keyword (re-usability) : There are already answers indicating the use of base. I would like to add a point.

Common functionality for all derived classes would come in the base class and you can call the base method followed by the specific implementation in the method in the derived class achieving re-usability.

Answer 4

In addition to mentioned, you can use "this" when calling an extension function.

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

You can't do:

SomeFunction();

from inside MyClass body. Only:

this.SomeFunction();

There is no real reason to create static extensions for the class you are making. The one scenario when it was useful to me is when I had extension functions based on the interface my class is implementing, not on the class itself.

Answer 5

I would recommend dropping the this. prefix, except in cases where it adds symmetry. E.g.:

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