INotifyPropertyChanged vs DependencyProperty di ViewModel

Ketika menerapkan ViewModel dalam arsitektur Model-View-ViewModel aplikasi WPF tampaknya ada dua pilihan utama bagaimana membuatnya menjadi dataable. Saya telah melihat implementasi yang digunakan DependencyPropertyuntuk properti yang akan diikat oleh View dan saya telah melihat implementasi ViewModel INotifyPropertyChangedsebagai gantinya.

Pertanyaan saya adalah kapan saya harus memilih yang satu daripada yang lain? Apakah ada perbedaan kinerja? Apakah benar-benar ide yang baik untuk memberikan dependensi ViewModel ke WPF? Apa lagi yang perlu saya pertimbangkan ketika membuat keputusan desain?

Kent menulis blog yang menarik tentang topik ini: Lihat Model: POCO versus DependencyObjects .

Ringkasan singkat:

1. DependencyObjects tidak ditandai sebagai serializable
2. Kelas DependencyObject menimpa dan menyegel metode Equals () dan GetHashCode ()
3. DependencyObject memiliki afinitas utas - ia hanya dapat diakses pada utas tempat ia dibuat

Saya lebih suka pendekatan POCO. Kelas dasar untuk PresentationModel (alias ViewModel) yang mengimplementasikan antarmuka INotifyPropertyChanged dapat ditemukan di sini: http://compositeextensions.codeplex.com

Menurut panduan kinerja WPF, DependencyObjects jelas berkinerja lebih baik daripada POCO yang menerapkan INotifyPropertyChanged:

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

Pilihannya sepenuhnya didasarkan pada logika bisnis dan tingkat abstraksi UI Anda. Jika Anda tidak ingin pemisahan yang baik maka DP akan bekerja untuk Anda.

DependencyProperties akan berlaku terutama di tingkat VisualElements sehingga tidak akan menjadi ide bagus jika kita membuat banyak DP untuk masing-masing persyaratan bisnis kita. Juga ada biaya yang lebih besar untuk DP daripada INotifyPropertyChanged. Ketika Anda mendesain WPF / Silverlight, cobalah untuk merancang UI dan ViewModel yang benar-benar terpisah sehingga pada suatu titik waktu kami dapat mengubah tata letak dan kontrol UI (Berdasarkan tema dan Gaya)

Lihat posting ini juga - /programming/275098/what-applications-could-i-study-to-understand-datamodel-view-view-viewmodel . Tautan ini memiliki banyak referensi ke pola Model-View-ViewModel, yang sangat relevan dengan diskusi ini.

Dari sudut pandang ekspresif, saya benar-benar menikmati menggunakan properti ketergantungan dan ngeri pada pemikiran INotifyPropertyChanged. Terlepas dari stringnama properti dan kemungkinan kebocoran memori karena berlangganan acara, INotifyPropertyChangedadalah mekanisme yang jauh lebih eksplisit.

Ketergantungan properti menyiratkan "saat ini, lakukan itu" menggunakan metadata statis yang mudah dipahami. Ini adalah pendekatan deklaratif yang mendapatkan suara saya untuk keanggunan.

INotifyPropertyChanged ketika digunakan juga memberi Anda kemampuan untuk menambahkan lebih banyak logika dalam kode pengambil dan penyetel properti Anda.

DependencyProperty contoh:

public static DependencyProperty NameProperty = DependencyProperty.Register( "Name", typeof( String), typeof( Customer ) );

public String Name
{
    set { SetValue( NameProperty, value ); }
    get { return ( String ) GetValue( NameProperty ); }
}

Dalam pengambil dan penyetel Anda --- yang dapat Anda lakukan hanyalah memanggil SetValue dan GetValue masing-masing, b / c di bagian lain dari kerangka pengambil / penyetel tidak dipanggil, alih-alih secara langsung memanggil SetValue, GetValue, sehingga logika properti Anda tidak akan dieksekusi dengan andal.

Dengan INotifyPropertyChanged, tentukan acara:

public event PropertyChangedEventHandler PropertyChanged;

Dan kemudian cukup sediakan logika apa pun di dalam kode Anda, lalu panggil:

// ...
// Something cool...
// ...

if( this.PropertyChanged != null )
{
    PropertyChanged( this, new PropertyChangedEventArgs( "Name" ) );
}

// More cool stuff that will reliably happen...

Ini bisa dalam pengambil / penyetel, atau di tempat lain.

Properti ketergantungan dimaksudkan untuk mendukung pengikatan (sebagai target) pada elemen UI bukan sebagai sumber pengikatan data, ini adalah tempat INotifyProperty masuk. Dari sudut pandang murni Anda tidak boleh menggunakan DP pada ViewModels.

"Untuk menjadi sumber ikatan, properti tidak perlu menjadi properti dependensi; Anda dapat menggunakan properti CLR sebagai sumber mengikat. Namun, untuk menjadi target dari ikatan, properti harus menjadi properti ketergantungan. Agar pengikatan satu arah atau dua arah menjadi efektif, properti sumber harus mendukung pemberitahuan perubahan yang menyebar ke sistem pengikatan dan dengan demikian target. Untuk sumber pengikatan CLR kustom, ini berarti bahwa properti tersebut harus mendukung INotifyPropertyChanged. Koleksi harus mendukung INotifyCollectionChanged. "

Semua objek ketergantungan tidak dapat diserialisasi (Ini bisa menghambat penggunaan ViewModels dan DTO (POCO).

Ada perbedaan antara DP dalam Silverlight dibandingkan dengan WPF.

http://msdn.microsoft.com/en-us/library/cc221408(v=VS.95).aspx

http://msdn.microsoft.com/en-us/library/cc903933(VS.95).aspx

Saya juga harus mempertimbangkan keputusan ini baru-baru ini.

Saya menemukan bahwa mekanisme INotifyPropertyChanged cocok dengan kebutuhan saya lebih baik karena memungkinkan saya untuk menempelkan GUI ke kerangka kerja logika bisnis yang ada tanpa status duplikasi. Kerangka kerja yang saya gunakan memiliki pola pengamat sendiri dan mudah untuk meneruskan satu tingkat pemberitahuan ke yang berikutnya. Saya hanya punya kelas yang mengimplementasikan antarmuka pengamat dari kerangka kerja logika bisnis saya dan antarmuka INotifyPropertyChanged.

Dengan DP Anda tidak dapat menentukan backend yang menyimpan negara sendiri. Saya harus membiarkan .net cache salinan setiap item negara saya mengikat. Ini seperti overhead yang tidak perlu - kondisi saya besar dan rumit.

Jadi di sini saya menemukan INotifyPropertyChanged lebih baik untuk mengekspos properti dari logika bisnis ke GUI.

Itu dikatakan di mana saya membutuhkan widget GUI khusus untuk mengekspos sebuah properti dan untuk perubahan pada properti itu untuk mempengaruhi widget GUI lainnya, DP membuktikan solusi sederhana.

Jadi di sana saya menemukan DP berguna untuk notifikasi GUI ke GUI.

Apakah benar-benar ide yang baik untuk memberikan dependensi ViewModel ke WPF?

.NET 4.0 akan memiliki System.Xaml.dll, jadi Anda tidak perlu lagi bergantung pada kerangka kerja sewenang-wenang untuk menggunakannya. Lihat posting Rob Relyea tentang sesi PDC-nya.

Saya ambil

XAML adalah bahasa untuk mendeskripsikan objek, dan WPF adalah kerangka kerja yang menggambarkan objek adalah elemen UI.

Hubungan mereka mirip dengan C #, bahasa untuk menggambarkan logika, dan .NET, suatu kerangka kerja yang mengimplementasikan jenis logika tertentu.

Tujuan XAML adalah grafik objek deklaratif. Teknologi W * F adalah kandidat yang bagus untuk paradigma ini, tetapi XAML ada secara independen dari mereka.

XAML dan seluruh sistem ketergantungan diimplementasikan sebagai tumpukan terpisah untuk WF dan WPF, mungkin untuk meningkatkan pengalaman tim yang berbeda tanpa menciptakan ketergantungan (tidak ada permainan kata-kata) di antara mereka.

Ketergantungan properti adalah perekat pembuatan kontrol kustom. Jika Anda tertarik menggunakan Intelli-sense untuk menunjukkan properti Anda di jendela properti pada waktu desain XAML, Anda harus menggunakan properti Ketergantungan. INPC tidak akan pernah menampilkan properti di jendela properti pada waktu desain.

Tampaknya Properti Ketergantungan harus digunakan dalam kontrol yang Anda buat seperti Tombol. Untuk menggunakan properti di XAML dan menggunakan semua fitur WPF, properti tersebut harus Dependency Properties.

Namun, ViewModel Anda lebih baik menggunakan INotifyPropertyChanged. Menggunakan INotifyPropertyChanged akan memberi Anda kemampuan untuk memiliki logika pengambil / penyetel jika perlu.

Saya sarankan memeriksa versi Josh Smith dari kelas dasar untuk ViewModel yang sudah mengimplementasikan INotifyPropertyChanged:

http://joshsmithonwpf.wordpress.com/2007/08/29/a-base-class-which-implements-inotifypropertychanged/

Saya pikir ini adalah contoh yang bagus tentang cara melakukan ViewModel.

Saya pikir DependencyProperty dan INotifyPropertyChanged digunakan untuk dua hal berbeda di Binding: yang pertama untuk memungkinkan properti menjadi target pengikatan dan menerima input dari properti lain (gunakan {Binding ...} untuk mengatur properti), yang terakhir saat Anda ingin nilai properti digunakan sebagai sumber pengikatan (nama dalam Ekspresi Jalur Binding). Jadi pilihannya hanyalah teknis.

Saya lebih suka pendekatan yang lebih langsung, yang saya blogging tentang dalam Model Presentasi Tanpa INotifyPropertyChanged . Menggunakan alternatif untuk pengikatan data, Anda dapat mengikat langsung ke properti CLR tanpa kode pembukuan. Anda hanya menulis kode .NET tua-polos di Model Tampilan Anda, dan itu diperbarui ketika Model Data Anda berubah.

Hanya ada satu hal mengapa memilih DependencyObject- Mengikat akan bekerja lebih baik. Coba saja contoh dengan ListBoxdan TextBox, isi daftar dengan data dari INotifyPropertyChangedproperti vs. DependencyPropertydan edit item saat ini dari TextBox...

Jika Anda ingin mengekspos properti ke kontrol lain, Anda harus menggunakan properti Ketergantungan ... Tapi semoga berhasil karena butuh waktu untuk mencari tahu ...