MVP ve MVC nedir ve fark nedir?

RAD (sürükle bırak ve yapılandır) yönteminin ötesine bakarken , birçok aracın sizi Model-View-Controller , Model-View-Presenter ve Model-View-ViewModel olarak adlandırılan üç tasarım deseni ile karşılaşma olasılığını teşvik eder . Sorumun üç kısmı var:

1. Bu kalıplar hangi sorunları ele alıyor?
2. Nasıl benzerler?
3. Nasıl farklılar?

Model-View-Presenter

In MVP , Sunucu Görünümü için UI iş mantığı içerir. Görünüm'deki tüm çağrılar doğrudan Sunum Yapan kişiyi temsil eder. Sunucu aynı zamanda doğrudan Görünüm'den ayrılır ve bir arayüz üzerinden konuşur. Bu, birim testinde Görünümün alay edilmesine izin vermek içindir. MVP'nin ortak bir özelliği, çok sayıda iki yönlü sevkiyat olması gerektiğidir. Örneğin, birisi "Kaydet" düğmesini tıkladığında, olay işleyicisi Sunum Yapanın "Kaydetme" yöntemine delege eder. Kaydetme işlemi tamamlandıktan sonra Presenter, Görünüm'ün kaydetme işleminin tamamlandığını görüntüleyebilmesi için arabirimi yoluyla Geri'yi arar.

MVP, Web Formlarında ayrı sunum yapmak için çok doğal bir model olma eğilimindedir. Bunun nedeni, Görünümün her zaman önce ASP.NET çalışma zamanı tarafından oluşturulmasıdır. Her iki değişken hakkında daha fazla bilgi edinebilirsiniz .

İki birincil varyasyon

Pasif Görüş: Görüş mümkün olduğunca aptal ve neredeyse sıfır mantık içeriyor. Sunucu, Görünüm ve Model ile konuşan ortada bir adamdır. Görünüm ve Model birbirinden tamamen korumalıdır. Model etkinlikleri artırabilir, ancak Presenter, Görünümü güncellemek için bunlara abone olur. Pasif Görünüm'de doğrudan veri bağlaması yoktur, bunun yerine Görünüm, Sunum Yapanın verileri ayarlamak için kullandığı ayarlayıcı özelliklerini ortaya çıkarır. Tüm durum Görünüm'de değil Sunumda yönetilir.

• Pro: maksimum test edilebilirlik yüzeyi; Görünüm ve Modelin temiz bir şekilde ayrılması
• Con: tüm verileri kendiniz bağladığınız için daha fazla çalışma (örneğin tüm ayarlayıcı özellikleri).

Denetleyici Denetleyici: Sunucu, kullanıcı hareketlerini yönetir. Görünüm, modele doğrudan veri bağlama yoluyla bağlanır. Bu durumda, Sunucunun görevi Modeli ona Görünümden geçirmek böylece ona bağlanabilir. Presenter ayrıca bir düğmeye basma, navigasyon vb. Hareketler için mantık içerecektir.

• Pro: veri tabanından yararlanarak kod miktarı azalır.
• Con: daha az test edilebilir yüzey var (veri bağlama nedeniyle) ve Görünümde doğrudan Model ile konuştuğu için daha az kapsülleme var.

Model-View-Controller

In MVC , Kontrolör Görünüm zaman uygulama yükler dahil olmak üzere herhangi bir eylem yanıt olarak gösterilecek olan belirlemekten sorumludur. Bu, eylemlerin Görünüm'den Sunum Yapan kişiye yönlendirildiği MVP'den farklıdır. MVC'de, Görünüm'deki her eylem bir eylemle birlikte bir Denetleyiciye yapılan çağrı ile ilişkilidir. Web'de her eylem, diğer tarafında yanıt veren bir Denetleyici bulunan bir URL'ye bir çağrı içerir. Bu Denetleyici işlemeyi tamamladığında, doğru Görünümü döndürür. Sekans, uygulamanın ömrü boyunca bu şekilde devam eder:

    Görünümdeki İşlem
        -> Denetleyiciye Çağrı
        -> Denetleyici Mantığı
        -> Denetleyici Görünümü döndürür.

MVC ile ilgili bir diğer büyük fark, Görünümün Model'e doğrudan bağlanmamasıdır. Görünümü basitçe oluşturur ve tamamen vatansızdır. MVC uygulamalarında Görünüm genellikle arkadaki kodda herhangi bir mantık içermez. Bu, kesinlikle gerekli olduğu MVP'ye aykırıdır, çünkü Görünüm Sunum Yapan temsilci seçmezse asla çağrılmaz.

Sunum Modeli

Bakılacak diğer bir model de Sunum ModeliDesen. Bu modelde Sunucu yoktur. Bunun yerine Görünüm doğrudan bir Sunum Modeline bağlanır. Sunu Modeli, Görünüm için özel olarak hazırlanmış bir Modeldir. Bu, bu Modelin, endişelerin ayrılmasının ihlali olacağı için bir kişinin bir alan modeline asla koyamayacağı özellikleri gösterebileceği anlamına gelir. Bu durumda, Sunum Modeli etki alanı modeline bağlanır ve bu Modelden gelen etkinliklere abone olabilir. Görünüm daha sonra Sunu Modeli'nden gelen olaylara abone olur ve kendisini buna göre günceller. Sunu Modeli, görünümün eylemleri çağırmak için kullandığı komutları gösterebilir. Bu yaklaşımın avantajı, PM görünümün tüm davranışlarını tamamen kapsadığı için arkadaki kodu tamamen kaldırabilmenizdir.Model-Görünüm-ViewModel .

Sunu Modeli hakkında bir MSDN makalesi ve WPF (eski Prizma) için Kompozit Uygulama Kılavuzu'nda Ayrılmış Sunu Kalıpları hakkında bir bölüm bulunmaktadır.

Bu, bu tasarım modellerinin birçok varyantının aşırı basitleştirilmesidir, ancak bu ikisi arasındaki farkları düşünmeyi seviyorum.

MVC

MVP

Bir süre önce bu konuda blog yazdım, Todd Snyder'ın ikisi arasındaki fark üzerine mükemmel gönderisini alıntıladım :

Desenler arasındaki temel farklar şunlardır:

MVP Kalıbı

• Görünüm modele daha gevşek bağlıdır. Sunum yapan kişi, modeli görünüme bağlamaktan sorumludur.
• Görünümle etkileşim bir arayüz üzerinden yapıldığı için birim testi daha kolay
• Genellikle sunucu haritasını bire bir görüntüleyin. Karmaşık görünümlerin çoklu sunumcuları olabilir.

MVC Kalıbı

• Denetleyici davranışlara dayanır ve görünümler arasında paylaşılabilir
• Hangi görünümün görüntüleneceğini belirlemekten sorumlu olabilir

Web'de bulabildiğim en iyi açıklama.

İşte iletişim akışını temsil eden çizimler

MVP, Görünüm'ün sorumlu olduğu bir senaryo olmak zorunda değildir (örneğin Taligent'in MVP'sine bakın).
İnsanların bunu "sadece bir görünüm" (Pragmatik Programcı) ile çeliştiği için bir anti-paternin aksine hala bir kalıp olarak (sorumlu görüntü) vaaz ettiğini talihsiz buluyorum. "Bu yalnızca bir görünümdür" kullanıcıya gösterilen son görünümün uygulamanın ikincil bir endişesi olduğunu belirtir. Microsoft'un MVP modeli, Görünümlerin yeniden kullanımını çok daha zorlaştırıyor ve Microsoft'un tasarımcısını kötü uygulamaları teşvik etmekten uygun bir şekilde mazur görüyor.

Açıkçası, MVC'nin altında yatan kaygıların herhangi bir MVP uygulaması için geçerli olduğunu düşünüyorum ve farklılıklar neredeyse tamamen anlamlıdır. Görünüm (verileri görüntüleyen), denetleyici (kullanıcı etkileşimini başlatan ve kontrol eden) ve model (temeldeki veri ve / veya hizmetler) arasındaki endişelerin ayrılmasını izlediğiniz sürece MVC'nin avantajlarını elde edersiniz . Faydaları elde ediyorsanız, modelinizin MVC, MVP veya Denetleyici Denetleyici olup olmadığını kim gerçekten önemsiyor? Tek gerçek desen MVC olarak kalır, gerisi sadece farklı lezzetlerdir.

Bu farklı uygulamaların birçoğunu kapsamlı bir şekilde listeleyen bu son derece heyecan verici makaleyi düşünün . Hepsinin temelde aynı şeyi yaptığını, ancak biraz farklı olduğunu fark edebilirsiniz.

Şahsen MVP'nin yakın zamanda, bir şeyin gerçekten MVC olup olmadığını savunan semantik bigotlar arasındaki tartışmaları azaltmak veya Microsofts Rapid Application Development araçlarını haklı çıkarmak için akılda kalıcı bir terim olduğunu düşünüyorum. Kitaplarımdaki bu nedenlerin hiçbiri, ayrı bir tasarım deseni olarak varlığını haklı çıkarmıyor.

MVP: görünüm sorumlu.

Görünüm, çoğu durumda sunucusunu oluşturur. Sunucu modelle etkileşime girecek ve bir arayüz aracılığıyla görünümü değiştirecektir. Görünüm bazen sunum yapan kişi ile, genellikle bir arayüz aracılığıyla etkileşime girer. Bu uygulamaya dönüşüyor; görünümün sunucudaki yöntemleri çağırmasını veya görünümün, sunucunun dinlediği etkinlikleri olmasını ister misiniz? Şuna bağlı: Görüş, sunum yapan kişiyi biliyor. Görünüm, sunucuya delege verir.

MVC: kontrolör sorumlu.

Denetleyici, bazı olay / isteklere göre oluşturulur veya bunlara erişilir. Daha sonra kontrolör uygun görünümü oluşturur ve görünümü daha fazla yapılandırmak için modelle etkileşime girer. Aşağıya doğru kaynar: denetleyici görünümü oluşturur ve yönetir; görünüm denetleyiciye bağımlıdır. Görünüm denetleyici hakkında bilmiyor.

MVC (Model Görüntüleme Denetleyicisi)

Giriş, görünümde değil, önce Kontrolöre yönlendirilir. Bu girdi, bir sayfa ile etkileşime giren bir kullanıcıdan geliyor olabilir, ancak aynı zamanda tarayıcıya belirli bir url girmek de olabilir. Her iki durumda da, bazı işlevleri başlatmak için arayüzlü bir Denetleyici. Denetleyici ile Görünüm arasında birebir ilişki var. Bunun nedeni, tek bir denetleyicinin yürütülen işleme bağlı olarak oluşturulacak farklı görünümleri seçebilmesidir. Denetleyiciden Görünüm'e tek yönlü oku not edin. Bunun nedeni, Görünüm'ün denetleyici hakkında herhangi bir bilgisi veya referansı olmamasıdır. Denetleyici Modeli geri aktarır, bu nedenle Görünüm ile ona geçirilen beklenen Model arasında bilgi vardır, ancak ona hizmet veren Denetleyici yoktur.

MVP (Model Görünümü Sunucusu)

Giriş, Presenter ile değil View ile başlar. Görünüm ile ilişkili Sunucu arasında bire bir eşleme vardır. Görünüm, Sunum Yapan kişi için bir referans tutar. Presenter aynı zamanda Görünüm'den tetiklenen olaylara da tepki gösterir, bu yüzden onunla ilişkili Görünüm'ün farkındadır. Presenter, Görünümü Model üzerinde gerçekleştirdiği istenen eylemlere göre günceller, ancak Görünüm Modelden haberdar değildir.

Daha fazla Referans için

Sorunun birçok cevabı var, ama ikisini açıkça karşılaştıran gerçekten basit bir cevaba ihtiyaç olduğunu hissettim. Bir kullanıcı bir MVP ve MVC uygulamasında bir film adı aradığında yaptığım tartışma şu şekildedir:

Kullanıcı: Tıklayın…

Görünüm : Kim bu? [ MVP | MVC ]

Kullanıcı: Ara düğmesini tıkladım…

Görünüm : Tamam, bir saniye ... [ MVP | MVC ]

( Sunucu | Denetleyiciyi çağıran görünüm …) [ MVP | MVC ]

Görünüm : Hey Sunucu | Denetleyici , bir Kullanıcı ara düğmesini henüz tıkladı, ne yapmalıyım? [ MVP | MVC ]

Sunucu | Kontrolör : Hey Görünüm , bu sayfada herhangi bir arama terimi var mı? [ MVP | MVC ]

Görünüm : Evet,… işte burada… “piyano” [ MVP | MVC ]

Presenter : Thanks View ,… Bu arada Model üzerindeki arama terimini arıyorum , lütfen ona bir ilerleme çubuğu gösterin [ MVP | MVC ]

( Sunucu | Denetleyici Modeli çağırıyor …) [ MVP | MVC ]

Sunucu | Denetleyici : Hey Model , Bu arama terimi için eşleşmeniz mi var ?: “piyano” [ MVP | MVC ]

Model : Hey Sunucu | Kontrolör , kontrol edeyim… [ MVP | MVC ]

( Model film veritabanına sorgu yapıyor…) [ MVP | MVC ]

( Bir süre sonra ... )

-------------- Bu, MVP ve MVC'nin ayrılmaya başladığı yerdir ---------------

Model : Sizin için bir liste buldum, Presenter , işte JSON “[{" name ”:" Piyano Öğretmeni "," yıl ": 2001}, {" name ":" Piyano "," yıl ": 1993} ] ”[ MVP ]

Model : Elde edilen bazı sonuçlar var, Kontrolör . Örneğimde bir alan değişkeni oluşturdum ve sonuçla doldurdum. Adı "searchResultsList" [ MVC ]

( Sunucu | Kontrolör sayesinde Modeli ve geri alır Görünüm ) [ MVP | MVC ]

Sunucu : Beklediğiniz için teşekkürler View , sizin için eşleşen sonuçların bir listesini buldum ve bunları sunulabilir bir biçimde düzenledim: ["Piano Teacher 2001", "Piano 1993"]. Lütfen kullanıcıya dikey bir listede gösterin. Ayrıca lütfen ilerleme çubuğunu şimdi gizleyin [ MVP ]

Kontrolör : Beklediğiniz için teşekkürler View , Model'e arama sorgunuzu sordum . Eşleşen sonuçların bir listesini bulduğunu ve bunları örneğinin içindeki "searchResultsList" adlı bir değişkende sakladığını söylüyor. Oradan alabilirsiniz. Ayrıca lütfen ilerleme çubuğunu şimdi gizleyin [ MVC ]

Görünüm : Çok teşekkür ederim Sunucu [ MVP ]

Görünüm : Teşekkürler "Denetleyici" [ MVC ] (Şimdi Görünüm kendisini sorguluyor: Modelden elde ettiğim sonuçları kullanıcıya nasıl sunmalıyım? Filmin yapım yılı önce mi yoksa son mu olmalı ...? dikey mi yatay mı? ...)

İlgilenmeniz durumunda, burada Github repo eşliğinde uygulama mimari desenleri (MVC, MVP, MVVP, temiz mimari, ...) ile ilgili bir dizi makale yazıyorum . Örnek android için yazılsa bile, temel prensipler herhangi bir ortama uygulanabilir.

• MVP = Model-View-Presenter

• MVC = Model-Görünüm-Denetleyici

  1. Her iki sunum modeli. Bir Model (Domain nesnelerini düşün), ekran / web sayfanız (Görünüm) ile kullanıcı arayüzünüzün nasıl davranması gerektiği arasındaki bağımlılıkları ayırırlar (Sunucu / Denetleyici)
  2. Konseptte oldukça benzerler, insanlar Presenter / Controller'ı tada bağlı olarak farklı şekilde başlatırlar.
  3. Farklılıklar hakkında harika bir makale burada . En dikkat çekici olanı, MVC modelinin Görünümü güncelleyen Modeline sahip olmasıdır.

Model-View-Controller

MVC bir yazılım uygulamasının mimarisi için bir modeldir. Uygulama mantığını üç ayrı parçaya ayırır, modülerliği ve işbirliği ve yeniden kullanım kolaylığı sağlar. Ayrıca, uygulamaları daha esnek ve yinelemelere karşı hoş hale getirir.Bir uygulamayı aşağıdaki bileşenlere ayırır:

• Veri ve iş mantığını işlemek için modeller
• Kullanıcı arayüzünü ve uygulamasını yönetmek için kontrolörler
• Görüntüleme grafik kullanıcı arayüzü nesneleri ve sunum kullanımı için

Bunu biraz daha açık hale getirmek için, basit bir alışveriş listesi uygulaması düşünelim. Tek istediğimiz, bu hafta satın almamız gereken her öğenin adı, miktarı ve fiyatının bir listesidir. Aşağıda, bu işlevselliğin bir kısmını MVC kullanarak nasıl uygulayabileceğimizi açıklayacağız.

Model-View-Presenter

• Model görünüşüdür (kullanıcı arabirimi) görüntülenir verilerdir.
• Görünüşüdür Sunucuya verileri görüntüler (modeli) ve rotalar, kullanıcı komutları (olaylar) bu verilere göre hareket için bu bir arayüzdür. Görünümün genellikle Sunucusuna referansı vardır.
• Sunum (MVC denetleyicisi tarafından oynanan) “orta erkek” ve, görünümü ve modelin her iki başvuru var. “Model” kelimesinin yanıltıcı olduğunu lütfen unutmayın . Bir Modeli geri alan veya işleyen bir iş mantığı olmalıdır . Örneğin: Kullanıcı'yı bir veritabanı tablosunda depolayan bir veritabanınız varsa ve Görünümünüzde bir kullanıcı listesi görüntülemek istiyorsanız, Sunum Yapan Kişinin bir listeyi sorgulayacağı veritabanı iş mantığınıza (DAO gibi) bir referansı olur. Kullanıcıların.

Basit bir uygulamaya sahip bir örnek görmek istiyorsanız lütfen bu GitHub yayınını kontrol edin

Veritabanındaki kullanıcıların listesini sorgulamak ve görüntülemek için somut bir iş akışı şu şekilde çalışabilir:

MVC ve MVP modelleri arasındaki fark nedir ?

MVC Kalıbı

• Denetleyici davranışlara dayanır ve görünümler arasında paylaşılabilir

• Hangi görünümün görüntüleneceğini belirlemekten sorumlu olabilir (Ön Denetleyici Deseni)

MVP Kalıbı

• Görünüm modele daha gevşek bağlıdır. Sunum yapan kişi, modeli görünüme bağlamaktan sorumludur.

• Görünümle etkileşim bir arayüz üzerinden yapıldığı için birim testi daha kolay

• Genellikle sunucu haritasını bire bir görüntüleyin. Karmaşık görünümlerin çoklu sunumcuları olabilir.

Ayrıca hatırlamakta fayda var, farklı MVP türleri de var. Fowler, paterni iki pasif görünüm ve denetleyici denetleyiciye ayırdı.

Pasif Görünümü kullanırken, Görünümünüz genellikle altta yatan kullanıcı arayüzü widget'ına az çok doğrudan eşlenen özelliklerle ince taneli bir arayüz uygular. Örneğin, Ad ve Adres gibi özelliklere sahip bir ICustomerView'ünüz olabilir.

Uygulamanız aşağıdaki gibi görünebilir:

public class CustomerView : ICustomerView
{
    public string Name
    { 
        get { return txtName.Text; }
        set { txtName.Text = value; }
    }
}

Presenter sınıfınız modelle konuşacak ve onu görünümle "eşleyecek". Bu yaklaşıma "Pasif Bakış" denir. Avantajı, görünümün test edilmesinin kolay olması ve UI platformları (Web, Windows / XAML vb.) Arasında hareket etmenin daha kolay olmasıdır. Dezavantajı, veri bağlama gibi şeylerden ( WPF ve Silverlight gibi çerçevelerde gerçekten güçlü ) yararlanamamanızdır.

MVP'nin ikinci aroması Denetleyici Denetleyicidir. Bu durumda, Görünümünüzde Müşteri adında bir özellik olabilir ve bu da yine kullanıcı arayüzü widget'larına veri bağlanır. Görünümü senkronize etmeyi ve mikro yönetmeyi düşünmek zorunda değilsiniz ve Denetleyici Denetleyici, örneğin tamamlanmış etkileşim mantığı gibi, gerektiğinde devreye girebilir ve yardımcı olabilir.

MVP'nin üçüncü "lezzeti" (veya belki de ona ayrı bir desen diyebilir) Sunum Modeli'dir (veya bazen Model-View-ViewModel olarak adlandırılır). MVP ile karşılaştırıldığında M ve P'yi bir sınıfa "birleştirirsiniz". Kullanıcı arabirimi widget'larınızın verilere bağlı olduğu müşteri nesneniz var, ancak "IsButtonEnabled" veya "IsReadOnly" vb. Gibi ek UI'ye özgü alanlarınız da var.

UI mimarisine bulduğum en iyi kaynak, Jeremy Miller tarafından Kendi CAB Serisi İçindekiler Tablosunda yapılan blog yayınları dizisidir . MVP'nin tüm lezzetlerini kapladı ve bunları uygulamak için C # kodunu gösterdi.

Ayrıca YouCard'da Silverlight bağlamında Model-View-ViewModel kalıbı hakkında blog yazdım Yeniden ziyaret edildi: ViewModel kalıbını uygulama .

Her biri farklı sorunlara hitap eder ve hatta aşağıdaki gibi bir şeye sahip olmak için birleştirilebilir.

Burada MVC, MVP ve MVVM'nin tam bir karşılaştırması da var

Bu çerçevelerin her ikisi de, örneğin bir veri kaynağı (model), uygulama mantığı (veya bu verileri faydalı bilgilere dönüştürmek) (Denetleyici / Sunum Yapan Kişi) ve ekran kodu (Görünüm) gibi etkileşimleri ayırmayı amaçlamaktadır. Bazı durumlarda, model bir veri kaynağını daha yüksek bir soyutlamaya dönüştürmek için de kullanılabilir. Bunun iyi bir örneği MVC Storefront projesidir .

Burada MVC ile MVP arasındaki farklar hakkında bir tartışma var .

Bir ayrım, bir MVC uygulamasında geleneksel olarak görüş ve kontrolörün modelle etkileşime girmesi, ancak birbiriyle etkileşmemesidir.

MVP tasarımları Presenter'ın modele erişmesini ve görünümle etkileşimini sağlar.

Bunu söyledikten sonra, ASP.NET MVC bu tanımlarla bir MVP çerçevesidir, çünkü Denetleyici, mantık içermeyen Görünümü doldurmak için Modele erişir (yalnızca Denetleyici tarafından sağlanan değişkenleri görüntüler).

MVP'den ASP.NET MVC ayrımı hakkında bir fikir edinmek için Scott Hanselman'ın bu MIX sunumuna göz atın.

Her ikisi de sunum ve iş mantığını ayırmaya çalışan ve iş mantığını UI yönlerinden ayıran kalıplardır

Mimari olarak, MVP, MVC'nin Ön Denetleyici tabanlı bir yaklaşım olduğu Sayfa Denetleyici tabanlı bir yaklaşımdır. Bu, MVP standart web formu sayfa yaşam döngüsünün, iş mantığının arkasındaki koddan çıkarılmasıyla artırıldığı anlamına gelir. Başka bir deyişle, sayfa http hizmetini veren kişidir. Başka bir deyişle, MVP IMHO web form evrimsel bir geliştirme türüdür. Diğer yandan MVC oyunu tamamen değiştirir, çünkü istek sayfa yüklenmeden önce kontrolör sınıfı tarafından kesilir, iş mantığı orada yürütülür ve daha sonra kontrolörün sayfaya yeni dökülen verileri işlemesi sonucunda ("görünüm") MVC, yönlendirme motoruyla geliştirilmiş MVP'nin Denetleyici Kontrolörü lezzetine çok benziyor (en azından bana)

Her ikisi de TDD'yi etkinleştirir ve olumsuz ve olumsuz yanları vardır.

Bunlardan birini seçmek için karar IMHO bir ASP NET web formu türü web geliştirme yatırım ne kadar zaman dayalı olmalıdır. Web formlarında kendini iyi görürse MVP'yi öneririm. Bir sayfa yaşam döngüsü vb şeylerde çok rahat hissetmezseniz MVC buraya gitmek için bir yol olabilir.

İşte bu konuda biraz daha ayrıntı veren başka bir blog yazısı bağlantısı

http://blog.vuscode.com/malovicn/archive/2007/12/18/model-view-presenter-mvp-vs-model-view-controller-mvc.aspx

Hem MVP hem de MVC kullandım ve geliştiriciler olarak her iki modelin teknik farklılıklarına odaklanma eğilimimiz olmasına rağmen, IMHO'daki MVP'nin noktası, benimsenme kolaylığıyla her şeyden çok daha fazla ilişkili.

Zaten web form geliştirme tarzı üzerinde iyi bir arka plan olarak bir ekip içinde çalışıyorsanız MVP tanıtmak MVC daha çok daha kolay. Bu senaryoda MVP'nin hızlı bir kazanç olduğunu söyleyebilirim.

Deneyimlerim, bir takımı web formlarından MVP'ye ve sonra MVP'den MVC'ye taşımanın nispeten kolay olduğunu söylüyor; web formlarından MVC'ye geçmek daha zordur.

Burada bir arkadaşımın MVP ve MVC hakkında yayınladığı bir dizi makaleye bir bağlantı bırakıyorum.

http://www.qsoft.be/post/Building-the-MVP-StoreFront-Gutthrie-style.aspx

MVP'de görünüm, modelden veri çizen ve hazırlayan / normalleştiren sunucudan veri çekerken MVC'de denetleyici, görünümü iterek modelden ve setten veri alır.

MVP'de birden çok sunum türü ile çalışan tek bir görünüm ve farklı birden çok görünüm ile çalışan tek bir sunum yapan kişi olabilir.

MVP genellikle Microsoft WPF bağlama çerçevesi veya HTML5 ve Java için çeşitli bağlama çerçeveleri gibi bir tür bağlama çerçevesi kullanır.

Bu çerçevelerde, UI / HTML5 / XAML, her bir UI öğesinin sunum yapan kişinin hangi özelliğinin görüntülendiğinin farkındadır, bu nedenle bir sunumu bir sunucuya bağladığınızda görünüm özellikleri arar ve bunlardan nasıl veri çekileceğini ve nasıl kullanıcı tarafından kullanıcı arayüzünde bir değer değiştirildiğinde bunları ayarlamak için.

Örneğin, model bir araba ise, sunumcu bir çeşit araba sunumcusu ise, araba özelliklerini (yıl, yapımcı, koltuklar, vb.) Görünüme maruz bırakır. Görünüm, 'araba üreticisi' adı verilen metin alanının, sunucu Maker özelliğini görüntülemesi gerektiğini bilir.

Daha sonra görünüme birçok farklı sunucu türünü bağlayabilirsiniz, hepsi Maker özelliğine sahip olmalıdır - bir uçak, tren veya herhangi bir şey olabilir, görünüm umursamıyor. Görünüm, kararlaştırılan bir arabirimi uyguladığı sürece, sunucudan veri alır - hangisi olursa olsun.

Bu bağlayıcı çerçeve, eğer onu soyursanız, aslında denetleyici :-)

Ve böylece, MVP'yi MVC'nin bir evrimi olarak görebilirsiniz.

MVC harika, ama sorun genellikle görünüm başına denetleyicisidir. Denetleyici A, Görünüm A'nın alanlarının nasıl ayarlanacağını bilir. Şimdi, Görünüm A'nın B modelindeki verileri görüntülemesini istiyorsanız, Model B'yi tanımak için Denetleyici A'ya ihtiyacınız vardır veya arabirim içeren bir nesne almak için Denetleyici A'ya ihtiyacınız vardır. MVP yalnızca bağlamalar olmadan veya Denetleyici B'deki UI set kodunu yeniden yazmanız gerekir.

Sonuç - MVP ve MVC'nin her ikisi de UI modellerinin ayrıştırılmasıdır, ancak MVP genellikle altında MVC olan bir bağlama çerçevesi kullanır. THUS MVP, MVC'den daha yüksek bir mimari seviyededir ve MVC'nin üzerinde bir sargı kalıbıdır.

Benim mütevazı kısa görüşüm: MVP büyük ölçekler için ve MVC küçük ölçekler için. MVC ile, bazen V ve C'nin doğrudan M'ye bağlı oldukça tek bir bölünmez bileşenin iki yüzü olduğunu hissediyorum ve UI kontrolleri ve temel widget'lar gibi daha kısa ölçeklere inerken kaçınılmaz olarak buna düşüyor. Bu ayrıntı düzeyinde MVP çok az mantıklı. Aksine biri daha büyük ölçeklere gittiğinde, uygun arayüz sorumlulukların açık bir şekilde atanmasıyla aynı hale gelir ve burada MVP gelir.

Öte yandan, başparmağın bu ölçek kuralı, platform özellikleri, MVC'nin uygulanmasının daha kolay olduğu web'de olduğu gibi MVP'den daha kolay olduğu gibi bileşenler arasında bir tür ilişkileri desteklediğinde çok az ağırlık alabilir.

Erwin Vandervalk (ve beraberindeki makale ) tarafından hazırlanan bu imajın MVC, MVP ve MVVM, benzerlikleri ve farklılıklarının en iyi açıklaması olduğunu düşünüyorum. Makale makalenin başlığında "MVC" ve "MVP" içermediği için "MVC, MVP ve MVVM" konulu sorgular için arama motoru sonuçlarında görünmüyor; ama en iyi açıklama bence.

( Makale ayrıca Bob Martin Amca görüşmelerinde söyledikleriyle de eşleşiyor: MVC'nin aslında sistemin mimarisi için değil, küçük UI bileşenleri için tasarlandığını)

MVC'nin birçok sürümü vardır, bu cevap Smalltalk'taki orijinal MVC ile ilgilidir. Kısacası,

Bu konuşma droidcon NYC 2017 - Mimari Bileşenleri ile temiz uygulama tasarımı bunu netleştiriyor

Orada bu o kısaca açıklar Amca Bob güzel bir video MVC & MVP sonunda.

IMO, MVP, MVC'nin gelişmiş bir sürümüdür ve burada göstereceğiniz şeyin (veriler) endişesini nasıl göstereceğinizden (görünüm) ayırırsınız. Sunucu, UI'nizin iş mantığını içerir, hangi verilerin sunulması gerektiğini dolaylı olarak dayatır ve size aptal görünüm modellerinin bir listesini verir. Verileri gösterme zamanı geldiğinde, görünümünüzü (muhtemelen aynı kimlikleri içerir) bağdaştırıcınıza takmanız ve minimum görünüm kodunun girildiği bu görünüm modellerini kullanarak (yalnızca ayarlayıcıları kullanarak) ilgili görünüm alanlarını ayarlamanız yeterlidir. Başlıca faydası, UI iş mantığınızı yatay bir listede veya dikey listede öğeleri göstermek gibi birçok / çeşitli görünüme karşı test edebilmenizdir.

MVC'de, farklı katmanları yapıştırmak için arayüzler (sınırlar) üzerinden konuşuyoruz. Bir denetleyici mimarimize bir eklentidir, ancak ne gösterileceğini empoze etmek için böyle bir kısıtlama yoktur. Bu anlamda, MVP bir çeşit MVC'dir ve görüş kavramı adaptöre adaptöre takılabilir.

Umarım bu daha iyi olur.

Action-Domain-Responder'ı ( ADR ) unuttun .

Yukarıdaki bazı grafiklerde açıklandığı gibi, Model ile MVC'deki Görünüm arasında doğrudan bir ilişki / bağlantı vardır . Bir eylem gerçekleştirilir Denetleyicisi bir eylemi çalıştırır, Model . Bu işlem, Model , bir tepki tetikleyecek içinde Görünüm . Görünüm zaman, her zaman güncellenir Modeli 'nin devlet değiştirir.

Bazı insanlar unutmaya devam ediyor, MVC 70'in sonlarında yaratıldı ve Web sadece 80 "/ 90'ın başlarında" yaratıldı. MVC başlangıçta Web için değil, Denetleyici yerine Masaüstü uygulamaları için oluşturuldu. , Model ve Görüş birlikte varolacaktı.

Hala aynı adlandırma kurallarını ( model-görünüm-denetleyicisi ) kullanan web çerçeveleri ( örneğin: Laravel ) kullandığımız için , MVC olması gerektiğini düşünüyoruz, ancak aslında başka bir şey.

Bunun yerine, Action-Domain-Responder'a bir göz atın . ADR'de, Denetleyici Model / Etki Alanında bir işlem gerçekleştirecek bir Eylem alır . Şimdiye kadar aynı. Fark, daha sonra bu işlemin yanıtını / verilerini toplar ve işlemek için bir Yanıtlayıcıya ( örneğin:) iletir. Aynı bileşen üzerinde yeni bir işlem istendiğinde, Denetleyici tekrar çağrılır ve döngü kendini tekrar eder. ADR olarak, orada hiçbir bağlantı Modeli / Domain ve Görünüm (arasında Reponser tepkisi ).view()

Not: Wikipedia, " Her ADR eyleminin ayrı sınıflar veya kapanışlarla temsil edildiğini " belirtir . Bu mutlaka doğru değildir . Birkaç İşlem aynı Denetleyicide olabilir ve model hala aynıdır.

mVC adr model görüntü kontrolörü aksiyon-alan-yanıtlayıcı

En basit cevap, görünümün modelle nasıl etkileşime girdiğidir. MVP'de görünüm, görünüm ve model arasında aracı görevi gören sunum yapan kişi tarafından güncellenir. Sunucu girişi görünümden alır, bu da verileri modelden alır ve sonra gerekli olan iş mantığını gerçekleştirir ve görünümü günceller. MVC'de model, denetleyiciden geri dönmek yerine görünümü doğrudan günceller.

• MVC'de, View kullanıcı arabirimi parçasına sahiptir, kontrolör görünüm ve model arasındaki aracıdır ve model iş mantığını içerir.
• MVP'de View, sunumun hem kullanıcı arayüzünü hem de uygulamasını içerir, çünkü burada sunum yapan kişi sadece bir arayüzdür ve model aynıdır, yani iş mantığı içerir.

MVP

MVP, Model - View-Presenter anlamına gelir. Bu, 2007'nin başlarında Microsoft'un Smart Client windows uygulamalarını tanıttığı bir resme geldi.

Bir sunucu, MVP'de View olaylarını ve iş mantığını modellerden bağlayan denetleyici bir rol oynar.

View olay bağlama, bir görünüm arayüzünden Presenter'da uygulanacaktır.

Görünüm, kullanıcı girişlerinin başlatıcısıdır ve daha sonra olayları Sunum Yapan kişiye verir ve sunum yapan kişi olay bağlarını işler ve modellerden veri alır.

Artıları: Görünüm sadece kullanıcı arayüzü yok mantık değil Yüksek seviyede test edilebilirlik

Eksileri: Olay bağlamaları uygulanırken biraz karmaşık ve daha fazla çalışma

MVC

MVC, Model-View-Controller'ın kısaltmasıdır. Denetleyici, modeller oluşturmaktan ve bağlama modelleriyle görünümler oluşturmaktan sorumludur.

Denetleyici başlatıcıdır ve hangi görünümün oluşturulacağına karar verir.

Artıları: Tek Sorumluluk İlkesine Vurgu Yüksek düzeyde test edilebilirlik

Eksileri: Aynı denetleyicide birden çok görünüm oluşturmaya çalışırsanız, bazen Denetleyiciler için çok fazla iş yükü.