Haruskah pandangan dan model berkomunikasi atau tidak?

Menurut halaman wikipedia untuk arsitektur MVC , tampilan bebas untuk diberitahukan oleh model, dan juga bebas untuk menanyakan model tentang keadaan saat ini. Namun, menurut kursus Paul Hegarty tentang iOS 5 di Stanford, kuliah 1, halaman 18 semua interaksi harus melalui pengontrol, dengan Model dan Tampilan yang tidak pernah seharusnya saling mengenal. Tidak jelas bagi saya apakah pernyataan Hegarty harus dimaksudkan sebagai penyederhanaan untuk kursus, tetapi saya tergoda untuk mengatakan bahwa dia ingin desain seperti itu.

Bagaimana Anda menjelaskan dua sudut pandang yang berlawanan ini?

Ini adalah topik kontroversial di MVC / MVVM. Ada yang bilang OK untuk View untuk mengakses Model secara langsung, yang lain mengatakan Anda harus membungkus Model dalam ViewModels untuk abstrak mereka jauh dari View. Saya pribadi bukan penggemar kedua pendekatan itu.

Salah satu tujuan utama MVC / MVVM adalah memisahkan UI, logika bisnis, dan data. Maka dengan mengingat konsep itu, memungkinkan Tampilan untuk secara langsung mengakses Model menciptakan ketergantungan yang mungkin tidak Anda inginkan. Di sisi lain, membungkus Model dalam ViewModels seringkali membosankan dan tidak terlalu berguna karena ViewModels cenderung bertindak hanya sebagai pass-through ke Model.

Saya suka pendekatan memiliki Model Anda menerapkan antarmuka tertentu, mari kita menyebutnya IModel. Kelas ViewModel Anda kemudian dapat menawarkan instance objek yang mengimplementasikan konsumsi IModel for View. View hanya tahu ini berfungsi dengan objek IModel yang didapat dari ViewModel. Ini menghapus kode wrapper ViewModel yang tidak ada serta menyembunyikan implementasi konkret dari IModel dari View. Anda nanti dapat menukar satu implementasi IModel dengan yang lain tanpa memengaruhi tampilan sedikit pun.

Di web, semua orang memanggil MVC decoupling mereka.

Beberapa teknologi, seperti C #, menggunakan MVVM karena tidak ada tautan antara View dan lainnya, semuanya berjalan melalui pencari layanan, mengikat variabel.

Pada MVC murni, View berbicara langsung dengan Model dan sebaliknya. Kontroler hanya ada ketika ada perubahan.

Dan kemudian, ada yang disebut PAC (Presentation Abstraction Control). Dalam arsitektur ini, View dan Model tidak saling berbicara. Pengontrol adalah satu-satunya yang diizinkan melakukan apa pun dengan Tampilan atau Model. Orang sering membingungkan ini dengan MVC.

Anda akan melihat penjelasan yang jauh lebih baik di sini: http://www.garfieldtech.com/blog/mvc-vs-pac

Bagi saya, tujuan dasar arsitektur adalah tidak menghalangi upaya di masa depan untuk refactoring. Biasanya, pandangan berinteraksi langsung dengan model jives dengan persyaratan ini, dan relatif jelas ketika tidak.

Ketika pandangan menjadi terlalu intim dengan model, ViewModel bisa menjadi hal yang indah, tetapi biasanya bagi saya kasus di mana itu disebut berada di minoritas.

Di MVC , Paul Hegarty salah. Pengontrol adalah tentang peristiwa pengguna, bukan komunikasi model-to-view. Dalam MVC klasik , tampilan mengamati model (pola Observer).

Dengan pria di antara melakukan mediasi, polanya harus disebut MVP , dan pada kenyataannya, sebagian besar dari apa yang sekarang disajikan sebagai MVC, sebenarnya lebih dekat ke MVP.

Lalu ada MVVM yang merupakan sesuatu yang mirip dengan keduanya, namun agak berbeda, dan sudah ada sejak lama ... yang terbaik adalah melihatnya sebagai dua MVC / MVP yang diikat bersama melalui objek viewmodel - "klien" MVC memiliki viewmodel sebagai modelnya, dan "server" MVC memiliki viewmodel sebagai pandangannya.

Karena Anda bertanya tentang materi dalam kuliah Stanford itu khususnya, ada baiknya mempertimbangkan dua hal tentang sikap Hegarty:

1. Seperti yang telah Anda sebutkan, dia mengajar kursus Ilmu Komputer tingkat l00. Ada banyak tempat dalam ceramahnya di mana ia menyederhanakan, menguraikan detail, atau mengatakan "lakukan saja seperti ini", seperti yang mungkin harus dilakukan seseorang ketika mengajarkan dasar-dasarnya, yaitu Anda harus menguasai aturan sebelum Anda dapat melanggarnya.
2. Pengalaman saya dengan iOS SDK adalah bahwa, di mana ia tidak memaksakan pemisahan ketat antara View dan Model, itu sangat diarahkan pada pola itu. Saat menulis aplikasi iOS khususnya, mematuhi pemisahan model-view membantu Anda menulis kode yang sesuai dengan harapan kerangka kerja. Saya ragu untuk menggeneralisasikan pernyataan Hegarty ke pengembangan di platform lain atau secara umum.

Saya setuju dengan Paul Hegarty dan percaya bahwa View tidak boleh tahu tentang Model. Ini tidak sulit untuk diraih tetapi membawa manfaat tambahan untuk desain Anda dan fleksibilitas di masa depan.

Dalam aplikasi kecil (biasanya desktop) di mana saya ingin menghindari kelas ViewModel "dummy" dan menjaga semuanya tetap sederhana, saya juga menggunakan antarmuka IModel (lihat jawaban di atas) dan berhati-hati agar Model tidak tahu tentang View (gunakan pelanggan) seperti dalam MVC klasik).

Juga dalam hal ini Kontroler ternyata cukup digabungkan dengan Tampilan dan untuk kesederhanaan saya tidak selalu jelas memisahkannya.

Pendekatan "disederhanakan" yang kedua adalah OK ketika Anda mungkin memiliki beberapa tampilan untuk model yang sama, tetapi saya tidak akan merekomendasikannya jika Anda ingin menggunakan tampilan yang sama untuk model yang berbeda. Di bawah berbeda saya maksud sangat berbeda secara alami dan bukan hanya kelas tes JUnit yang "mengikuti" model utama.

Saya percaya bahwa tidak ada aturan yang keras dan cepat untuk ini, itu sepenuhnya tergantung pada kebutuhan Anda.

Anda akan menemukan orang-orang dengan kepercayaan berbeda. Arsitektur adalah konsep untuk membantu merancang solusi yang lebih baik.

Terlepas dari komunikasi model-view, ada satu lagi kontradiksi tentang logika bisnis di MVC. Banyak orang percaya bahwa semua logika bisnis harus menjadi satu model (lihat pertanyaan SO ini ), di sisi lain tautan yang dibagikan oleh Florian (dalam jawabannya) mengatakan logika bisnis harus di controller.

Terlepas dari ini, ada kemungkinan untuk membagi logika bisnis menjadi logika aplikasi (letakkan di controller) dan Domain login (letakkan di model).

Jadi, moral cerita adalah MVC berarti model, tampilan dan pengontrol harus terpisah. Selain itu, apa pun yang paling cocok untuk Anda.

Saya menggunakan DTO untuk komunikasi model-view.

Contohnya:

• Pengguna mengisi Formulir Pembaruan (Lihat)
• Pengguna mengirimkan formulir
• Pengontrol mengikat data formulir ke UserUpdateDTO
  • DTO dan UserModel adalah POJO tetapi DTO tidak memiliki id dan nama pengguna karena kami tidak dapat memperbarui nama pengguna.
  • Perbedaan lainnya adalah kelas Model memiliki hubungan dan asosiasi tetapi DTO hanya menyimpan data dan kami dapat menambahkan validator JSR 303 ke dalamnya
• Pengendali mengatakan itu ke lapisan layanan untuk menyimpan
• Lapisan layanan mengatakan ke lapisan DAO untuk mempertahankan data

Saya bersama kamp yang mengatakan bahwa pandangan tidak boleh berkomunikasi dengan model. Pengontrol harus selalu menjadi orang yang dapat melakukan segalanya, kemudian memutuskan apa yang harus dilakukan (validasi, minta data dari model, dll).

Saya cenderung melihatnya lebih sebagai masalah organisasi yang lain.

Seperti banyak yang disarankan tentang mengapa dan bagaimana tampilan & model harus berinteraksi secara bebas dalam konteks yang berbeda, tetapi alasan utama di iOS untuk membuat Pengendali adalah mediator di antara mereka adalah untuk menghindari ketergantungan Model & Lihat dalam basis kode Anda dan memungkinkan kami untuk menggunakan kembali baik model atau tampilan sesuai dengan persyaratan dengan evolusi iOS.

Karena kami mungkin perlu menyimpan pembaruan untuk Aplikasi kami di UI / UX atau Model atau beberapa kali keduanya, itu seharusnya tidak menghasilkan kode dependensi mode antara model & tampilan. Jika Anda ingin mengubah lapisan Presentasi aplikasi Anda, maka Anda cukup pergi dan ubah maka Anda masih bisa menggunakan kembali Model yang sama dan sebaliknya bisa dilakukan.

Meskipun saya setuju bahwa MVC di iOS menghasilkan ViewControllers raksasa dengan banyak berbagai logika di dalamnya dan menangani setiap jenis hal selain apa yang dimaksudkan untuk itu. Jadi lebih baik menggunakan MVVM atau Presentation Controls untuk membuat basis kode Anda lebih fleksibel, mudah untuk membaca dan dipelihara dengan ViewControllers yang lebih kecil.

Ini mungkin membantu yang mencari ViewControllers yang lebih kecil di iOS:

http://blog.xebia.com/simplification-of-ios-view-controllers-mvvm-or-presentation-controls/