Dalam kondisi apa penggunaan MVVM sesuai?

Model View View-Model dikembangkan oleh Microsoft untuk menargetkan platform pengembangan UI yang mendukung pemrograman berbasis acara, khususnya Windows Presentation Foundation (WPF) dan Silverlight pada platform .NET menggunakan bahasa XAML dan .NET. Sejak itu, banyak kerangka kerja Javascript seperti Angular, Knockout dan ExtJS telah mengadopsi pola tersebut.

Seperti kebanyakan pola perangkat lunak, MVVM memiliki kegunaan yang tepat, dan penyalahgunaannya. Dalam kondisi apa penggunaan MVVM sesuai? Kapan itu keliru?

MVVM dimaksudkan untuk digunakan di mana interaksi pengguna yang kompleks menggunakan UI dengan kesetiaan tinggi diperlukan (yaitu WPF ).

MVVM ditargetkan pada platform pengembangan UI modern (Windows Presentation Foundation, atau WPF, dan Silverlight) di mana terdapat pengembang pengalaman pengguna (UXi) yang memiliki persyaratan berbeda dari persyaratan pengembang yang lebih "tradisional" (misalnya berorientasi pada logika bisnis dan pengembangan back end). View-Model MVVM adalah "pada dasarnya konverter nilai pada steroid," yang berarti bahwa View-Model bertanggung jawab untuk mengekspos objek data dari Model sedemikian rupa sehingga objek-objek tersebut mudah dikelola dan dikonsumsi. Dalam hal ini, View-Model lebih Model dari View, dan menangani sebagian besar jika tidak semua logika tampilan.

MVVM dirancang untuk memanfaatkan fungsi-fungsi khusus dalam WPF untuk lebih memudahkan pemisahan pengembangan lapisan View dari sisa pola dengan menghapus hampir semua "kode-belakang" dari lapisan View. Alih-alih mengharuskan Desainer Interaktif untuk menulis kode tampilan, mereka dapat menggunakan bahasa markup WPF asli XAML dan membuat binding ke ViewModel, yang ditulis dan dikelola oleh pengembang aplikasi. Pemisahan peran ini memungkinkan Desainer Interaktif untuk fokus pada kebutuhan UX daripada pemrograman atau logika bisnis, memungkinkan lapisan aplikasi dikembangkan di berbagai aliran pekerjaan.

Untuk UI di mana interaksi kaya seperti ini tidak diperlukan, MVVM mungkin berlebihan; MVP mungkin merupakan pilihan yang lebih alami. Untuk aplikasi web, MVC lebih cocok. Untuk aplikasi yang sangat kecil yang tidak akan pernah tumbuh lebih besar (seperti utilitas Winforms kecil), kode-belakang memadai.

Terkadang MVVM bisa menjadi jebakan. Dari pengalaman saya, itu mendukung aplikasi seperti CRUD (formulir lebih dari data) dibandingkan UI yang lebih berorientasi tugas. Saya tidak mengatakan bahwa itu menyiratkan arsitektur buruk untuk back end / orang lain lapisan dalam aplikasi tetapi saya telah melihat banyak aplikasi MVVM datang dengan arsitektur "DDD light". Saya tidak tahu mengapa sebenarnya mungkin karena pengikatannya sangat mudah dan sangat mudah untuk mengatur aplikasi dengan ORM dan MVVM / Binding menggunakan objek domain POCO / Anemic.

MVVM adalah bantuan pita untuk lapisan pengikat data yang dirancang dengan buruk. Secara khusus, ia telah melihat banyak digunakan di dunia WPF / silverlight / WP7 karena keterbatasan dalam pengikatan data di WPF / XAML.

Mulai sekarang, saya akan berasumsi kita berbicara tentang WPF / XAML karena ini akan membuat semuanya lebih jelas. Mari kita lihat beberapa kekurangan yang ingin diselesaikan oleh MVVM di WPF / XAML.

Bentuk data vs bentuk UI

The 'VM' di MVVM menciptakan satu set objek yang didefinisikan dalam C # yang memetakan ke set objek presentasi yang didefinisikan dalam XAML. Objek C # ini biasanya terhubung ke XAML melalui properti DataContext pada objek presentasi.

Akibatnya, grafik objek viewmodel perlu dipetakan ke grafik objek presentasi aplikasi Anda. Itu bukan untuk mengatakan bahwa pemetaan harus satu-ke-satu, tetapi jika kontrol daftar terkandung oleh kontrol jendela, maka harus ada cara untuk mendapatkan dari objek DataContext jendela ke objek yang menggambarkan data daftar itu.

Grafik objek viewmodel berhasil memisahkan model objek grafik dari grafik objek ui, tetapi dengan mengorbankan lapisan viewmodel tambahan yang harus dibangun dan dipelihara.

Jika saya ingin memindahkan beberapa data dari layar A ke layar B, saya perlu dipusingkan dengan model tampilan. Dalam benak seorang pebisnis, ini adalah perubahan UI. Itu harus terjadi murni di dunia XAML. Sayangnya, itu jarang bisa. Lebih buruk lagi, tergantung pada bagaimana viewmodels terstruktur dan seberapa aktif perubahan data, cukup banyak data re-routing yang diperlukan untuk mencapai perubahan ini.

Mengatasi ikatan data yang tidak ekspresif

Binding WPF / XAML tidak cukup ekspresif. Pada dasarnya Anda bisa menyediakan cara untuk sampai ke objek, jalur properti untuk dilalui, dan mengikat konverter untuk menyesuaikan nilai properti data dengan apa yang diminta objek presentasi.

Jika Anda perlu mengikat properti di C # ke sesuatu yang lebih kompleks dari itu, Anda pada dasarnya kurang beruntung. Saya belum pernah melihat aplikasi WPF tanpa konverter mengikat yang mengubah true / false menjadi Visible / Collapsed. Banyak aplikasi WPF juga cenderung memiliki sesuatu yang disebut NegatingVisibilityConverter atau sejenisnya yang membalik polaritas. Ini harus mematikan lonceng alarm.

MVVM memberi Anda panduan untuk menyusun kode C # yang dapat digunakan untuk memperhalus batasan ini. Anda dapat mengekspos properti pada model tampilan Anda yang disebut SomeButtonVisibility dan hanya mengikatnya ke visibilitas tombol itu. XAML Anda bagus dan cantik sekarang ... tetapi Anda telah menjadikan diri Anda sebagai pegawai toko - sekarang Anda harus mengekspos + memperbarui binding di dua tempat (UI dan kode dalam C #) saat UI Anda berkembang. Jika Anda perlu tombol yang sama berada di layar lain, Anda harus mengekspos properti serupa pada model tampilan yang dapat diakses layar itu. Lebih buruk lagi, saya tidak bisa hanya melihat XAML dan melihat kapan tombol akan terlihat lagi. Segera setelah binding menjadi sedikit tidak trivial, saya harus melakukan pekerjaan detektif dalam kode C #.

Akses ke data dibatasi secara agresif

Karena data umumnya masuk ke UI melalui properti DataContext, sulit untuk merepresentasikan data global atau sesi secara konsisten di seluruh aplikasi Anda.

Gagasan "pengguna yang saat ini masuk" adalah contoh yang bagus - ini seringkali benar-benar hal global dalam contoh aplikasi Anda. Dalam WPF / XAML sangat sulit untuk memastikan akses global ke pengguna saat ini secara konsisten.

Yang ingin saya lakukan adalah menggunakan kata "CurrentUser" di binding data secara bebas untuk merujuk ke pengguna yang saat ini masuk. Sebagai gantinya, saya harus memastikan bahwa setiap DataContext memberi saya cara untuk sampai ke objek pengguna saat ini. MVVM dapat mengakomodasi hal ini, tetapi model tampilan akan berantakan karena semuanya harus menyediakan akses ke data global ini.

Contoh di mana MVVM jatuh

Katakanlah kita memiliki daftar pengguna. Di sebelah setiap pengguna, kami ingin menampilkan tombol "hapus pengguna", tetapi hanya jika pengguna yang saat ini masuk adalah admin. Selain itu, pengguna tidak diizinkan untuk menghapus diri mereka sendiri.

Objek model Anda seharusnya tidak tahu tentang pengguna yang saat ini login - mereka hanya akan mewakili catatan pengguna dalam database Anda, tetapi entah bagaimana pengguna yang saat ini masuk perlu terkena bindings data dalam baris daftar Anda. MVVM menentukan bahwa kita harus membuat objek viewmodel untuk setiap baris daftar yang menyusun pengguna yang saat ini masuk dengan pengguna yang diwakili oleh baris daftar itu, lalu memaparkan properti yang disebut "DeleteButtonVisibility" atau "CanDelete" pada objek viewmodel itu (tergantung pada perasaan Anda) tentang mengikat konverter).

Objek ini akan terlihat sangat mirip dengan objek Pengguna dalam banyak cara lain - mungkin perlu mencerminkan semua properti objek model pengguna dan meneruskan pembaruan ke data tersebut saat ia berubah. Ini terasa sangat menjengkelkan - sekali lagi, MVVM membuat Anda menjadi pegawai dengan memaksa Anda untuk mempertahankan objek yang mirip dengan pengguna ini.

Pertimbangkan - Anda mungkin juga harus mewakili properti pengguna Anda dalam database, model, dan tampilan. Jika Anda memiliki API antara Anda dan database Anda, maka itu lebih buruk - mereka diwakili dalam database, server API, klien API, model, dan tampilan. Saya akan sangat ragu untuk mengadopsi pola desain yang menambahkan lapisan lain yang perlu disentuh setiap kali properti ditambahkan atau diubah.

Lebih buruk lagi, lapisan ini berskala dengan kompleksitas UI Anda, bukan dengan kompleksitas model data Anda. Seringkali data yang sama diwakili di banyak tempat dan di UI Anda - ini tidak hanya menambahkan lapisan, tetapi juga menambahkan lapisan dengan banyak area permukaan tambahan!

Bagaimana hal bisa terjadi

Dalam kasus yang dijelaskan di atas, saya ingin mengatakan:

<Button Visibility="{CurrentUser.IsAdmin && CurrentUser.Id != Id}" ... />

CurrentUser akan diekspos secara global ke semua XAML di aplikasi saya. Id akan merujuk ke properti di DataContext untuk baris daftar saya. Visibilitas akan dikonversi dari boolean secara otomatis. Setiap pembaruan untuk Id, CurrentUser.IsAdmin, CurrentUser, atau CurrentUser.Id akan memicu pembaruan visibilitas tombol ini. Mudah-peasy.

Sebaliknya, WPF / XAML memaksa penggunanya untuk membuat kekacauan lengkap. Sejauh yang saya tahu, beberapa blogger kreatif menampar nama pada kekacauan itu dan nama itu adalah MVVM. Jangan tertipu - ini tidak berada di kelas yang sama dengan pola desain GoF. Ini adalah hack jelek untuk bekerja di sekitar sistem pengikatan data yang jelek.

(Pendekatan ini kadang-kadang disebut sebagai "Pemrograman Reaktif Fungsional" jika Anda mencari bacaan lebih lanjut).

Kesimpulannya

Jika Anda harus bekerja di WPF / XAML, saya masih tidak merekomendasikan MVVM.

Anda ingin kode Anda disusun seperti contoh "bagaimana segala sesuatu bisa terjadi" di atas - model yang diekspos langsung untuk dilihat, dengan ekspresi pengikatan data yang kompleks + paksaan nilai yang fleksibel. Ini jauh lebih baik - lebih mudah dibaca, lebih bisa ditulis, dan lebih bisa dipelihara.

MVVM memberi tahu Anda untuk menyusun kode Anda dengan cara yang lebih verbose dan kurang dapat dikelola.

Alih-alih MVVM, buat beberapa hal untuk membantu Anda memperkirakan pengalaman yang baik: Kembangkan konvensi untuk mengekspos keadaan global ke UI Anda secara konsisten. Bangun diri Anda beberapa alat dari konverter mengikat, MultiBinding, dll yang memungkinkan Anda untuk mengekspresikan ekspresi mengikat yang lebih kompleks. Bangun sendiri perpustakaan pengonversi yang mengikat untuk membantu membuat kasus pemaksaan yang umum menjadi tidak terlalu menyakitkan.

Bahkan lebih baik - ganti XAML dengan sesuatu yang lebih ekspresif. XAML adalah format XML yang sangat sederhana untuk membuat instance objek C # - tidak akan sulit untuk menghasilkan varian yang lebih ekspresif.

Rekomendasi saya yang lain: jangan gunakan toolkit yang memaksa kompromi semacam ini. Mereka akan merusak kualitas produk akhir Anda dengan mendorong Anda ke arah omong kosong seperti MVVM alih-alih berfokus pada domain masalah Anda.

Saya sangat suka MVVM dan saya menemukan tantangannya memotivasi dan melihat banyak manfaat, tetapi ...

1. Untuk aplikasi atau game yang membutuhkan banyak UI / kode interaksi untuk menambahkan banyak perilaku khusus sambil mempertahankan performa - seringkali lebih baik menggunakan MVVM yang sedikit kotor - menggunakannya saat berguna atau lebih banyak data sentris daripada interaksi area sentris dari kode. Katakanlah Anda ingin membuat kontrol dan memindahkannya di antara kontrol induk yang berbeda atau menemboloknya ...

2. Ini memiliki kurva belajar yang cukup curam, jadi kecuali Anda punya waktu, rencanakan untuk mengembangkan banyak di WPF / SL, memiliki desainer yang ahli dalam Blend, rasakan kebutuhan untuk menulis kode uji untuk UI Anda atau berharap untuk melakukan pemeliharaan selama bertahun-tahun untuk Anda proyek - mungkin tidak membuahkan hasil.

3. Tidak begitu banyak desainer yang tahu Blend, tidak semua proyek layak memfokuskan pengujian otomatis pada lapisan presentasi, karena bagaimanapun juga perlu diuji secara manual dan itulah bagaimana Anda akan menemukan bug yang paling penting, bukan dengan menguji VM Anda.

4. Ini benar-benar investasi. Anda harus memahami dasar-dasar WPF / SL dan XAML terlebih dahulu, kemudian mencari cara untuk melakukan binding dengan benar, menghubungkan vs ke vms dalam beberapa urutan, mendapatkan perintah yang tepat, memilih kerangka kerja dalam banyak kasus yang bisa menjadi bermasalah karena perizinan, membangun perpustakaan sippets untuk kode secara efisien, hanya untuk menemukan bahwa platform tidak selalu bekerja dengan baik dengan binding dan perlu membangun perpustakaan perilaku yang memberi Anda apa yang Anda butuhkan.

Namun secara keseluruhan - jika Anda mengatasi semua rintangan dan menjadi cukup mahir dalam pola - semuanya membayar kembali dengan kejelasan, pemeliharaan dan ... Hak-hak membual? :)

Saya telah menjadi programmer WPF / Silverlight selama bertahun-tahun membangun aplikasi besar, seperti sistem perdagangan, di MVVM.

Bagi saya, seiring berjalannya waktu, saya telah belajar bahwa MVVM yang ketat memakan waktu dan biaya. Dengan ketat, maksud saya aturan seperti "tidak ada kode di belakang".

Tidak mungkin apa pun selain bentuk / basis data aplikasi paling dasar, tidak memiliki kode-belakang.

Desainer Anda akan menentukan sesuatu pada hari pertama yang tidak mungkin dengan kontrol standar, jadi Anda harus membangun serangkaian kontrol khusus, atau membungkus kontrol yang ada, untuk mendukung paradigma interaksi saat bekerja dengan MVVM.

Saya telah menulis semua jenis kontrol UI desir menggunakan matematika, inersia, gerakan, dll. Dan kerja kerasnya.

Tapi ini semua kode-belakang, hanya saja tidak dalam pandangan. Anda harus menangani klik tombol, menggulir, menyeret dll. Tapi semuanya dibungkus dengan baik dalam satu set kontrol, yang entah bagaimana membuat kode di belakang ini oke.

Seringkali lebih mudah hanya dengan menulis kode-belakang dan hal-hal pintar UI dalam tampilan, daripada membangun satu set kontrol hanya demi itu.

Tujuan MVVM adalah untuk memisahkan logika aplikasi / bisnis dari logika UI. Sistem penjilidan dan MVVM adalah cara yang bagus untuk melakukan ini.

Tujuan lain yang dipuji-puji, seperti desainer XAML di satu meja, programmer C # di yang lain, satu yang bekerja di Blend yang lain di VS, adalah sebuah kesalahan.

Mampu mendesain ulang UI dengan cepat adalah kesalahan lain. Ini tidak pernah terjadi, optimasi prematurnya; pengerjaan ulang besar membutuhkan banyak pekerjaan yang dilakukan untuk melihat model. Tweak adalah satu hal tetapi perbaikan UI cepat tidak mungkin; model tampilan harus sesuai dengan paradigma interaksi, sehingga sambungan lebih ketat daripada yang Anda sadari.

Bagi saya, saya menggunakan MVVM untuk menjaga logika aplikasi saya terpisah (saya biasanya menggunakan pengontrol yang dapat diuji dan satu set model tampilan tanpa logika) tetapi kode dan trik apa pun yang diperlukan untuk membuat tampilan UI saya dan bertindak dengan cara yang seksi, saya tidak berkeringat.

Lain Anda akhirnya memerintah-dalam desain Anda, animasi keren, dll hanya karena gagasan tentang bagaimana MVVM-arize semuanya menjadi terlalu membingungkan.

MVVM, seperti kebanyakan hal dalam hidup, memiliki sweet spot di suatu tempat antara dua ekstrem.

Hal terpenting dalam desain perangkat lunak adalah mengirimkan produk Anda lebih awal, mencari tahu fitur apa yang digunakan, apa yang berfungsi dengan baik, dan tidak menulis kode yang bagus untuk suatu produk yang tidak digunakan oleh siapa pun.

Jika aplikasi Anda mengharuskan Anda untuk mengikat data yang berlebihan dalam waktu nyata, maka MVVM sebenarnya bisa menghalangi karena itu memperkenalkan abstraksi yang memperlambat proses dan, dengan asumsi kita berbicara tentang WPF / Silverlight / WP7 sekarang, mengikat mesin saat ini tidak seefisien itu; meskipun perangkat tambahan sedang dalam perjalanan.

MVVM, sebagaimana adanya, juga bukan satu-satunya bagian dari persamaan yang perlu Anda pertimbangkan. MVVM murni perlu didukung dengan infrastruktur seperti pola Mediator untuk memungkinkan Anda berkomunikasi melalui ViewModels yang terputus.

Terlepas dari pendapat blucz di atas, MVVM sesuai dengan pola GoF. Jika Anda melihat pola, MVVM adalah setara dengan pola Model View Passive Presenter, yang muncul kira-kira bersamaan dengan MVVM. Anda akan sering di sini orang mengeluh tentang kompleksitas MVVM semata-mata karena mereka tidak mengerti bagaimana merancang menggunakannya.

Area lain yang saya temukan masalah dengan MVVM adalah di mana Anda perlu memasukkan teknologi pihak ketiga yang tidak dirancang untuk mendukungnya (seperti kerangka kerja UII untuk MS Dynamics). Kadang-kadang Anda harus bertanya pada diri sendiri apakah layak atau tidaknya rasa sakit "peretasan" di sekitar teknologi lain hanya untuk bekerja dengan MVVM.

Jika Anda mencampur dan mencocokkan sesuatu seperti Win Forms ke dalam solusi WPF Anda, maka bagian dari solusi itu mungkin tidak akan cocok untuk MVVM juga. Saya harap ini memberi Anda beberapa gagasan tentang di mana MVVM tidak berlaku.

Menggunakan MVVM tidak masuk akal ketika:

• Anda tidak bekerja dengan WPF atau Silverlight
• Anda sedang menguji konsep

Itu dia. Saya tidak bisa memikirkan mengapa Anda TIDAK akan menggunakan MVVM ketika bekerja dengan WPF / Silverlight, kecuali jika Anda menguji atau men-debug sesuatu dalam proyek yang terpisah. Saya menemukan pola desain yang ideal untuk pengembangan WPF / Silverlight karena cara kerja XAML Bindings.

Inti dari MVVM adalah bahwa seluruh aplikasi Anda dijalankan dalam ViewModels Anda, dan Views Anda hanyalah lapisan cantik yang dapat digunakan pengguna untuk berinteraksi dengan ViewModels Anda. Anda ingin mengklik tombol, Anda sebenarnya menjalankan metode ViewModel. Anda ingin mengubah halaman, Anda sebenarnya mengubah properti CurrentPage di ViewModel.

Saya menggunakan MVVM untuk semua pengembangan WPF / Silverlight, bahkan proyek satu halaman kecil yang sederhana, meskipun bagaimana saya menggunakan MVVM berbeda berdasarkan ukuran proyek dan apa yang saya butuhkan. Satu kali saya melakukan aplikasi kecil tanpa MVVM, saya akhirnya menyesalinya (kemudian direactored untuk menggunakan MVVM sambil menambahkan pembaruan)

Saya melakukan beberapa pekerjaan untuk klien pada proyek yang kode-belakang dengan upaya untuk mengkonversi ke MVVM dilemparkan dan itu adalah kekacauan besar. Itu tidak berarti semua proyek di belakang kode berantakan. Pandangan akan kesalahan atau crash Blend yang menyebabkan masalah bagi para desainer.

Saya telah mencoba-coba dengan RoR dan cukup banyak melewatkan melakukan apa pun dengan ASP.NET Webforms tetapi ketika ASP.NET MVC keluar saya mencoba untuk belajar sebanyak mungkin, sering menggunakan buku ASP.NET MVC In Action dan codecampserver sebagai referensi . Meskipun ini adalah pola yang berbeda, saya menggunakan banyak hal yang saya pelajari dari buku In Action dalam pengembangan SL / MVVM.

Ketika saya mulai bekerja dengan Silverlight saya terkejut melihat betapa telanjangnya itu dan rasanya seperti persyaratan untuk memilih salah satu dari banyak kerangka kerja yang tersedia untuk mendandaninya. Saya melihat ini sebagai masalah dengan orang yang menyerah untuk belajar MVVM.

Saya mulai dengan MVVM-Light yang luar biasa yang membantu saya memahami pola penjualan. Saya kemudian mulai bekerja dengan Caliburn Micro dan kemudian lampu menyala. Bagi saya Caliburn Micro seperti menggunakan ASP.NET MVC melalui ASP.NET Webforms. Jadi, bahkan untuk aplikasi sampel kecil saya membuat proyek, NuGet CM, dan saya tidak aktif. Saya mengikuti pendekatan ViewModel pertama dan menjaga Tampilan saya bodoh dan mudah untuk dikerjakan di Blend. VM saya dapat diuji jika Anda menggunakannya dan dengan CM, cukup mudah untuk membungkuk di sekitar tata letak layar yang kompleks.

Anda dapat menikmati memeriksa alternatif ini. Opsi ini mengesampingkan cara penyatuan data WPF, datatemplates, dan MVVM. Opsi ini lebih mirip pendekatan WinForms designer.cs yang lama, sederhana, dan dapat diandalkan.

Komposit WPF

http://wpfcomposites.codeplex.com/

Di sini, kode-C # di belakang untuk WPF dihasilkan dengan melapisi matriks sederhana di atas UI melalui komposit berbasis kisi. Jika XAML UI modern hanya berisi beberapa label teks dan kotak daftar foto, mengapa ini tidak dapat didefinisikan dengan baris kode sederhana: grid.AddText (guid, x coordinate, y coordinate)? Catatan, ini bukan di atas kanvas, tetapi masih di dalam wadah WPF: kisi, dockpanel, dll. WPF sangat kuat. Pendekatan ini hanya memanfaatkan ini.

Pengembang biasanya tidak keberatan dengan matriks dan indeks. Mulailah dengan level kontainer berbutir kasar yang ditentukan oleh GUID tentang objek transfer data (DTO) atau POCO, lalu pujilah kontainer yang dikunci ini dengan matriks butiran halus dari baris dan kolom potensial di dalam?

Proyek codeplex di atas memperkenalkan pendekatan ini dengan memulai dengan kontrol ListBox tetapi diperluas untuk mencakup semua kontrol komposit WPF. Misalnya, setiap listboxitem adalah komposit yang ditambahkan dengan GUID (gabungan ikatan satu-ke-satu ke kelas), lalu di dalam item ini ada Grid di mana elemen UI anak (anak mengikat satu-ke-satu ke properti dalam suatu kelas) dapat ditambahkan sesuka hati melalui kode di belakang. Anak-anak mungkin berupa blokir teks atau gambar.

Idenya adalah untuk meningkatkan indeks dan struktur Elemen UI yang terdefinisi dengan baik (itu memaksa ListBox Presentasi. Juga bertema ListBox sebagai dasar untuk memulai) alih-alih datatemplates. Pendekatan baru ini sengaja membatasi apa yang bisa dilakukan tetapi dengan demikian menghasilkan kode C # yang ringkas dan kuat di belakang yang intuitif. Tidak perlu mencari solusi templat kontrol untuk menata bilah gulir atau mengacaukan solusi dengan beberapa templat data untuk tugas-tugas sederhana.

MVVM sebagian besar berbasis di sekitar kerangka UI yang saya gunakan. Jadi dengan sesuatu seperti WPF atau Silverlight yang memiliki paradigma berbasis mengikat ke datacontext, bahwa datacontext selalu bisa disebut model tampilan.

Jadi pertanyaannya kepada saya adalah kapan Anda membangun kelas terpisah yang besar dan gemuk yaitu model tampilan untuk kontrol / jendela / aplikasi ini dan kapan Anda bisa menggunakan benda-benda yang sudah dibangun.

Jadi kita punya pertanyaan klasik tentang menambahkan lapisan abstraksi. VM akan menambah bobot, kelembaman dan struktur untuk suatu proyek. Ini akan membuatnya lebih mudah untuk dibangun, tetapi lebih sulit untuk berubah dan lebih lama untuk dibangun. Tak satu pun dari hal-hal itu mudah diukur.

Untuk jawaban yang murah, MVVM tidak sesuai untuk aplikasi baris perintah atau layanan web :)