Это чрезмерное упрощение множества вариантов 9X_pattern этих шаблонов проектирования, но именно 9X_terminology так мне нравится думать о различиях между 9X_terminology ними.

MVC

MVP

Некоторое время назад я писал об этом в 9X_model-view-presenter блоге, цитируя Todd Snyder's excellent post on the difference between the two:

Вот основные различия между узоры:

Паттерн MVP

• Вид более слабо связан с моделью. Ведущий отвечает за привязку модели к вид.
• Легче проводить модульное тестирование, поскольку взаимодействие с представлением осуществляется через интерфейс
• Обычно представление для ведущего отображается один в один. Сложные представления могут иметь несколько ведущих.

Шаблон MVC

• Контроллеры основаны на поведении и могут быть общими для просмотры
• Может отвечать за определение того, какой вид отображать

Это 9X_ui лучшее объяснение в сети, которое я смог 9X_model-view-controller найти.

Вот иллюстрации, изображающие коммуникационный 9X_design-patterns поток

MVP не обязательно является сценарием, в котором View 9X_mvp является главным (см., например, MVP Taligent).
Мне 9X_model-view-controller жаль, что люди до сих пор проповедуют это 9X_model-view-controller как шаблон (Ответственное представление), а 9X_ui не как анти-шаблон, поскольку это противоречит 9X_programming-terms «Это просто представление» (Программист-прагматик). «Это 9X_terminology просто вид» означает, что окончательный 9X_pattern вид, отображаемый пользователю, является 9X_model-view-controller второстепенной задачей приложения. Шаблон 9X_gui MVP Microsoft значительно усложняет повторное 9X_ui использование представлений и удобно освобождает 9X_pattern дизайнера Microsoft от поощрения плохой 9X_terminology практики.

Честно говоря, я думаю, что основные 9X_terminology проблемы MVC справедливы для любой реализации 9X_model-view-controller MVP, а различия почти полностью семантические. Пока 9X_user-interface вы следуете разделению проблем между представлением 9X_nomenclature (которое отображает данные), контроллером 9X_design-patterns (который инициализирует и контролирует взаимодействие 9X_user-interface с пользователем) и моделью (базовые данные 9X_mvc и/или сервисы)) вы получаете преимущества 9X_gui MVC. . Если вы получаете преимущества, то 9X_model-view-controller кого действительно волнует, является ли 9X_design-patterns ваш шаблон MVC, MVP или Supervising Controller? Единственный 9X_gui шаблон real остается MVC, остальные — просто 9X_pattern разные его разновидности.

Обратите внимание 9X_design-patterns на this очень интересную статью, в которой подробно 9X_model-view-controller перечислены некоторые из этих различных 9X_patterns реализаций. Вы можете заметить, что все 9X_model-view-presenter они в основном делают одно и то же, но немного 9X_mvp по-разному.

Лично я думаю, что MVP только 9X_terminology недавно был повторно введен в качестве броского 9X_mvp термина либо для уменьшения споров между 9X_model-view-presenter семантическими фанатиками, которые спорят, действительно 9X_user-interface ли что-то является MVC, либо для оправдания 9X_design-patterns инструментов быстрой разработки приложений 9X_model-view-presenter Microsoft. Ни одна из этих причин в моих 9X_pattern книгах не оправдывает его существования 9X_model-view-controller в качестве отдельного шаблона проектирования.

MVP: главное представление.

Представление, в большинстве случаев, создает 9X_patterns его презентер. Ведущий будет взаимодействовать 9X_user-interface с моделью и манипулировать представлением 9X_pattern через интерфейс. Представление иногда будет 9X_model-view-controller взаимодействовать с докладчиком, обычно 9X_pattern через какой-либо интерфейс. Это сводится 9X_mvp к реализации; вы хотите, чтобы представление 9X_ui вызывало методы ведущего, или вы хотите, чтобы 9X_pattern представление имело события, которые слушает 9X_pattern ведущий? Это сводится к следующему: представление 9X_patterns знает о ведущем. Представление делегируется 9X_patterns ведущему.

MVC: контроллер отвечает.

Контроллер создается или осуществляется 9X_patterns доступ по какому-либо событию/запросу. Затем 9X_nomenclature контроллер создает соответствующее представление 9X_programming-terms и взаимодействует с моделью для дальнейшей 9X_design-patterns настройки представления. Это сводится к 9X_nomenclature следующему: контроллер создает представление 9X_mvp и управляет им; представление подчинено 9X_user-interface контроллеру. Представление не знает о контроллере.

MVC (контроллер представления модели)

Входные данные в первую очередь направлены 9X_nomenclature на контроллер, а не на представление. Этот 9X_gui ввод может поступать от пользователя, взаимодействующего 9X_ui со страницей, но это также может быть простой 9X_ui ввод определенного URL-адреса в браузере. В 9X_mvp любом случае это контроллер, с которым взаимодействуют 9X_nomenclature некоторые функции. Между Контроллером и 9X_mvp Представлением существует взаимосвязь «многие 9X_mvp к одному». Это потому, что один контроллер 9X_programming-terms может выбирать разные представления для 9X_user-interface рендеринга в зависимости от выполняемой 9X_nomenclature операции. Обратите внимание на одностороннюю 9X_mvc стрелку от контроллера к просмотру. Это 9X_model-view-presenter связано с тем, что View не имеет никаких 9X_terminology сведений о контроллере и не ссылается на 9X_mvc него. Контроллер действительно передает 9X_mvc Модель, поэтому между представлением и ожидаемой 9X_terminology моделью, передаваемой в него, существует 9X_gui информация, но не Контроллер, обслуживающий 9X_design-patterns его.

MVP (презентация представления модели)

Ввод начинается с представления, а не 9X_design-patterns с докладчика. Между представлением и соответствующим 9X_nomenclature докладчиком существует взаимно однозначное 9X_nomenclature соответствие. View содержит ссылку на Presenter. Presenter 9X_pattern также реагирует на события, запускаемые 9X_patterns из View, поэтому он знает о View, с которым 9X_nomenclature он связан. Presenter обновляет представление 9X_gui на основе запрошенных действий, которые 9X_mvp он выполняет с моделью, но представление 9X_terminology не поддерживает модель.

Подробнее Reference

Есть много ответов на этот вопрос, но я 9X_programming-terms чувствовал, что нужен какой-то действительно 9X_programming-terms простой ответ, четко сравнивающий их. Вот 9X_design-patterns обсуждение, которое я придумал, когда пользователь 9X_user-interface ищет название фильма в приложении MVP и 9X_gui MVC:

Пользователь: Нажмите нажмите …

Вид: Кто 9X_pattern это? [MVP|MVC]

Пользователь: Я только что нажал 9X_ui на кнопку поиска…

Вид: Хорошо, секундочку… . [MVP|MVC]

( View вызов 9X_ui Presenter|Controller … ) [MVP|MVC]

Вид: Эй, Ведущий|Контроллер, пользователь только что 9X_model-view-presenter нажал кнопку поиска, что мне делать? [MVP|MVC]

Ведущий|Контролер: Эй, Просмотр, есть 9X_design-patterns ли поисковый запрос на этой странице? [MVP|MVC]

View: Да,… вот 9X_model-view-presenter оно… «пианино» [MVP|MVC]

Ведущий|Контролер: Спасибо Просмотр,… тем временем 9X_gui я ищу поисковый запрос на Модель, пожалуйста, покажите 9X_nomenclature ему/ей индикатор выполнения [MVP|MVC]

( Презентатор|Контроллер вызывает 9X_patterns Модель … ) [MVP|MVC]

Ведущий|Контроллер: Эй, Модель, у вас есть совпадение по 9X_mvc этому поисковому запросу?: «пианино» [MVP|MVC]

Модель: Эй, Ведущий|Контроллер, дайте 9X_patterns мне проверить… [MVP|MVC]

( Модель делает запрос к базе 9X_design-patterns данных фильмов… ) [MVP|MVC]

( Через некоторое время 9X_pattern ... )

-------------- Здесь MVP и MVC начинают 9X_ui расходиться ---------------

Модель: Я нашла для 9X_mvc вас список, Ведущий, вот он в формате JSON “[{"name":"Учитель 9X_model-view-controller фортепиано","год":2001},{"name":"Piano"," год":1993}]” [MVP]

Модель: Доступен 9X_design-patterns некоторый результат, Контроллер. Я создал переменную 9X_model-view-presenter поля в своем экземпляре и заполнил ее результатом. Это 9X_patterns имя "searchResultsList" [MVC]

(Presenter|Controller благодарит 9X_user-interface Model и возвращается к View) [MVP|MVC]

Ведущий: Спасибо за ожидание 9X_nomenclature Посмотреть, я нашла для вас список подходящих результатов 9X_model-view-presenter и оформила их в презентабельном виде: ["Учитель 9X_mvp фортепиано 2001", "Пианино 1993"]. Пожалуйста, покажите 9X_mvc его пользователю в виде вертикального списка. Также, пожалуйста, скройте 9X_patterns индикатор выполнения [MVP]

Контролер: Спасибо за ожидание 9X_programming-terms Просмотр, я спросил Модель о вашем поисковом запросе. Он 9X_mvc говорит, что нашел список совпадающих результатов 9X_pattern и сохранил их в переменной с именем «searchResultsList» внутри 9X_pattern своего экземпляра. Вы можете получить его 9X_nomenclature оттуда. Также, пожалуйста, скройте индикатор 9X_pattern выполнения [MVC]

Просмотр: Большое спасибо Ведущий [MVP]

Вид: Спасибо, «Контроллер» [MVC] (Теперь 9X_pattern View задается вопросом: как мне представить 9X_model-view-controller пользователю результаты, которые я получаю 9X_nomenclature от Model? Должен ли год производства фильма идти 9X_programming-terms первым или последним...? Должен ли он быть 9X_nomenclature вертикальным или горизонтальным список?...)

Если 9X_terminology вам интересно, я написал серию статей, посвященных 9X_user-interface архитектурным шаблонам приложений (MVC, MVP, MVVP, чистая 9X_terminology архитектура и т. д.), сопровождаемых репозиторием 9X_terminology Github here. Несмотря на то, что образец написан 9X_patterns для Android, лежащие в его основе принципы 9X_patterns можно применить к любому носителю.

Модель-представление-контроллер

MVC - это образец архитектуры программного 9X_pattern приложения. Он разделяет логику приложения 9X_programming-terms на три отдельные части, способствуя модульности 9X_terminology и простоте совместной работы и повторного 9X_design-patterns использования. Это также делает приложения 9X_design-patterns более гибкими и удобными для итераций. Оно 9X_design-patterns разделяет приложение на следующие компоненты:

• Модели обработки данных и бизнес-логики.
• Контроллеры для работы с пользовательским интерфейсом и приложением.
• Представления для обработки объектов графического пользовательского интерфейса и представления.

Чтобы 9X_nomenclature прояснить это, давайте представим простое 9X_model-view-controller приложение со списком покупок. Все, что 9X_model-view-presenter нам нужно, это список с названием, количеством 9X_patterns и ценой каждого предмета, который нам нужно 9X_pattern купить на этой неделе. Ниже мы опишем, как 9X_pattern мы могли бы реализовать некоторые из этих 9X_ui функций с помощью MVC.

Model-View-Presenter

• модель - это данные, которые будут отображаться в представлении (пользовательском интерфейсе).
• Представление - это интерфейс, который отображает данные (модель) и направляет пользовательские команды (события) в Presenter для обработки этих данных. В представлении обычно есть ссылка на его презентатор.
• Presenter - это «посредник» (играемый контроллером в MVC) и имеет ссылки как на представление, так и на модель. Обратите внимание, что слово «модель» вводит в заблуждение. Скорее, это должна быть бизнес-логика, которая извлекает или манипулирует моделью. Например: если у вас есть база данных, хранящая User в таблице базы данных, и ваше представление хочет отображать список пользователей, тогда Presenter будет иметь ссылку на бизнес-логику вашей базы данных (например, DAO), откуда Presenter будет запрашивать список пользователей.

Если вы хотите увидеть 9X_pattern образец с простой реализацией, проверьте this Сообщение 9X_model-view-presenter GitHub

Конкретный рабочий процесс запроса 9X_model-view-presenter и отображения списка пользователей из базы 9X_mvp данных может работать следующим образом:

В 9X_ui чем разница между шаблонами MVC и MVP?

Шаблон MVC

• Контроллеры основаны 9X_mvp на поведении и могут использоваться в разных 9X_ui представлениях

• Может отвечать за определение 9X_model-view-presenter представления для отображения (шаблон переднего 9X_pattern контроллера)

Шаблон MVP

• Просмотр более слабо связан 9X_nomenclature с моделью. Ведущий отвечает за привязку 9X_mvc модели к представлению.

• Проще проводить модульное 9X_mvp тестирование, поскольку взаимодействие с 9X_gui представлением осуществляется через интерфейс

• Обычно 9X_mvp от просмотра к докладчику сопоставляют один 9X_nomenclature к одному. Сложные представления могут иметь 9X_programming-terms несколько докладчиков.

• MVP = Модель-Просмотр-Ведущий

• MVC = модель-представление-контроллер

  1. Оба шаблона презентации. Они разделяют зависимости между Моделью (например, объектами Домена), вашим экраном/веб-страницей (Вид) и тем, как должен вести себя ваш пользовательский интерфейс (Презентатор/Контроллер)
  2. Они довольно похожи по концепции, люди инициализируют Presenter/Controller по-разному в зависимости от вкуса.
  3. Отличная статья о различиях here. Наиболее примечательно то, что в шаблоне MVC модель обновляет представление.

9X_design-patterns

Также стоит помнить, что существуют разные 9X_gui типы MVP. Фаулер разделил шаблон на две 9X_nomenclature части: пассивный просмотр и контролирующий 9X_ui контроллер.

При использовании пассивного 9X_mvp представления ваше представление обычно 9X_design-patterns реализует детализированный интерфейс со 9X_model-view-controller свойствами, более или менее напрямую отображающими 9X_design-patterns базовый виджет пользовательского интерфейса. Например, у 9X_terminology вас может быть ICustomerView с такими свойствами, как 9X_gui имя и адрес.

Ваша реализация может выглядеть 9X_design-patterns примерно так:

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

Ваш класс Presenter будет общаться 9X_terminology с моделью и «сопоставлять» ее с представлением. Этот 9X_design-patterns подход называется «пассивный взгляд». Преимущество 9X_design-patterns заключается в том, что представление легко 9X_design-patterns тестировать и его легче перемещать между 9X_nomenclature платформами пользовательского интерфейса 9X_pattern (Web, Windows/XAML и т. д.). Недостатком 9X_terminology является то, что вы не можете использовать 9X_patterns такие вещи, как привязка данных (что действительно эффективно 9X_model-view-controller в таких фреймворках, как WPF и Silverlight).

Вторая разновидность 9X_nomenclature MVP — это Контролирующий Контролер. В этом 9X_programming-terms случае ваше представление может иметь свойство 9X_gui с именем Customer, которое затем снова привязывается 9X_model-view-presenter к данным виджетов пользовательского интерфейса. Вам 9X_terminology не нужно думать о синхронизации и микроуправлении 9X_mvp представлением, а управляющий контроллер 9X_programming-terms может вмешаться и помочь, когда это необходимо, например, со 9X_gui сложной логикой взаимодействия.

Третий «разновидность» MVP 9X_terminology (или кто-то, возможно, назвал бы его отдельным 9X_mvc шаблоном) — это модель представления (или 9X_terminology иногда ее называют Model-View-ViewModel). По 9X_user-interface сравнению с MVP вы «объединяете» M и P в 9X_pattern один класс. У вас есть объект клиента, к 9X_mvp которому привязаны данные ваших виджетов 9X_ui пользовательского интерфейса, но у вас также 9X_design-patterns есть дополнительные поля, специфичные для 9X_mvp пользовательского интерфейса, такие как 9X_mvc «IsButtonEnabled» или «IsReadOnly» и т. д.

Я 9X_ui думаю, что лучший ресурс, который я нашел 9X_model-view-presenter по архитектуре пользовательского интерфейса, — это 9X_patterns серия сообщений в блоге, сделанных Джереми 9X_model-view-presenter Миллером на The Build Your Own CAB Series Table of Contents. Он рассказал обо всех вариантах 9X_mvp MVP и показал код C# для их реализации.

Я 9X_pattern также писал о шаблоне Model-View-ViewModel 9X_patterns в контексте Silverlight по адресу YouCard Re-visited: Implementing the ViewModel pattern.

Обе эти платформы нацелены на разделение 9X_design-patterns задач — например, взаимодействие с источником 9X_mvp данных (моделью), логику приложения (или 9X_terminology преобразование этих данных в полезную информацию) (контроллер/презентатор) и 9X_model-view-presenter код отображения (представление). В некоторых 9X_pattern случаях модель также можно использовать 9X_nomenclature для преобразования источника данных в абстракцию 9X_model-view-presenter более высокого уровня. Хорошим примером 9X_design-patterns этого является MVC Storefront project.

Существует обсуждение here относительно 9X_design-patterns различий между MVC и MVP.

Различие заключается 9X_design-patterns в том, что в приложении MVC традиционно 9X_model-view-presenter представление и контроллер взаимодействуют 9X_programming-terms с моделью, но не друг с другом.

В проектах 9X_design-patterns MVP ведущий получает доступ к модели и взаимодействует 9X_model-view-controller с представлением.

Сказав это, ASP.NET MVC 9X_terminology по этим определениям является инфраструктурой 9X_programming-terms MVP, потому что контроллер обращается к 9X_design-patterns модели для заполнения представления, которое 9X_model-view-presenter не должно иметь логики (просто отображает 9X_programming-terms переменные, предоставленные контроллером).

Чтобы 9X_design-patterns получить представление об отличиях ASP.NET 9X_terminology MVC от MVP, ознакомьтесь со статьей this MIX presentation Скотта 9X_ui Хансельмана.

Оба шаблона пытаются разделить представление 9X_model-view-controller и бизнес-логику, отделив бизнес-логику от 9X_model-view-presenter аспектов пользовательского интерфейса

Архитектурно 9X_terminology MVP — это подход, основанный на контроллере 9X_programming-terms страниц, а MVC — подход, основанный на переднем 9X_model-view-controller контроллере. Это означает, что в стандартной 9X_ui веб-форме MVP жизненный цикл страницы просто 9X_gui улучшен за счет извлечения бизнес-логики 9X_mvp из кода позади. Другими словами, страница 9X_model-view-controller обслуживает http-запрос. Другими словами, MVP 9X_model-view-controller IMHO — это эволюционный тип усовершенствования 9X_model-view-controller веб-формы. MVC, с другой стороны, полностью 9X_terminology меняет игру, потому что запрос перехватывается 9X_patterns классом контроллера до загрузки страницы, бизнес-логика 9X_nomenclature выполняется тут же, а затем в конечном результате 9X_ui обработки контроллером данных, только что 9X_patterns выгруженных на страницу («просмотр») В этом 9X_pattern смысле MVC очень похож (по крайней мере, на 9X_mvc мой взгляд) на вариант Supervising Controller 9X_mvp MVP, дополненный механизмом маршрутизации

Оба 9X_programming-terms они поддерживают TDD и имеют как недостатки, так 9X_user-interface и преимущества.

Решение о том, как выбрать 9X_gui один из них, ИМХО, должно основываться на 9X_mvc том, сколько времени вы вложили в веб-разработку 9X_gui ASP NET. Если кто-то считает себя хорошим 9X_programming-terms в веб-формах, я бы предложил MVP. Если кто-то 9X_design-patterns чувствует себя не очень комфортно в таких 9X_programming-terms вещах, как жизненный цикл страницы и т. Д., MVC 9X_model-view-controller может быть здесь.

Вот еще одна ссылка на 9X_ui пост в блоге, дающая немного больше подробностей 9X_terminology по этой теме

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

Я использовал как MVP, так и MVC, и хотя 9X_mvp мы, как разработчики, склонны сосредотачиваться 9X_nomenclature на технических различиях обоих шаблонов, суть 9X_nomenclature MVP в IMHO гораздо больше связана с простотой 9X_programming-terms внедрения, чем с чем-либо еще.

Если я работаю 9X_mvp в команде, у которой уже есть хороший опыт 9X_mvp в области разработки веб-форм, гораздо проще 9X_pattern внедрить MVP, чем MVC. Я бы сказал, что 9X_patterns MVP в этом сценарии - быстрая победа.

Мой 9X_model-view-controller опыт подсказывает мне, что переместить команду 9X_patterns с веб-форм на MVP, а затем с MVP на MVC 9X_nomenclature относительно легко; переход от веб-форм 9X_user-interface к MVC сложнее.

Я оставляю здесь ссылку на 9X_mvc серию статей, опубликованных моим другом 9X_ui о MVP и MVC.

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

В MVP представление рисует данные от ведущего, который 9X_nomenclature рисует и подготавливает / нормализует данные 9X_design-patterns из модели, в то время как в MVC контроллер 9X_model-view-controller рисует данные из модели и устанавливает 9X_programming-terms их путем нажатия в представлении.

В MVP у 9X_ui вас может быть одно представление, работающее 9X_model-view-controller с несколькими типами докладчиков, и одно 9X_gui выступающее, работающее с разными несколькими 9X_design-patterns представлениями.

MVP обычно использует какую-либо 9X_user-interface структуру привязки, например структуру привязки 9X_design-patterns Microsoft WPF или различные структуры привязки 9X_mvp для HTML5 и Java.

В этих фреймворках UI / HTML5 9X_terminology / XAML знает, какое свойство презентатора 9X_user-interface отображает каждый элемент UI, поэтому, когда 9X_pattern вы привязываете представление к презентатору, оно 9X_pattern ищет свойства и знает, как извлекать данные 9X_gui из их и как установить их, когда значение 9X_patterns изменяется в пользовательском интерфейсе 9X_user-interface пользователем.

Так, если, например, модель 9X_design-patterns представляет собой автомобиль, то ведущий 9X_user-interface представляет собой своего рода автомобильный 9X_design-patterns ведущий, который показывает свойства автомобиля 9X_mvc (год, производитель, количество мест и т. д.). Представлению 9X_model-view-controller известно, что текстовое поле под названием 9X_terminology «производитель автомобиля» должно отображать 9X_design-patterns свойство presenter Maker.

Затем вы можете 9X_gui привязать к представлению множество различных 9X_model-view-controller типов докладчиков, у всех должно быть свойство 9X_pattern Maker - это может быть самолет, поезд или 9X_design-patterns что-то еще, представление не имеет значения. Представление 9X_user-interface получает данные от докладчика - независимо 9X_ui от того, какой - при условии, что оно реализует 9X_mvp согласованный интерфейс.

Фреймворк привязки, если 9X_model-view-presenter убрать его, на самом деле это контроллер 9X_pattern :-)

Итак, вы можете рассматривать MVP как 9X_patterns эволюцию MVC.

MVC - это замечательно, но 9X_model-view-presenter проблема в том, что обычно его контроллер 9X_gui для каждого представления. Контроллер A 9X_ui знает, как устанавливать поля представления 9X_model-view-presenter A. Если теперь вы хотите, чтобы представление 9X_nomenclature A отображало данные модели B, вам нужно, чтобы 9X_user-interface контроллер A знал модель B, или вам нужен 9X_design-patterns контроллер A для получения объекта с интерфейсом 9X_programming-terms - что похоже на Только MVP без привязок, или 9X_user-interface вам нужно переписать код набора пользовательского 9X_patterns интерфейса в контроллере B.

Заключение. И 9X_ui MVP, и MVC не связаны с шаблонами пользовательского 9X_model-view-presenter интерфейса, но MVP обычно использует структуру 9X_nomenclature привязок, которая является MVC ниже. THUS 9X_mvp MVP находится на более высоком архитектурном 9X_model-view-controller уровне, чем MVC, и шаблон оболочки выше 9X_model-view-controller MVC.

Мое скромное краткое мнение: MVP предназначен 9X_design-patterns для больших масштабов, а MVC - для крошечных 9X_model-view-presenter масштабов. С помощью MVC я иногда чувствую, что 9X_mvc V и C можно рассматривать как две стороны 9X_pattern одного неделимого компонента, скорее напрямую 9X_mvp связанных с M, и одна неизбежно попадает 9X_mvp в это при переходе к более коротким масштабам, таким 9X_pattern как элементы управления пользовательского 9X_mvp интерфейса и базовые виджеты. На этом уровне 9X_pattern детализации MVP не имеет смысла. Когда кто-то, наоборот, переходит 9X_model-view-presenter к более крупным масштабам, правильный интерфейс 9X_mvc становится более важным, то же самое и с 9X_pattern недвусмысленным распределением обязанностей, и 9X_programming-terms здесь появляется MVP.

С другой стороны, это 9X_patterns эмпирическое правило масштабирования может 9X_programming-terms иметь очень небольшой вес, если характеристики 9X_model-view-presenter платформы благоприятствуют каким-то отношениям 9X_design-patterns между компонентами, например, в сети, где 9X_pattern кажется, что реализовать MVC проще, чем 9X_gui MVP. .

Я думаю, что это изображение Эрвина Вандервалька 9X_ui (и прилагаемый к нему article) является лучшим 9X_pattern объяснением MVC, MVP и MVVM, их сходства 9X_nomenclature и различий. article не отображается в результатах 9X_programming-terms поиска по запросам «MVC, MVP и MVVM», потому 9X_terminology что заголовок статьи не содержит слов «MVC» и 9X_user-interface «MVP»; но я думаю, что это лучшее объяснение.

(article также 9X_mvp соответствует тому, что дядя Боб Мартин 9X_pattern сказал в одном из своих выступлений: что 9X_model-view-presenter MVC изначально был разработан для небольших 9X_user-interface компонентов пользовательского интерфейса, а 9X_model-view-presenter не для архитектуры системы)

Существует много версий MVC, этот ответ 9X_gui касается исходного MVC в Smalltalk. Вкратце, это

Этот 9X_mvc доклад droidcon NYC 2017 - Clean app design with Architecture Components разъясняет это

MVC (модель-представление-контроллер)

В MVC за все отвечает Контроллер! Контроллер 9X_pattern запускается или осуществляется доступ на 9X_ui основе некоторых событий / запросов, а затем 9X_mvc управляет представлениями.

Представления 9X_model-view-presenter в MVC практически не имеют состояния, контроллер 9X_pattern отвечает за выбор представления для отображения.

Например: Когда 9X_model-view-presenter пользователь нажимает кнопку «Показать мой 9X_user-interface профиль», запускается контроллер. Он связывается 9X_pattern с моделью, чтобы получить соответствующие 9X_user-interface данные. Затем отображается новое представление, напоминающее 9X_ui страницу профиля. Контроллер может брать 9X_pattern данные из модели и передавать их непосредственно 9X_programming-terms в представление - как предложено на приведенной 9X_mvc выше диаграмме - или позволить представлению 9X_model-view-controller извлекать данные из самой модели.

MVP (Model-View-Presenter)

В MVP главное 9X_programming-terms - представление! каждый View вызывает своего 9X_mvp Presenter или имеет некоторые события, которые 9X_terminology Presenter слушает.

Представления в MVP не 9X_nomenclature реализуют никакой логики, презентатор отвечает 9X_design-patterns за реализацию всей логики и взаимодействует 9X_mvp с представлением, используя какой-то интерфейс.

Например: Когда 9X_pattern пользователь нажимает кнопку «Сохранить», обработчик 9X_user-interface событий в представлении передает полномочия 9X_mvp методу «OnSave» докладчика. Презентатор 9X_design-patterns выполнит необходимую логику и любую необходимую 9X_patterns связь с моделью, затем обратится к представлению 9X_programming-terms через свой интерфейс, чтобы представление 9X_model-view-presenter могло показать, что сохранение было завершено.

MVC против MVP

• MVC не возлагает ответственность за представление на представление, представления действуют как подчиненные устройства, которыми может управлять и направлять контроллер.
• В MVC представления не имеют состояния, в отличие от представлений в MVP, где они сохраняют состояние и могут изменяться со временем.
• В MVP у представлений нет логики, и мы должны делать их по возможности бессмысленными. С другой стороны, представления в MVC могут иметь некоторую логику.
• В MVP докладчик отделен от представления и общается с ним через интерфейс. Это позволяет имитировать представление в модульных тестах.
• В MVP представления полностью изолированы от модели. Однако в MVC представления могут взаимодействовать с представлением, чтобы не отставать от него. актуальные данные.

Самый простой ответ - как представление 9X_user-interface взаимодействует с моделью. В MVP представление 9X_user-interface обновляется ведущим, который действует как 9X_user-interface посредник между представлением и моделью. Докладчик 9X_terminology принимает входные данные из представления, которое 9X_model-view-presenter извлекает данные из модели, а затем выполняет 9X_design-patterns любую требуемую бизнес-логику, а затем обновляет 9X_gui представление. В MVC модель обновляет представление 9X_model-view-presenter напрямую, а не возвращается через контроллер.

Есть this хорошее видео от дяди Боба, где он 9X_mvc кратко объясняет MVC и MVP в конце.

IMO, MVP - это 9X_patterns улучшенная версия MVC, в которой вы в основном 9X_model-view-presenter отделяете заботу о том, что вы собираетесь 9X_pattern показывать (данные) от того, как вы собираетесь 9X_programming-terms показывать (представление). Презентатор 9X_programming-terms включает в себя своего рода бизнес-логику 9X_design-patterns вашего пользовательского интерфейса, неявно 9X_terminology указывает, какие данные должны быть представлены, и 9X_model-view-presenter дает вам список глупых моделей представления. И 9X_design-patterns когда приходит время отображать данные, вы 9X_nomenclature просто подключаете свое представление (возможно, с 9X_terminology теми же идентификаторами) к адаптеру и устанавливаете 9X_mvp соответствующие поля представления, используя 9X_user-interface эти модели представления, с минимальным 9X_mvc количеством вводимого кода (просто используя 9X_nomenclature сеттеры). Его главное преимущество заключается 9X_terminology в том, что вы можете протестировать бизнес-логику 9X_model-view-presenter пользовательского интерфейса на множестве 9X_mvp / различных представлениях, таких как отображение 9X_terminology элементов в горизонтальном или вертикальном 9X_user-interface списке.

В MVC мы говорим через интерфейсы 9X_mvp (границы) для склеивания разных слоев. Контроллер 9X_terminology - это плагин к нашей архитектуре, но у него 9X_user-interface нет такого ограничения, чтобы налагать то, что 9X_model-view-controller показывать. В этом смысле MVP - это своего 9X_model-view-controller рода MVC с концепцией представлений, подключаемых 9X_mvc к контроллеру через адаптеры.

Надеюсь, это 9X_patterns поможет лучше.

Вы забыли о Action-Domain-Responder (ADR).

Как показано на некоторых 9X_mvc рисунках выше, существует прямая связь / связь 9X_programming-terms между моделью и представлением в MVC. В Контроллере выполняется действие, которое 9X_mvc выполняет действие для Модели. Это действие в 9X_terminology модели, вызовет реакцию в представлении. Представление всегда обновляется при изменении 9X_design-patterns состояния Модели.

Некоторые люди постоянно забывают, что 9X_model-view-controller MVC was created in the late 70" и что Интернет был создан только в 9X_mvc конце 80-х / начале 90-х. MVC изначально 9X_user-interface создавался не для Интернета, а для настольных 9X_patterns приложений, где контроллер, модель и представление 9X_model-view-controller могли сосуществовать вместе.

Поскольку мы 9X_terminology используем веб-фреймворки (например: Laravel), которые по-прежнему 9X_programming-terms используют те же соглашения об именах (model-view-controller), мы 9X_pattern склонны думать, что он должен быть MVC, но 9X_programming-terms на самом деле это нечто другое.

Взгляните 9X_patterns на Action-Domain-Responder. В ADR Контроллер получает Действие, которое выполняет 9X_mvp операцию в Модели / Домене. Пока то же самое. Разница в 9X_model-view-controller том, что затем он собирает ответ / данные 9X_gui этой операции и передает их Responder (например: view()) для визуализации. Когда 9X_ui для того же компонента запрашивается новое 9X_design-patterns действие, снова вызывается Контроллер, и цикл повторяется. В 9X_mvc ADR нет связи между моделью / доменом и представлением 9X_pattern (ответ респондента).

Примечание. Википедия утверждает, что «каждое действие ADR, однако, представлено отдельными классами или закрытием». Это не обязательно 9X_mvp правда. Несколько действий могут находиться 9X_pattern в одном контроллере, и шаблон остается прежним.

mvc adr model-view-controller action-domain-responder

В двух словах

• В MVC View имеет часть пользовательского интерфейса, которая вызывает контроллер, который, в свою очередь, вызывает модель, а модель, в свою очередь, запускает события обратно для просмотра.
• В MVP View содержит пользовательский интерфейс и вызывает презентатора для реализации части. Ведущий вызывает представление напрямую для обновления части пользовательского интерфейса. Модель, которая содержит бизнес-логику, вызывается докладчиком и не взаимодействует с представлением. Так что здесь ведущий выполняет большую часть работы :)

9X_patterns