When NOT TO USE 'this' keyword?

问题:

Sorry for asking it again, there are already some questions about this keyword. But all of them tell the purpose of 'this'.

When do you use this keyword
C# when to use this keyword
Use of “this” keyword in formal parameters for static methods in C#
Proper usage of “this.” keyword in C#?

My question is when not to use 'this' keyword .
OR
Is it all right to use this keyword always in situation like the code

class RssReader
{
    private XmlTextReader _rssReader;
    private XmlDocument _rssDoc;
    private XmlNodeList _xn;

    protected XmlNodeList Item { get { return _xn; } }
    public int Count { get { return _count; } }

    public bool FetchFeed(String url)
    {
        this._rssReader = new XmlTextReader(url);
        this._rssDoc = new XmlDocument();
        _rssDoc.Load(_rssReader);
        _xn = _rssDoc.SelectNodes("/rss/channel/item");
        _count = _xn.Count;
        return true;
    }
}

here i have not used 'this' with "_xn" and "_count" also not with "_rssDoc.Load(_rssReader);" is it fine? Should i use "this" with all occurrences of class variables within the class?

Edit: Is it useless to use 'this' in a class for its own variables?

回答1:

this is almost always optional and does not need to be specified. If you want to be explicit that you are referring to a member, then use this. If you have a naming convention (such as naming all member fields something like _foo), then you really don't need to refer to them like this._foo.

It's a matter of personal taste (no performance penalty), but I find having the explicit this is harder to maintain and adds little value if you have a solid naming convention. Some people will only use this when calling a member method, e.g. this.Foo(_bar) instead of Foo(_bar), but again, I don't personally believe it adds much.

If you're working with existing code, follow the convention there, otherwise, pick whichever makes you the most productive and effective.

回答2:

I always use this. I use the same naming convention for local variables and private fields and it makes the code much easier to read because it becomes obvious if the used identifier is a field or local variable.

Further it prevents the introduction of bugs by adding a new local variable that hides a field.

internal sealed class Foo
{
    private Int32 bar = 42;

    private void Bar()
    {
        // Uncommenting the following line will change the
        // semantics of the method and probably introduce
        // a bug.  
        //var bar = 123;

        Console.WriteLine(bar);

        // This statement will not be affected.
        Console.WriteLine(this.bar);
    }
}

This can be avoided by using different naming conventions for fields and local variables but I really dislike underscore prefixed names. The first character of a word is very important for its readability and an underscore is one of the worst possible choices.

回答3:

My rule of thumb: Never use 'this' when it is redundant. In this case, 'this' is redundant, so I would avoid it. A tool like ReSharper is very good at telling you when this is the case.

回答4:

I always use this. to make it clear that I am referring to a class member, not a local variable.

回答5:

I would try to be consistent, so that people don't get confused into thinking that the few you do the other way (apart from the way you normally pick) have some special significance.

If you don't use the _whatever naming convention for fields, then you should use this.whatever consistently because otherwise there will be problems when constructors take a whatever parameter and try to put in a whatever field.

回答6:

It is fine. Especially since your class doesn't have a base class and the private fields are named appropriately. ReSharper considers this in your case to be redundant.

回答7:

Should i use "this" with all occurrences of class variables within the class?

In your particular case, NO.

Consider however the following example:

class RssReader
{
    private String url;

    public bool FetchFeed (String url)
    {
        new XmlTextReader (url);

        // vs.

        new XmlTextReader (this.url);

        return true;
    }
}

Here you'll need to specify this to access the instance variable that has the same name as the method argument.

回答8:

there is absolutely no reason not to use this. even redundancy is no reason not to use it, at all. You get the benefit of the intellisense box to safely complete your code and saves your time by selecting the right variable with the down-key and not to maul your keyboard all the time.

回答9:

You may, but don't need to unless it's a method that takes arguments with the same names as your class vars (to distinguish them).

回答10:

Well, as for me, 'this' looks really redundant when used with names starting with "_". This is absolutely legal in your example though.

回答11:

Here is how I look at it. When you call a member (be it method, property or field) of a class as such like DoMyThing(); or return Property; within the instance scope, it's not necessary that you're calling an instance member. DoMyThing or Property can be static members too.

public class Abc
{
    public static void Static()
    {
    }

    public Xyz Instance;

    public void Test() //instance scope
    {
        var xyz = Instance; //calls instance member
        Static(); //calls static member
    }
}

For both of them (static and instance) I've not prefixed anything. Actually my choices are:

1. do not prefix at all as above

   public void Test()
   {
       var xyz = Instance;
       Static();
   }
   

2. prefix for instance members alone

   public void Test()
   {
       var xyz = this.Instance; // prefixes 'this'
       Static(); 
   }
   

3. prefix for static members alone

   public void Test()
   {
       var xyz = Instance; 
       Abc.Static(); //prefixes class
   }
   

4. prefix in both cases

   public void Test()
   {
       var xyz = this.Instance; // prefixes 'this'
       Abc.Static(); //prefixes class
   }
   

This answer is not to say one style is better than other. This is just personal preference. Each has its own claim for correctness and readability.

My take:

a. I for one do not like the inconsistent style of 2. and 3.

b. 1. has the advantage of being more readable for me. Prefixing makes it more about definition than intent.

c. 4. is all about correctness. It has the advantage of being extremely consistent, especially considering you would be forced to prefix for both instance and static members at some point anyway. This is even more important to consider when it comes to base keyword where if you dont prefix with base keyword for a base class member, then adding a member with the same name in current derived class will cause it to override the previous call, changing the whole dynamics.

Personally, I would go with 1. And use this or Abc sparingly when I'm forced to. It's more readable for me, a benefit for me that is good enough to compensate for the little inconsistency it might cause.