How do I disable the implicit “this” in C#?

Question

This bothers me a lot and I find I write stupid bugs when combined with Intellisense (VS 2008 Pro):

class Foo
{
    public Foo(bool isAction)
    {
        this.IsAction = IsAction;
    }

    public bool IsAction { get; private set; }
}

Did you catch it? I certainly didn't until IsAction never changed, causing bugs.

Intellisense somehow converted "isA<tab>" to "IsAction" for me which means the property Foo.IsAction is always false regardless of the constructor input. Just brilliant.

I have to say that I particularly hate the "implicit this" (I don't know if that has a formal name) and I would like to turn it off so it never assumes it. Is there a way to do this? This also applies in calling static methods of the same class.

Alternatively, what naming conventions avoid this little problem? The property must remain "IsAction" so it has to be a convention on the constructor parameter name. Oddly enough, if I name it with the exact matching spelling then this.IsAction = IsAction; works out correctly.

The problem isn't case-sensitive languages but the implicitness of this. Now that I think about it, this also more of a VS 2008 Pro question than a C#. I can live with code already written without the this but I don't want to write new code without it which means telling In

---

Noldorin's answer got me thinking.

Now that I think about it, this also more of a VS 2008 question than a C#. I can live with code already written without the this (though I do change it if I'm in there mucking around) but I don't want to write new code without it which means telling Intellisense to stop doing it. Can I tell Intellisense to knock it off?

Answer 1

This is a common problem. Microsoft has some recommendations for parameter names but they aren't terribly helpful in your case.

As other responders have mentioned, you cannot "disable" the C# language scope resolution behavior - your best approach is a naming conventions. Others have mentioned "Hungarian" notation - some people have a knee-jerk reaction to this because of the confusion over the original intent of the notation.

My personal approach, has been to use the character 'p' as a prefix to parameter names of public functions. It's unobtrusive, simple, readily identifiable, and easy to enforce with tools like Resharper.

The particular naming convention you choose is a matter of preference and style; however, there is some benefit from being consistent in the practice you select.

Using my suggested naming convention, you would write your constructor to:

class Foo
{
    public Foo(bool pIsAction)
    {
        this.IsAction = pIsAction;
    }

    public bool IsAction { get; private set; }
}

Answer 2

I've just tried your code in Visual Studio 2008. Turning on the in built static analysis yields the following error:

Warning 3 CA1801 : Microsoft.Usage : Parameter 'isAction' of 'Foo.Foo(bool)' is never used. Remove the parameter or use it in the method body.

My suggestion is by turning this on you will find errors like this early on. To enable this choose properties from the context menu on the project, then select the Code Analysis tab and select "Enable Code Analysis on Build"

Answer 3

You could always go back to Hungarian notation [I'm preparing to get flamed as I type this]. If you can deal with the ugliness, it would solve your problem. This is a suggestion, not a reccomendation.

Alternately, I'm pretty gosh darned sure that static code analysis will catch this and warn you about it. Try FxCop.

EDIT

I have been using Resharper for over a year now, and I do know that it is very smart about assisting you in a case sensitive way. Among other benefits, your intellisense problem will be solved by installing Resharper.

EDIT 2

I just checked. Neither FxCop, nor Resharper catches this error directly. What both do catch is the fact that the isAction parameter is unused in the Foo method. In this case, the warning would clue you in to the mistake. In cases where the parameter is used in another way within the method, it might slip through static code analysis.

Answer 4

FxCop will complain about this because the isAction parameter is never used. Specifically it will pull rule CA1801:ReviewUnusedParameters.

Personally I've always felt that the C# compiler should give a warning about unused parameters.

Answer 5

This gets me all the time. I've taken to prepending variables being passed into the constructor with a '_', like:

class Foo
{    
    public Foo(bool _isAction)
    {
        this.IsAction = _isAction;
    }
    public bool IsAction { get; private set; }}

Answer 6

I'm afraid there's no way to disable the "implicit this" feature. It's part of the language specification and compiler, and there's no way to turn it off.

Personally, I don't consider this a big problem. Admittedly, it is important to be careful with the capitalisation of member and parameter names, but this is always the situation in a case-sensitive language such as C#.

My recommended "solution" (which you already seem to be doing) is to always use the this keyword for referencing properties/fields, so that it should immediately stand out when you should be using a parameter. It's not going to solve the problem for you, but if you keep it in mind it will undoubtedly help. Just getting in the habit of this (as well as remembering all parameter/local variable names should start with lower-case) will do you well to avoid this issue in the future.

Answer 7

It's an annoying problem in Visual Studio's intellisense. Resharper gets it right most of the time though.

Answer 8

I think it's more likely that the developer picked "IsAction" instead of "isAction" from Intellisense. I don't think Intellisense would change "isA" to "this.IsAction".

If the names differ only by case then I think the only way to prevent mistakes like this is by being aware of them and careful, and by using unit tests effectively.

Answer 9

It might be annoying in other capacities, but you could turn off the option to have Intellisense pre-select the most recently used member. I realize that won't really fix the problem outright but it might possibly help prevent some accidental tabs when you don't really have the right item selected.

Answer 10

Note:

If you are using Resharper, you have some shortcuts that write a lot of this code for you and avoid the error.

You can either create the property first, then hit Alt-Ins and choose "generate constructor", or you can add a parameter "isAction" to the constructor, hit Alt-Enter with the caret in the parameterName, and choose the "Create and initialize Auto-property IsAction" action from the menu that pops up.