What does this[string key] mean

It's an indexer. It defines an indexed property that can be used to access a collection of the object by using objectName["key"] like for example a Dictionary<string,T>.

The implementation could look something like this:

string this[string key]
{ 
    get{return _internalDictionary[key];}
}

Or this:

string this[string key]
{ 
    get
    {
        switch(key)
        {
            case "Length":
                return this.Length;
            case "Timeout":
                return this.Timeout.ToString();
            case "Version":
                return "1.5.0";
        }
        return null;
    }
}

It's just like a method but different

This is really just a special kind of function. For example imagine you had this class:

class MyClass {
    public string GetValue(string name) {
        switch(key)
        {
            case "Name":
                return "John";
            case "Age":
                return 30;
        }
    }
}

The way you would call this code would of course be this:

// Calling a regular method
var instance = new MyClass();
var value = instance.GetValue("Name");
Console.WriteLine(value);
// Output: John

Now change a couple of things so that you are using the "indexer" syntax instead.

1. Instead of using the method name "GetValue", use the "this" keyword.
2. Instead of parenthesis around your parameters, use square brackets

Applying those steps:

• string GetValue(string name) becomes
• string this[string name]

To make it a little easier to envision imagine that your original function instead of being called GetValue() was called This(), then:

• string This(string name) becomes
• string this[string name]

Full code:

class MyClass {
    // public string GetValue(string name) {
    public string this[string name] {
        switch(key)
        {
            case "Name":
                return "John";
            case "Age":
                return 30;
        }
    }
}

In terms of calling your indexer, you drop the function name and again use square brackets instead of parenthesis. So that instance.GetValue("Name") becomes instance["Name"].

Full code:

// Calling a regular method
var instance = new MyClass();

// Remove the dot (.) and the function name
// Instead of parenthesis use square brackets

// var value = instance.GetValue("Name");
var value = instance["Name"];

Console.WriteLine(value);
// Output: John

When should you use an indexer instead of a method?

Whenever you want. Whenever you feel it makes sense. It's usually used when an object stores dynamic keyed values like Dictionary<TKey,TValue>, or when you want your object to behave like an array like List.

It is an Indexer which allows an object to be indexed like an array.

public class MyIndexer
    {
        private string[] myData;
        public string this[int ind]
        {
            get
            {
                return myData[ind];
            }
            set
            {
                myData[ind] = value;
            }
        }
    }

public class UseIndex
    {
        public void UseIndexer()
        {            
            MyIndexer ind = new MyIndexer();

            ind[1] = "Value 1";
            ind[2] = "Value 2";
            ind[3] = "Value 3";    
            ind[4] = "Value 4";    
            ind[5] = "Value 5";    
        }
    }