Как следствие, на привычную для методов реализацию накладывается целый ряд ограничений:
- Отсутствие set only свойств. А если еще точнее, то вообще сеттер не должен быть доступнее геттера. Т.е. вот этот код:
private object prop; public object Prop { set { prop = value; } }является таким же жидким говном, что и вот этот:
private object prop; public object Prop { protected get { return prop; } set { prop = value; } }
- Cохранения значения:
a.Prop = v1; var v2 = a.Prop;
Если бы Value было полем, то значения v1 и v2 очевидно были бы идентичны. Аналогично должно быть и в случае свойств. Поэтому логика чтения должна быть абсолютно симметрична логике записи. Вот такое говно:
private ClassB prop; public ClassB Prop { get { return prop; } set { if (someCondition) prop = value; } }и вот такое:
private static ClassB PropDefaultValue = new ClassB (); private ClassB prop; public ClassB Prop { get { return PropDefaultValue; } set { prop = value; } }и тем более такое:
private ClassB prop; public ClassB Prop { get { return prop; } set { } }писать недопустимо. Последнее, кстати, вообще за гранью. Входное значение в сеттере свойства должно использоваться всегда. Приятно, что Resharper умеет такие вещи находить, правда подсвечивает их по умолчанию как Warning.
- Безопасное чтение:
static void Main(string[] args) { var a = new ClassA(); var v1 = a.Prop; }Любое обращение к свойству (как и к полю) в любом месте приложения не должно приводить к исключению (за вычетом асинхронных).
- Независимость от количества обращений. Вот такой код:
var v1 = new ClassB(); a.Prop = v1;
должен давать точно такой же результат, что и, например, такой:
var a = new ClassA(); var v1 = new ClassB(); var v2 = new ClassB(); a.Prop = v1; a.Prop = v2; a.Prop = v1;
И почти то же самое с чтением. Почти, потому что в многопоточной среде между двумя чтениями в одном потоке может произойти запись в другом. Поэтому, с одной стороны,
за пределами критических секций нельзя рассчитывать, что два чтения свойства подряд:
var v1 = a.Prop; var v2 = a.Prop;
дадут одинаковый результат, а с другой стороны, это нихуя не повод писать свойства так, чтобы правило нарушалось внутри критической секции.
- Независимость свойств друг от друга. Например, результаты выполнения
var a = new ClassA(); var v1 = new ClassB(); var v2 = new ClassC(); a.Prop1 = v1; a.Prop2 = v2;
и
var a = new ClassA(); var v1 = new ClassB(); var v2 = new ClassC(); a.Prop2 = v2; a.Prop1 = v1;
должны быть идентичны. Если проблемы с соблюдением предыдущих правил, за исключением отдельных крайне извращенных единичных случаев, могут быть только по причине особой недоразвитости говнокодера, то с соблюдением этого правила вполне объективные проблемы могут наступить при наличии большого количества вычислимых свойств, если их значения кэшируются. Кэш надо обновлять, или, как минимум, помечать невалидным, при изменении любого из участвующих в вычислении значений. Которые, в свою очередь, тоже могут быть вычислимыми. Ну и так далее. В результате, кроме возможных циклических зависимостей и лишних обновлений, велика вероятность банально забыть добавить в сеттер какого-нибудь из свойств код, обновляющий какой-нибудь из зависимых кэшей.
Описанная проблема имеет мало отношения к конкретной логике вычисления значений свойств, поэтому она вполне прилично решается средствами AOP (тем же PostSharp'ом) или кодогенерации (с помощью того же T4).
Отдельный независимый набор проблем добавляют виртуальные свойства:
- C# не позволяет сделать виртуальным только геттер или сеттер.
- Если в базовом абстрактном классе у абстрактного свойства определен только геттер:
public abstract class ClassA { public abstract ClassX Prop { get; } }то в наследнике переопределить геттер и добавить сеттер уже нельзя:
public class ClassB : ClassA { private ClassX prop; public override ClassX Prop { get { return prop; } set { prop = value; } // ClassB.Prop.set': cannot override because 'ClassA.Prop' does not have an overridable set accessor } }И даже говномодификатор new тут не поможет:
public class ClassB : ClassA { private ClassX prop; public new ClassX Prop { get { return prop; } set { prop = value; } // 'ClassB.Prop' hides inherited abstract member 'ClassA.Prop.get' } }
- Если интерфейс описывает свойство с геттером и сеттером, а в базовом классе это свойство также присутствует, но, например, сеттер не публичный, то реализовать интерфейс в наследнике можно только как explicit:
public interface I1 { int Prop { get; set; } } public class ClassBase { public int Prop { get; internal set; } } public class ClassDerived : ClassBase, I1 { int I1.Prop { get { return Prop; } set { Prop = value; } } }Кстати тут, в отличие от предыдущего случая, модификатор new, к сожалению, вполне применим:
public interface I1 { int Prop { get; set; } } public class ClassBase { public int Prop { get; internal set; } } public class ClassDerived : ClassBase, I1 { public new int Prop { get { return base.Prop; } set { base.Prop = value; } } }
Своя специфическая квадрожопа связана с DependencyProperty. Не, сама идея просто ахуенна, но реализация, чтоб ее, сосет у всего квартала. Рассказ в деталях о всех проблемах реализации DependencyProperty в WPF - это тема нескольких отдельных постов, поэтому здесь только о том, что непосредственно относится к свойствам:
public class ClassA : DependencyObject { public static readonly DependencyProperty PropProperty = DependencyProperty.Register("Prop", typeof(int), typeof(ClassA), new PropertyMetadata(0, (_1,_2) => {}, CoerceValue), Validate); private static object CoerceValue(DependencyObject d, object basevalue) { var r = (int) basevalue; return r*2; } private static bool Validate(object value) { return (value is int); } public int Prop { get { return (int)GetValue(PropProperty); } set { SetValue(PropProperty, value); } } }Метод CoerceValue полностью нарушает правило сохранения значения, но, к сожалению, является жизненной необходимостью - другого способа корректировать значения, полученные через биндинг, нет, а использовать ValueConverter'ы в общем случае не вариант, потому что корректировка может относиться к свойству, а не к конкретному биндингу. Т.о., использование фреймворка вступает в прямой конфликт с гайдлайнами языка.
public class ClassA : DependencyObject { public static readonly DependencyProperty PropProperty = DependencyProperty.Register("Prop", typeof(int), typeof(ClassA), new PropertyMetadata(0, (_1,_2) => {}, CoerceValue), Validate); private static object CoerceValue(DependencyObject d, object basevalue) { var r = (int) basevalue; if (r < 10) throw new ArgumentOutOfRangeException(); return basevalue; } private static bool Validate(object value) { return (value is int); } public int Prop { get { return (int)GetValue(PropProperty); } set { SetValue(PropProperty, value); } } } public class ClassB : ClassA { static ClassB() { PropProperty.OverrideMetadata(typeof(ClassB), new PropertyMetadata(0, (_1, _2) => { }, CoerceValue)); } private static object CoerceValue(DependencyObject d, object basevalue) { var r = (int)basevalue; if (r > 20) throw new ArgumentOutOfRangeException(); return basevalue; } }Здесь строевым шагом пошел по пизде LSP, потому что CoerceValue базового класса в наследнике не вызовется. Чтобы он вызвался, нужно переписать метод вот так:
private static object CoerceValue(DependencyObject d, object basevalue) { var basePM = PropProperty.GetMetadata(typeof(ClassB).BaseType); var baseCoerce = basePM.CoerceValueCallback; var value = baseCoerce != null ? baseCoerce(d, basevalue) : basevalue; var r = (int)value; if (r > 20) throw new ArgumentOutOfRangeException(); return value; }Вроде бы все хорошо, но беда в том, что эта схема через жопу. Это совсем не то же самое, что использовать ключевое слово base. Более того, ни в MSDN, ни в большинстве книг по WPF про этот ньюанс ни слова. Как результат, в процессе жизни приложения наследник даже не заметит, что в базовом классе у DependencyProperty появился/удалился CoerceValueCallback, со всеми вытекающими. Ровно как и не заметиn появления промежуточного класса между базовым и наследником, как минимум на этапе компиляции.
Однако несмотря на все вышеперечисленные особенности, свойства - охуенная возможность языка С#, и ими обязательно надо пользоваться. Главное - знать, как.
Комментариев нет:
Отправить комментарий