How to call an extension method from own class without casting?

Question

I\'m trying to call an extension method on my own class, but it fails to compile. Consider the following lines of code:

public interface IHelloWorld
{
}         


        

Answer 1

this.HelloWorld(); works with no casting.

Remember how Extension methods work:

You use an object and compiler would know the type then it could resolve it to the extension method. If no object is used, then it would not be able to resolve it.

Answer 2

The cast isn't necessary - the this part is. So this works fine:

return this.HelloWorld();

Section 7.6.5.2 explicitly talks about method invocations of the form

expr.identifier ( )
expr.identifier ( args )
expr.identifier < typeargs > ( )
expr.identifier < typeargs > ( args )

This invocation:

HelloWorld()

isn't of that form, as there's no expression involved.

It's not immediately clear to me why the language was designed that way (i.e. why the "implicit this" was excluded) and maybe Eric Lippert will add an answer to that effect later. (The answer may well be along the lines of "because it would have taken a long time to spec, implement and test, for relatively little benefit.") However, this answer at least shows that the C# compiler is sticking to the spec...

Answer 3

Not really an answer, but too long to fit in the comment section...

Let's take the following example, that I think is pretty common:

public class DoubleSet : List<double>
{
    public IEnumerable<double> Square()
    {
        return this.Select( x => x*x );
    }
}

It is a perfectly valid point that the this is not necessary for the compiler to interpret the Select method properly.

However I think that in some ways, imposing the dot notation highlights the fact that we're dealing with an extension method, and that as such, the extension method will only access the members of the current instance through public accessors, even if you're calling it within the private scope of the class.

It makes explicit to the code reader that the extension method will treat the "this" instance as if it didn't know anything of its internal state. And indeed the class of the object is completely unknown to the extension method (as the extension method only knows the interface)

If the code was only:

    public IEnumerable<double> Square()
    {
        return Select( x => x*x );
    }

it would be much less obvious that you're dealing with IEnumerable.Select that is actually calling the IList.GetEnumerator and getting every element one by one to call the x => x*x function.