What idiom (if any) do you prefer for naming the "this" parameter to extension methods in C#, and why?

Question

The first parameter to a C# extension method is the instance that the extension method was called on. I have adopted an idiom, without seeing it elsewhere, of calling that variable "self". I would not be surprised at all if others are using that as well. Here's an example:

public static void Print(this string self)
{
   if(self != null) Console.WriteLine(self);
}

However, I'm starting to see others name that parameter "@this", as follows:

public static void Print(this string @this)
{
   if(@this != null) Console.WriteLine(@this);
}

And as a 3rd option, some prefer no idiom at all, saying that "self" and "@this" don't give any information. I think we all agree that sometimes there is a clear, meaningful name for the parameter, specific to its purpose, which is better than "self" or "@this". Some go further and say you can always come up with a more valuable name. So this is another valid point of view.

What other idioms have you seen? What idiom do you prefer, and why?

Answer 1

I have seen obj and val used. I do not like @this. We should try to avoid using keywords. I have never seen self but I like it.

Answer 2

You could do something like this...

public static void Print(this string extended)
{
   if(extended != null) Console.WriteLine(extended);
}

Answer 3

I name it fairly normally, based on the use. So "source" for the source sequence of a LINQ operator, or "argument"/"parameter" for an extension doing parameter/argument checking, etc.

I don't think it has to be particularly related to "this" or "self" - that doesn't give any extra information about the meaning of the parameter. Surely that's the most important thing.

EDIT: Even in the case where there's not a lot of obvious meaning, I'd prefer some meaning to none. What information is conferred by "self" or "@this"? Merely that it's the first parameter in an extension method - and that information is already obvious by the fact that the parameter is decorated with this. In the example case where theStringToPrint/self option is given, I'd use outputText instead - it conveys everything you need to know about the parameter, IMO.

Answer 4

I call it 'target', since the extension method will operate on that parameter.

Answer 5

I believe @this should be avoided as it makes use of the most useless language-specific feature ever seen (@). In fact, anything that can cause confusion or decrease readability such as keywords appearing where they are not keywords should be avoided. self reminds me of python but could be good for a consistent naming convention as it's clear that it's referring to the instance in use while not requiring some nasty syntactic trickery.

Answer 6

I name the variable exactly how I would name it if it were a plain old static method. The reason being that it can still be called as a static method and you must consider that use case in your code.

The easiest way to look at this is argument validation. Consider the case where null is passed into your method. You should be doing argument checking and throwing an ArgumentNullException. If it's implemented properly you'll need to put "this" as the argument name like so.

public static void Print(this string @this) {
  if ( null == @this ) {
    throw new ArgumentNullException("this");
  }
  ...
}

Now someone is coding against your library and suddenly gets an exception dialog which says "this is null". They will be most confused :)

This is a bit of a contrived example, but in general I treat extension methods no different that a plain old static method. I find it makes them easier to reason about.