Зачем нам нужны свойства В C#
можете ли вы сказать мне, каково точное использование свойств в C# я имею в виду практическое объяснение
в нашем проекте мы используем такие свойства, как
/// <summary>
/// column order
/// </summary>
protected int m_order;
/// <summary>
/// Get/Set column order
/// </summary>
public int Order
{
get { return m_order; }
set { m_order = value; }
}
/// <summary>
/// constructor
/// </summary>
/// <param name="name">column name</param>
/// <param name="width">column width</param>
/// <param name="order">column order</param>
public ViewColumn(string name, int width, int order)
{
//
// TODO: Add constructor logic here
//
m_name = name;
m_width = width;
m_order = order;
}
/// <summary>
/// returns the column name, width, and order in list view.
/// </summary>
/// <returns>string represent of the ViewColumn object</returns>
public override string ToString()
{
return (string.Format("column name = {0}, width = {1}, order = {2}.",
m_name, m_width, m_order));
}
/// <summary>
/// Do a comparison of 2 ViewColumn object to see if they're identical.
/// </summary>
/// <param name="vc">ViewColumn object for comparison</param>
/// <returns>True if the objects are identical, False otherwise.</returns>
public override bool Equals(object obj)
{
ViewColumn vc = (ViewColumn)obj;
if(m_name == vc.Name &&
m_width == vc.Width &&
m_order == vc.Order)
return true;
else
return false;
}
9 ответов
class Room {
public string sectionOne;
public string sectionTwo;
}
Room r = new Room();
r.sectionOne = "enter";
люди попадают в sectionOne довольно легко, не было никакой проверки.
class Room
{
private string sectionOne;
private string sectionTwo;
public string SectionOne
{
get
{
return sectionOne;
}
set
{
sectionOne = Check(value);
}
}
}
Room r = new Room();
r.SectionOne = "enter";
теперь вы проверили человека и знаете, есть ли у него что-то злое с ним.
короткий ответ: инкапсуляция
длинный ответ: свойства очень разнообразны. Он позволяет выбрать способ предоставления данных внешним объектам. При установке значений можно ввести некоторый объем проверки данных. Он также aliviates головная боль 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 позаботиться об этом.
Это способ использовать его, за исключением того, как вы его устанавливаете, возможно. Вместо доступа к переменной-члену может потребоваться использовать свойство из класса, чтобы можно было использовать единообразные правила для каждой переменной-члена. Это основное преимущество использования свойств, чтобы привести логику доступа и сеттера все в одном месте. Это действительно зависит от ваших конкретных потребностей, хотите ли вы установить его с помощью свойства или нет. Обратите внимание, что в конструкторе вы хотите быть очень осторожными при вызове свойства, так как вы можете или не можете полагаться на другие части инициализируемого класса, которые еще не были бы выполнены при доступе через конструктор. Опять же, это зависит от конкретной реализации.
это также немного чище, чтобы использовать:
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...
}
}
свойства используются для ограничения прямого доступа к переменным-членам класса. Абстракция поддерживается с помощью свойств. Всякий раз, когда вы хотите создать экземпляр объекта и установить данные в его переменные-члены, используя свойство, вы можете проверить некоторые условия, будет ли значение установлено в переменную-член или нет. Вы можете ограничить запись чтения свойством, чтобы значение переменной-члена можно было только читать, только писать при доступе к объекту этого класса.
Преимущества Времени Разработки
свойства упрощает визуальное проектирование, у вас есть самый известный браузер свойств Visual Studio, позволяющий изменять свойства объекта.
свойства также предоставляют дополнительные метаданные проверки, визуальный внешний вид в браузере свойств, например, выпадающий список, диапазон, выбор цвета и т. д.
отдельные данные и действия
Они действительно представляют разницу между "данных" объектов и "действия" (методы) объекта.
когда мы смотрим на класс, если у нас есть 50 методов для просмотра, не все всегда будут использовать правильное именование функций, что затруднит понимание вещей позже. Я всегда говорю программистам, что всякий раз, когда вы программируете, напишите код таким образом, чтобы через 5 лет, если кто-то другой смотрит на код, он должен понять код.
используя имена методов доступа к данным и некоторые действия создают путаницу в долгосрочной перспективе... как и в случае стека, Push / Pop-это действия, но "размер" или "количество" - это данные.
создание свойства "Count" просто отличает его назначение как данные вместо действия.
привязка данных
Как упоминалось другими, свойства предлагают расширенный уровень привязки данных, как двусторонняя привязка и т. д.
Ограничение Доступа
вы можете иметь свойства readonly и дополнительные методы доступа, как указано другие.
отражение
его немного легко работать со свойствами в случае написания общего кода на основе отражения.
Различные Реализации Хранения
открытые переменные хранят данные только как члены, где еще свойства предоставляют различные способы хранения данных в разных формах, таких как internaly они могут храниться как hashtable (как это делается в объектах зависимостей в WPF). Их можно кэшировать. Они лихача передается далее некоторым другим дочерним сущностям или сущностям foriegn. Однако реализация скрыта для абонентов.
проверка
свойство Setting может потребовать определенной проверки, а код проверки в части " Set " кода может легко помочь вам проверить входные данные и сообщить об ошибках соответственно.
уведомления
установить часть метода может вызывать события уведомлений, такие как INotifyPropertyChanged.события PropertyChanged какие другие объекты могут прослушивать и обновлять отображаемое значение. Это важная часть расширенной привязки данных.
короче говоря, это новый "стандарт" хранения данных, который имеет передовые средства, а затем просто хранит данные в членах класса. Избегая свойств, как правило, вы можете выполнять все функции, но поскольку реализация может отличаться от человека к человеку, ее стандарт, который помогает каждому определить/получить доступ/проверить / уведомить хранилище данных в одной форме, называемой "Properties"
Как отметил Джастин, инкапсуляция является одним из основных принципов ООП. Вы хотели бы сохранить внутреннее представление данных в своем классе скрытым от внешнего мира и предоставить одобренные способы просмотра/управления им.
свойства C# - это конструкции, которые обеспечивают простой способ сделать это. В вашем примере вы ничего не делаете внутри get и set методы, но в реальной жизни вам может понадобиться, чтобы сделать некоторые вещи, как
- хранить валюту в 10-м копеек как длинное целое число, но вернуться во внешний мир в виде строки с 2 десятичных места и знак$.
- ограничить определенное свойство только для чтения (или даже только для записи: например:, класс генератора паролей/хэш-генератора).
- измените состояние объекта каким-либо образом, когда это значение установлено/get.
в Java вы пишете геттеры и сеттеры, которые являются простыми старыми методами, которые возвращают или принимают значение соответственно.