INotifyPropertyChanged или DependencyProperty

Ответ 1

Использование памяти: INotifyPropertyChanged - это интерфейс, который близок к нулевому издержкам памяти. "Близко к нулю", потому что я предполагаю, что вы будете писать метод OnPropertyChanged и, возможно, некоторые обработчики событий в других классах (если только вы не просто говорите о привязке к WPF), значит, будут небольшие накладные расходы кода.

Производительность: DependancyProperties много распространяются под обложками. Если вы не напишете самый неэффективный метод OnPropertyChanged, я бы сделал ставку на то, что INotifyPropertyChanged также станет победителем.

Если у вас нет определенной причины для желания/необходимости поведения, предоставляемого DP, я бы просто пошел с INotifyPropertyChanged.

Обновление

В комментариях упоминается, что производительность привязки немного выше для DP (на 15-20% быстрее, но все же только разница менее 50 мс для 1000 привязок) из-за количества отражений, необходимых для поиска/подключения прямого свойства. Это технически отличается от производительности по обновлению элемента пользовательского интерфейса с привязкой к базе данных, к чему привязывался мой комментарий. Но это не значит, что моя ставка все еще правильна. Таким образом, несколько примеров и много инструментов .NET Reflector digger позже выглядят... неубедительными. Оба пути делают тонну работы под обложками, и я не смог получить никаких примеров, чтобы показать определенную разницу в производительности обновления.

Я все еще придерживаюсь INotifyPropertyChanged, если у меня нет специфической потребности в DP, но это было, по крайней мере, интересное упражнение, чтобы еще больше заглянуть в ядро ​​WPF.:)

Ответ 2

Ничего, я просто нашел ответы, которые я искал в следующих question.

Я отвечу на ответ "LBugnion" (так что все кредиты идут ему) для вашего удобства:

Реализация INotifyPropertyChanged имеет много преимуществ перед DependencyObjects (я сокращу это DO, чтобы упростить его) и используя DependencyProperties (DP):

• Это более легкий
• Позволяет вам больше свободы в моделировании ваших объектов.
• Может быть легко сериализовано
• Вы можете поднять событие, когда захотите, что может быть полезно в определенных сценариях, например, если вы хотите связать несколько изменений только в одной операции пользовательского интерфейса или когда вам нужно поднять событие, даже если данные не были изменить (принудительно перерисовать...)

С другой стороны, наследование ДО в WPF имеет следующие преимущества:

• Легче реализовать особенно для новичков.
• Вы получаете механизм обратного вызова (почти) бесплатно, позволяя вам получать уведомление, когда изменяется значение свойства
• Вы получаете механизм принуждения, позволяющий определять правила для max, min и текущего значения свойства.

Существуют и другие соображения, но они являются основными.

Я думаю, что общий консенсус в том, что DP отлично подходят для элементов управления (и вы можете реализовать CustomControl с настраиваемыми DP даже в Silverlight), но для объектов данных лучше использовать INotifyPropertyChanged.

HTH, Лоран

Ответ 3

Как сообщает MSDN, WPF быстрее привязывается к DependencyProperties, чем к пользовательским объектам CLR, используя INotifyPropertyChanged.

См. http://msdn.microsoft.com/en-us/library/bb613546.aspx

Ответ 4

IMHO, INotifyPropertyChanged очень легкий и простой в использовании по сравнению с DP. Что касается производительности/памяти, вам действительно нужно знать? Кнут хочет знать.

Очевидно, вы должны определить свои требования и посмотреть, сколько DP вы ожидаете создать/секунду, как долго они живут, и провести несколько тестов. Я сделал это раньше и не видел никаких проблем с созданием недолгого DP при ~ 10 к/сек (YMMV).

Ответ 5

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

Ответ 6

Это очень интересный и важный вопрос ИМХО. Я проверил его на следующей чистой (без привязки) задаче. DP как факт должен быть очень быстрым... (100.. свойства каждого стандартного управления, анимативные) Итак, проблема

Предположим, что оси координат 3D. Мы помещаем ярлыки как x, y и z рядом с каждой осью. 3D-рендеринг текста в WPF относительно тяжелая работа WPF 3D Perfomance

Задача - это обнаружение ротацией меток при вращении мыши в трехмерной сцене, когда метки имеют прямой вид для пользователя (при трехмерном повороте сцены они переводятся с осями, но вращаются специальным образом). Эта задача решается с помощью той же функции CallBack. Реализация выглядит следующим образом:

• Подход - INotifyPropertyChanged включает)

  Открытое свойство T3D_LabelAngleX() As Double Получить Вернуться _T3D_LabelAngleX Конец Get Set (значение ByVal As Double) _T3D_LabelAngleX = значение t3d_SetLabelTransform() Конец Конечное свойство

• Подход - DP

  Публичный общий ReadOnly MDS_AngleLabelRotation_XProperty As DependencyProperty = _ DependencyProperty.Register( "MDS_AxisAngleRotation_X", _ GetType (Double), GetType (MainDecartsSystem), _ Новый PropertyMetadata (MDS_AngleLabelRotation_XDefault, AddressOf MDS_RotationChanged))

  Public Property MDS_AngleLabelRotation_X() As Double
      Get
          Return CType(GetValue(MDS_AngleLabelRotation_XProperty), Double)
      End Get
      Set(ByVal value As Double)
          SetValue(MDS_AngleLabelRotation_XProperty, value)
      End Set
  End Property
  

  Фокус MDS_RotationChanged и t3d_SetLabelTransform() равно. . Моя бедная мышь... Оба очень БЫСТРО! Я не мог обнаружить никакой разницы. Кажется, что DP немного быстрее, наверное... (я не уверен). Спасибо за вопрос.