Почему нам нужны Свойства в C#

Краткий ответ: Инкапсуляция

Длинный ответ: Свойства очень универсальны. Это позволяет вам выбирать, как вы хотите предоставлять свои данные внешним объектам. Вы можете ввести некоторый объем проверки данных при установке значений. Это также устраняет головную боль методов getX () и setX () , которые можно встретить в подобных Java и т. Д.

Множество причин:

• Семантика. Свойства отделяют реализацию вашего типа от интерфейса.
• Двоичная совместимость. Если вам когда-либо понадобится изменить свойство, вы можете сделать это, не нарушая двоичную совместимость зависимого кода. С полями вы должны перекомпилировать все , даже если новая реализация использует свойство с тем же именем.
• Привязка данных. Вы не можете привязать данные к полю.

Вот общий шаблон:

class Foo {

    private Bar _bar;

    //here, Foo has a Bar object.  If that object has already been instantiated, return that value.  Otherwise, get it from the database.
    public Bar bar {
        set { _bar = value;}
        get {
            if (_bar == null) {
                _bar = Bar.find_by_foo_name(this._name);
            }
            return _bar;
        }
    }
}

Короче говоря, это позволяет нам получить доступ к объекту Bar в нашем экземпляре Foo. Эта инкапсуляция означает, что нам не нужно беспокоиться о том, как извлекается Bar, или о том, что foo.bar уже был создан. Мы можем просто использовать объект, а внутренности класса Foo позаботятся об этом.

Design Time Benefits

Properties makes visual designing easy, you have Most Famous Property Browser of Visual Studio to allow you to change properties of object.

Properties also provide additional metadata of validation, visual appearance inside Property Browser, like drop down, range, color picker etc.

Seperate Data and Actions

They truely represent difference between "Data" of object and "Actions" (Methods) of object.

When we look at class, if we have 50 methods to look at, not everyone will always use correct naming of functions, that will make things difficult to understand later on. I always tell the programmers that whenever you program, write the code in such a way that after 5 years, if someone else looks at the code, he should understand the code.

Using method names of data access and some actions create confusion in long run... like in case of Stack, Push/Pop are actions but "Size" or "Count" is data.

Creating property of "Count" simply distinguishes its purpose as data instead of action.

Databinding

As mentioned by others, properties offer advanced level of databinding like two way binding etc.

Access Restrictions

You can have readonly properties and additional accessors as mentioned by others.

Reflection

Its little easy to work with properties in case of writing generic code based on reflection.

Different Storage Implementation

Public variables store data only as members, where else properties provide various ways to store data in different forms like internaly they can be stored as hashtable (as they are done in dependency objects in WPF). They can be cached. They cab be relayed further to some other child entities or foriegn entities. However implementation is hidden for callers.

Validation

Setting property may require certain validation, and validation code in "Set" part of code can easily help you validate the input and report errors accordingly.

Notifications

Set part of method can raise notification events such as INotifyPropertyChanged.PropertyChanged which other objects can listen for and update the display value. This is important part of advanced data binding.

In short, its a new "Standard" of data storage that has advanced facilities then just mere storing the data in the members of class. By avoiding properties typically you can perform all functions, but since implementation may differ from person to person, its a standard which helps everyone to define/access/validate/notify the data storage in one single form called "Properties"

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

Это также немного чище в использовании:

myObject.Property1 = "Test String";
Console.WriteLine(myObject.Property1);

Чем то, что вы видите на некоторых других языках:

myObject.setProperty1("Test String");
System.out.writeln(myObject.getProperty1());

Вот случай, когда вы можете инкапсулировать некоторую логику:

public int Order
{
    get { return m_order; }
    set
    {
        // Put some rules checking here. Maybe a call to make sure that the order isn't duplicated or some other error based on your business rules.
        m_order = value;
    }
}

Еще один способ их использования:

public int Order { get; private set; }

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

Наконец, если вам нужно управлять логикой, вы можете написать это:

public int Order
{
    get { return m_order; }
    protected set
    {
        // Again, you can do some checking here if you want...
        m_order = value;
        // You can also do other updates if necessary. Perhaps a database update...
    }
}

Как заметил Джастин, инкапсуляция является одним из основные принципы ООП. Вы бы хотели сохранить внутреннее представление данных в вашем классе скрытым извне и предоставить одобренные способы просмотра / управления им.

Свойства C # - это конструкции, которые предоставляют простой способ сделать это. В вашем примере вы ничего не делаете внутри методов get и set , но в реальной жизни вам может потребоваться сделать некоторые вещи, например,

• Хранить валюту в 10 центов, как длинное целое число, но возвращение во внешний мир в виде строки с двумя десятичными пробелами и знаком $.
• Ограничить определенное свойство как доступное только для чтения (или даже только для записи: например:, средство проверки пароля / генератор хэшей) учебный класс).

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