The this keyword is relatively language-agnostic, as many other OOP languages use it (Java and C++, for example).

Anyway, this basically refers to the object's instance of itself. It can be useful in 3 different ways. Let's define a basic program:

namespace Example 
{
    class Program 
    {
        static void Main(string[] args) 
        {
            Dog d = new Dog("Fido");
            d.PerformAction();

            Console.ReadKey();
        }
    }

    public class Animal 
    {
        string Name { get; set; }
        public Animal(string name) 
        {
            this.Name = name;
        }

        public virtual void Speak() 
        {
            Console.WriteLine("grr");
        }

        public static void PrintName(Animal animal) 
        {
            Console.WriteLine(animal.Name);
        }
    }

    class Dog : Animal 
    {
        public Dog(string name) : base(name) { }

        public override void Speak() 
        {
            Console.WriteLine("woof");
        }

        public void PerformAction() 
        {
            Speak();
            this.Speak();
            base.Speak();

            Animal.PrintName(this);
        }
    }
}

This program gives us the following output:

woof
woof
grr
Fido

Why? It requires a basic understanding of the keywords this and base. To understand base, you need to know what derived classes are and when to use them. Basically, the derived class in this case represents an "is-a" relationship between the two; that is to say, a Dog "is a" Animal, which it is.

This means that Dog will take on the methods of the parent class (in this case, Animal) as well as explicitly calling methods from its parent class even though the subclass may have overridden it.

The use of derivative classes is a bit of a long subject, and I don't know how much you've read into it in your book, but it's important stuff to know.

Anyway, let's look at the program flow. In our Main method, we are instantiating a Dog object, and passing it a string parameter of "Fido". This creates a new Dog object.

The Dog constructor has a suffix of base(name). This means that the constructor for Animal will be used and provided with that parameter. In the Animal class, this sets the Name property to "Fido". Since the Dog "is a" Animal, the Dog class possesses its own property called Name which is now set to "Fido".

Note the use of the keyword this in the constructor for Animal. In this case, this is simply a reference to the current object, which is actually of type Dog. You could actually omit the this and simply put Name = name; for that line. When you are only referencing properties or variables, this is simply syntactic sugar; that is, it doesn't actually do anything, but makes the code a little cleaner and its intentions more obvious.

So now we have a Dog object set up. The next line in the Main method is d.PerformAction();.

The PerformAction() method here is unique to the Dog class. An Animal cannot call it, but a Dog can.

Try to follow along with the flow of the code here.

The first line in the method is Speak();. This prints "woof". Why? Because it is calling the Dog's overridden method, overriding makes the method unique to the Dog class, so it speaks.

The second line in the method is this.Speak();. This also prints "woof." Why? Because it's exactly the same as calling the method by itself. Much like properties and variables, calling this.Method() is the same as calling simply Method() in an object. This has its advantages though; and is preferred if you are doing any type of class derivation, because it makes it more explicit whether or not you mean to call the overridden method or the parent class method.

The third line is base.Speak();. This prints "grr". Why? Because it is calling the base class method, i.e, the Animal class's Speak() method. You explicitly told the class to not call the overriden method.

The last line is Animal.PrintName(this); This prints "Fido". Why? Well, one thing to note is that this is a static method, and as such, it cannot be called from an object reference, and must be called from the class itself. It takes in a parameter of type Animal, and a Dog is of type Animal. If you remember back to the constructor, the Dog has its own Name property which was set to "Fido". The PrintName() method prints the object's Name property. So it prints "Fido". You can use this to pass to an external method a reference to your object so that it can do something with it.

One caveat: this cannot be used inside of any static classes or methods, because this is an internal object reference, and static classes/methods, by definition, are decoupled from any particular object.

I don't know how well I've explained this. It's one of those things where you have to use it a bit to really get a feel for when and where it would be useful, and why. Once you program for a bit, go through some books and/or tutorials, its purpose will become obvious.

Hope that helps.