8.6 The this Keyword

The keyword this refers to the current instance of an object. The this reference is a hidden parameter in every nonstatic method of a class (static methods are discussed later in this chapter). There are three ways in which the this reference is typically used. The first way is to qualify instance members that have the same name as parameters, as in the following:

public void SomeMethod (int hour)
{
   this.hour = hour;
}

In this example, SomeMethod() takes a parameter (hour) with the same name as a member variable of the class. The this reference is used to resolve the ambiguity. While this.hour refers to the member variable, hour refers to the parameter.

You can, for example, use the this pointer to make a copy constructor more explicit:

public Time(Time that)
{
    this.Year = that.Year;
    this.Month = that.Month;
    this.Date = that.Date;
    this.Hour = that.Hour;
    this.Minute = that.Minute;
    this.Second = that.Second;
}

In this snippet, this refers to the current object (the object whose constructor is running) and that refers to the object passed in.

The argument in favor of this style is that you pick the right variable name and then use it both for the parameter and for the member variable. The counter-argument is that using the same name for both the parameter and the member variable can be confusing

The second use of the this reference is to pass the current object as a parameter to another method, as in the following code:

Class SomeClass
{
  public void FirstMethod(OtherClass otherObject)
  {
     otherObject.SecondMethod(this);
  }
  // ...
}

This code snippet establishes two classes, SomeClass and OtherClass. SomeClass has a method named FirstMethod(), and OtherClass has a method named SecondMethod().

Inside FirstMethod, we'd like to invoke SecondMethod, passing in the current object (an instance of SomeClass) for further processing. To do so, you pass in the this reference, which refers to the current instance of SomeClass.

The third use of this is with indexers, which are covered in Chapter 15.