Когда НЕ ИСПОЛЬЗОВАТЬ ключевое слово 'this'?

Question

Извините за повторный запрос, уже есть несколько вопросов по этому ключевому слову. Но все они говорят цель «этого».

Когда вы используете это ключевое слово
C # когда использовать это ключевое слово
Использование ключевого слова this в формальных параметрах для статических методов в C #
Правильное использование ключевого слова this в C #?

У меня вопрос , когда не следует использовать ключевое слово "this" .
OR
Можно ли использовать это ключевое слово всегда в ситуации, подобной коду

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

здесь я не использовал 'this' с "_xn" и "_count", а не с "_rssDoc.Load (_rssReader);" это нормально? Должен ли я использовать «это» со всеми вхождениями переменных класса в классе?

Редактировать: Неужели бесполезно использовать 'this' в классе для своих собственных переменных?

Answer 1

I всегда используйте this. Я использую то же соглашение об именах для локальных переменных и личных полей, и это делает код намного проще для чтения, потому что становится очевидным, если используемый идентификатор является полем или локальной переменной.

Кроме того, он предотвращает появление ошибок, добавляя новую локальную переменную, которая скрывает поле.

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);
    }
}

Этого можно избежать, используя разные соглашения об именах для полей и локальных переменных, но я действительно не люблю подчеркивать префиксные имена. Первый символ слова очень важен для его читабельности, и подчеркивание является одним из худших возможных вариантов.

Answer 2

this почти всегда является необязательным и не требует указания. Если вы хотите явно указать, что ссылаетесь на участника, используйте this. Если у вас есть соглашение об именах (например, присваивает имена всем полям-членам что-то вроде _foo), тогда вам действительно не нужно ссылаться на них как this._foo.

Это вопрос личного вкуса (без потери производительности), но я считаю, что поддерживать this сложнее, и он мало полезен, если у вас есть твердое соглашение об именах. Некоторые люди будут использовать this только при вызове метода-члена, например this.Foo(_bar) вместо Foo(_bar), но опять же, я лично не верю, что это добавляет много.

Если вы работаете с существующим кодом, соблюдайте там соглашение, в противном случае выберите тот, который сделает вас наиболее продуктивным и эффективным.

Answer 3

Мое эмпирическое правило: никогда не используйте «это», если оно избыточно. В этом случае «это» является излишним, поэтому я бы избегал этого. Такой инструмент, как ReSharper, очень хорошо скажет вам, когда это так.

Answer 4

Я всегда использую this., чтобы было ясно, что я имею в виду члена класса, а не локальную переменную.

Answer 5

нет абсолютно никаких причин не использовать это. даже избыточность не является причиной, чтобы вообще не использовать ее. Вы можете воспользоваться преимуществом поля intellisense для безопасного завершения кода и экономии своего времени, выбирая правильную переменную с помощью клавиши «вниз», а не постоянно портить клавиатуру.

Answer 6

Должен ли я использовать "this" со всеми вхождениями переменных класса в классе?

В вашем конкретном случае НЕТ.

Рассмотрим, однако, следующий пример:

class RssReader
{
    private String url;

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

        // vs.

        new XmlTextReader (this.url);

        return true;
    }
}

Здесь вам нужно указать this для доступа к переменной экземпляра, имя которой совпадает с именем аргумента метода.

Answer 7

Хорошо.Тем более, что у вашего класса нет базового класса, а частные поля названы соответствующим образом.ReSharper считает this в вашем случае избыточным.

Answer 8

Я бы постарался быть последовательным, чтобы люди не смущались, думая, что те немногие, которые вы делаете другим способом (помимо того, что вы обычно выбираете), имеют какое-то особое значение.

Если вы не используете какое-либо соглашение об именах для полей, то вы должны использовать его последовательно, потому что в противном случае возникнут проблемы, когда конструкторы примут какой-либо параметр и попытаются вставить любое поле.

Answer 9

Вы можете, но не обязательно, если это не метод, который принимает аргументы с теми же именами, что и ваши классовые переменные (для их различения).

Answer 10

Вот как я на это смотрю. Когда вы вызываете член (будь то метод, свойство или поле) класса, такого как DoMyThing(); или return Property; в пределах области действия экземпляра, необязательно вызывать элемент экземпляра. DoMyThing или Property также могут быть статическими членами.

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

Для них обоих (статических и экземпляров) я ничего не ставил перед префиксами. На самом деле мой выбор:

1. не префикс, как указано выше

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

2. префикс только для членов экземпляра

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

3. префикс для статических элементов

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

4. префикс в обоих случаях

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

Этот ответ не означает, что один стиль лучше, чем другой. Это всего лишь личные предпочтения. У каждого свои претензии на корректность и читабельность.

Мой дубль:

а. Мне, например, не нравится несовместимый стиль 2. и 3.

б. 1. имеет преимущество в том, что для меня это более читабельно. Префикс делает это больше об определении, чем намерении.

с. 4. все о правильности. Его преимущество в том, что он чрезвычайно последовательный, особенно если учесть, что вы в любом случае будете вынуждены использовать префикс для instance и static . Это еще более важно учитывать, когда речь идет о ключевом слове base, где, если вы не префикс с ключевым словом base для члена базового класса, то добавление члена с тем же именем в текущий производный класс приведет к тому, что он переопределит предыдущий звоните, меняя всю динамику.

Лично я бы пошел с 1. И использовал this или Abc экономно, когда меня принуждали. Для меня это более читабельно, для меня это достаточно хорошо, чтобы компенсировать небольшую несогласованность, которую может вызвать.