Почему я должен использовать закрытую переменную в методе доступа?

Question

Извините, если я noob, у меня есть это сомнение, почему мы используем частные переменные и устанавливаем их, используя свойства?

Почему мы не можем использовать только одни свойства?

Я говорю о таких ситуациях

private string _testVariable;

public string MyProperty
{
    get { return _testVariable;}
    set {_testVariable = value;}
}

Я думаю о простом использовании

public string MyProperty { get; set; } 

Почему избыточная приватная переменная? эти две стратегии разные? Может ли кто-нибудь, пожалуйста, пролить свет на это.

Спасибо

Answer 1

Ваши примеры семантически одинаковы. Синтаксис объявления краткого свойства (просто имеющий { get; set; }) - это ярлык, доступный в C # 3.0. Компилятор фактически создает приватную переменную поддержки и простой метод получения и установки, как в первом примере.

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

Answer 2

Почему избыточная приватная переменная? являются эти две стратегии разные? Можно Кто-нибудь, пожалуйста, пролить свет на это.

Если все, что вы делаете - это чтение / запись переменной, то нет. В противном случае есть две причины, по которым вам нужна закрытая переменная:

Проверка данных

// Data validation
public class IntWrapper
{
    private int _value;
    public int Value
    {
        get { return _value; }
        set
        {
            if (value < 0) { throw new Exception("Value must be >= 0"); }
            _value = value;
        }
    }
}

Получатель / установщик оборачивает основное хранилище данных

public class StringBuffer
{
    List<char> chars = new List<char>();

    // Wraps up an underlying data store
    public string Value
    {
        get { return new String(chars.ToArray()); }
        set { chars = new List<char>(value.ToCharArray()); }
    }

    public void Write(string s) { Write(chars.Count, s); }

    public void Write(int index, string s)
    {
        if (index > chars.Count) { throw new Exception("Out of Range"); }
        foreach(char c in s)
        {
            if (index < chars.Count) { chars[index] = c; }
            else { chars.Add(c); }
            index++;
        }
    }
}

Answer 3

Mashesh, Мы все должны были начать где-то! Вы спрашивали о частных свойствах vars vs с этим примером:

private string _testVariable;

public string MyProperty
{
    get { return _testVariable;}
    set {_testVariable = value;}
}

-or-

public string MyProperty { get; set; }

Рассматривали ли вы:

public string MyProperty { get; private set; }

Вы можете применить область действия к получателям / установщикам свойств. , , , отличная вещь. О да . , , при использовании этого типа свойства в пределах определяющего класса (как в конструкторе), добавьте к нему «this». - таким образом, назначение будет выглядеть как 'this.MyProperty = "Назначенная строка";'. Это делает ваши намерения намного более ясными. , .

Answer 4

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

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

Свойства auto в вашем втором фрагменте кода вообще не связаны с закрытой переменной. Дизайн авто-свойств, как и явный дизайн свойств, использованный в первом фрагменте, допускает будущие изменения. Например, в рамках этой модификации вы можете преобразовать свойства auto в явно реализованные свойства.

Answer 5

Второй пример, который вы приводите:

public string MyProperty { get; set; }

Доступно только в более поздних версиях .Net Framework (начиная с версии 3.0, я считаю)

Первый пример позволяет вам устанавливать точки останова в операторах return и присваивания, в результате чего отладчик прерывается при назначении / чтении свойства.

Answer 6

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

Очевидно, что если вам нужно сделать что-то особенное в геттере или сеттере, тогда следует использовать полную семантическую форму, а не сахар.

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

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

Вы можете обращаться к внутренней переменной, а также к свойству, так что это правильный путь? Это не очевидно ...

Answer 7

Это не относится к языку C #, но больше к приложению.

Одной из причин использования свойств является то, что во многих средах они рассматриваются как «Специальные». Например, Silverlight и WPF будут привязаны к свойствам, а не к полям

Answer 8

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

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

Answer 9

Свойство - это в основном оболочка вокруг поля. Эта оболочка позволяет использовать переменную из внешнего мира. В C # 3.0 вы можете просто объявить свойство как public string MyProperty { get; set; } Компилятор автоматически объявляет приватную переменную и для этого также получает набор методов. Если вам нужно выполнить какие-либо вычисления внутри класса, который объявляет свойство, вам следует использовать для этого личное поле.