Mengapa memiliki kode pengguna / tulisan tangan minimal dan melakukan semuanya di XAML?

Saya merasa komunitas MVVM telah menjadi terlalu bersemangat seperti programmer OO di tahun 90-an - itu adalah nama yang salah MVVM identik dengan tanpa kode. Dari pertanyaan StackOverflow tertutup saya :

Banyak kali saya menemukan posting di sini tentang seseorang yang mencoba melakukan yang setara dalam XAML alih-alih kode di belakang. Satu-satunya alasan mereka adalah mereka ingin menjaga kode mereka di belakang 'bersih'. Perbaiki saya jika saya salah, tetapi tidak demikian halnya:

XAML dikompilasi juga - ke dalam BAML - maka pada saat runtime harus diurai menjadi kode. XAML berpotensi memiliki lebih banyak bug runtime karena mereka tidak akan diambil oleh kompiler pada waktu kompilasi - dari ejaan yang salah - bug ini juga lebih sulit untuk di-debug. Sudah ada kode di belakang - suka atau tidak InitializeComponent (); harus dijalankan dan file .gics yang ada di dalamnya berisi banyak kode meskipun mungkin disembunyikan. Apakah ini murni psikologis? Saya menduga itu adalah pengembang yang berasal dari latar belakang web dan suka markup yang bertentangan dengan kode.

EDIT: Saya tidak mengusulkan kode di balik XAML - gunakan keduanya - saya lebih suka melakukan pengikatan saya di XAML juga - Saya hanya menentang melakukan segala upaya untuk menghindari menulis kode di balik esp dalam aplikasi WPF - itu harus merupakan perpaduan dari keduanya untuk mendapatkan hasil maksimal dari itu.

UPDATE: Ini bahkan bukan ide Microsoft, setiap contoh di MSDN menunjukkan bagaimana Anda dapat melakukannya di keduanya.

Saya belum pernah mendengar ada yang menyarankan untuk memasukkan semuanya ke XAML.

Bahkan, itu akan menjadi ide yang buruk, IMO.

Masalahnya, secara historis, berasal dari aplikasi Winforms yang memiliki logika dalam kode mereka di belakang yang tidak seharusnya ada di sana, karena itu adalah logika . Dari situlah pentingnya VM berasal. Ini memungkinkan Anda untuk mengisolasi bagian-bagian yang menyatukan View to the Model.

Oleh karena itu, View dibiarkan hanya menangani apa yang terbaik, yaitu UI.

Sekarang, jika Anda memiliki situasi di mana UI Anda memerlukan kode, maka dengan segala cara lakukan dan letakkan di kode Anda di belakang. Namun, saya akan mengatakan bahwa untuk 95% dari skenario di luar sana, Anda kemungkinan besar akan lebih baik meninggalkan UI dalam file markup, dan jika Anda memerlukan beberapa kode di belakang, itu mungkin beberapa logika yang Anda coba tuliskan yang lebih tepat diserahkan ke Model Tampilan. Pengecualian untuk ini adalah hal-hal seperti Perilaku, tetapi mereka adalah hewan yang sepenuhnya terpisah, dan memerlukan tempat khusus (yaitu tidak ada dalam kode Anda di belakang).

Untuk langsung menjawab pertanyaan Anda, dan dengan asumsi bahwa ketika Anda mengatakan "kode" yang dalam setiap contoh Anda merujuk secara khusus ke kode-belakang (kode yang ada pada kelas kontrol visual), alasannya adalah agar antarmuka pengguna Anda dapat sepenuhnya diimplementasikan sepenuhnya dan dimanipulasi dalam Blend, hanya menggunakan satu teknologi. Asumsinya adalah bahwa desainer UX Anda bukan pengembang dan tidak ingin bekerja dalam kode, dan bahwa mereka adalah ahli tata letak dan XAML sebagai lawan ahli pengkodean. Jika Anda menerapkan semuanya tanpa kode di belakang, Anda bisa memberikan alat-alat yang mereka butuhkan untuk bekerja sepenuhnya dalam bahasa mereka.

Ini memberikan pemisahan bersih antara pemrograman imperatif dan desain deklaratif.

Ini adalah alasan mengemudi untuk keberadaan "perilaku" di Silverlight dan WPF - alih-alih memasukkan beberapa kode ke dalam kode di belakang, buatlah perilaku modul kecilnya sendiri yang dapat digunakan kembali. Jika Anda melakukannya, Blend memberi Anda manfaat karena dapat menyeret dan melepaskannya ke kontrol. Sekarang, alih-alih memiliki bagian yang bergerak sekali saja ke kontrol XAML all-in-all yang lain, Anda telah mengabstraksikan bagian yang bergerak menjadi wadah yang bagus yang dapat dimanipulasi menggunakan alat perancang.

Dalam pengalaman saya, ini sering terjadi karena mencoba menggunakan logika yang rumit dalam pemicu XAML agar tidak keluar dari kode-belakang, ketika pendekatan yang lebih baik, lebih sederhana adalah dengan memasukkan logika itu ke dalam keduanya - itu termasuk dalam pandangan. -model.

Salah satu keuntungan terbesar untuk melakukan semua yang Anda bisa dalam xaml adalah menjaga semua perilaku di satu tempat. Setiap kali pengembang harus melompat antara xaml dan kode itu menjadi lebih sulit untuk memahaminya.

Saya sudah berada di tim WPF yang tidak membuat pengurangan kode di belakang prioritas. Ada lebih dari beberapa kali debugging jauh lebih sulit karena beberapa event handler memanipulasi kontrol dan itu tidak segera terlihat karena perilaku tersebut tersebar di dalam dua file.

Yang mengatakan, saya percaya Anda benar untuk berpikir bahwa kadang-kadang Anda lebih baik berkompromi pada prinsip desain. Beberapa hal sangat sulit dilakukan dalam xaml. Saya telah menghabiskan berjam-jam atau bahkan berhari-hari mencoba untuk mendapatkan perilaku untuk bekerja di xaml yang bisa saya lakukan dalam waktu yang jauh lebih sedikit dengan menggunakan kode-belakang. Saya datang untuk memperlakukan kode-belakang sebagai upaya terakhir, tetapi saya tidak akan pernah memberi tahu seseorang bahwa mereka tidak boleh menggunakannya. Ini hanyalah kompromi lain yang perlu dipahami oleh insinyur yang baik.

sunting: Dari komentar, sepertinya posting saya diartikan sebagai menentang xaml. Maksud saya adalah untuk membantah yang sebaliknya. Xaml murni selalu lebih disukai karena menjaga semua perilaku di satu tempat. Campuran xaml dan kode-belakang dapat berbelit-belit, sehingga meminimalkan kode-belakang sangat ideal. Xaml lebih baik daripada di belakang kode murni karena banyak alasan. WPF dan Silverlight dirancang untuk ditulis dalam xaml.

Saya hanya memiliki pengetahuan yang sangat dangkal tentang XAML, tetapi saya bingung bahwa kompiler tidak akan mendeteksi kesalahan ketik.

Perbedaan dasarnya adalah, bahwa XAML bersifat deklaratif , sedangkan C # misalnya adalah imperatif.

Sederhananya:

Pane p = new Pane(200, 100);
Button foo = new Button("foo");
Button bar = new Button("bar");
p.addChild(foo);
p.addChild(bar);

vs.

<Pane width="200" height="100">
    <Button label="foo"/>
    <Button label="bar"/>
<Pane>

Kode atas benar-benar menciptakan hierarki dengan efek samping, sedangkan yang lebih rendah hanya mendeklarasikannya. Perlu juga dicatat, bahwa sementara misalnya addChildmetode ini dapat diganti namanya, hubungan anak-orang tua adalah inti dari model semantik dan diwakili seperti itu dalam potongan deklaratif. Ini sangat jauh dari implementasi, yang memungkinkan banyak optimasi di bawahnya, seperti contoh malas, sepenuhnya transparan.
Pemrograman deklaratif memiliki sejumlah keunggulan. Ini lebih ringkas, ekspresif dan sangat dekat dengan model Anda. Saya akan pergi sejauh itu lebih disukai.

Namun, ini tidak berarti, Anda harus mencoba memasukkan semuanya ke XAML. C # memiliki banyak konstruksi tingkat tinggi yang memungkinkan gaya deklaratif.

Pada akhirnya, Anda ingin kode Anda pendek dan mudah dibaca. Jadi jika Anda dapat mencapai hal yang sama di C # dengan kode lebih sedikit daripada di XAML, menggunakan C # adalah logis. Perlu diingat bahwa, bagaimanapun, kode XAML lebih "portabel" dalam arti bahwa itu jauh lebih rentan terhadap perubahan dalam komponen yang digunakan, mengabstraksi kerangka NET. Jauh (misalnya rincian tentang bagaimana binding diimplementasikan).