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. This also applies in calling static methods of the same class.

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.

Answer 1

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 2

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 3

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 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

Things have changed since 2009 when these other answers were submitted. I see the question is tagged visual-studio-2008 but this may still help someone. In recent versions of Visual Studio, such as Visual Studio 2019, it's possible to configure the IDE to check C# code for code-style conformity. One of the available checks is to require the explicit use of this .

Go to Options > Text Editor > C# > Code Style > General, where you'll find a group named 'this.' preferences . Set each one to Prefer 'this.' and set the Severity to Error .

Any violations in your C# code will cause a code-style-check error to be shown in the IDE. Curiously though, this doesn't cause the build to fail.

See also the documentation on the EditorConfig file format , where the relevant parameters are named like dotnet_style_qualification_for_field .

Answer 8

Further ideas are:

1. Implement your own checker, eg by searching for the regex \\b(\\w+)\\b\\s*=\\s*\\1 . This will find all self-assignments, not only in class constructors. It is not theoretically fool-proof (eg it won't capture self-assignments with a /**/ comment mixed into the middle of them), but it should work well enough in all practical scenarios.

2. If you don't mind a little bit of extra typing you can initially give the constructor parameter a different name and rename it after writing the body of the constructor.

Answer 9

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

Answer 10

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 11

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 12

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.