Если вы смотрите за RAD (drag-drop и configure) способ создания пользовательских интерфейсов, которые многие инструменты поощряют, вы, вероятно, столкнетесь с тремя шаблоны проектирования Model-View-Controller, Model-View-Presenter и Model-View-ViewModel. Мой вопрос состоит из трех частей:
В MVP Presenter содержит бизнес-логику пользовательского интерфейса для представления. Все вызовы из View делегируются непосредственно в Presenter. Презентатор также отделен непосредственно от представления и общается с ним через интерфейс. Это делается для того, чтобы разрешить насмешку над видом в модульном тесте. Одним из общих атрибутов MVP является то, что должно быть много двусторонней диспетчеризации. Например, когда кто-то нажимает кнопку "Сохранить", обработчик события делегирует метод Presenter "OnSave". Как только сохранение завершено, докладчик затем перезвонит представлению через его интерфейс, чтобы представление могло отобразить, что сохранение завершено.
MVP имеет тенденцию быть очень естественной моделью для достижения отдельного представления в веб-формах. Причина в том, что представление всегда сначала создается средой выполнения ASP.NET. Вы можете узнать больше об обоих вариантах.
Пассивное представление: представление настолько глупо, насколько это возможно, и содержит практически нулевую логику. Ведущий - посредник, который говорит с Видом и Моделью. Вид и Модель полностью защищены друг от друга. Модель может вызывать события, но докладчик подписывается на них для обновления представления. В пассивном просмотре нет прямой привязки данных, вместо этого вид предоставляет свойства сеттера, которые Presenter использует для установки данных. Все состояние управляется в Presenter, а не View.
Контролирующий контроллер. Ведущий обрабатывает жесты пользователя. Представление привязывается к модели напрямую через привязку данных. В этом случае это задание Presenter передать модель в представление, чтобы она могла с ней связываться. Presenter также будет содержать логику для таких жестов, как нажатие кнопки, навигация и т.д.
В MVC контроллер отвечает за определение того, какое представление отображать в ответ на любое действие, в том числе при загрузке приложения. Это отличается от MVP, где действия направляются через представление к докладчику. В MVC каждое действие в представлении соотносится с вызовом контроллера и действием. В сети каждое действие включает в себя обращение к URL-адресу, с другой стороны которого есть контроллер, который отвечает. Как только этот Контроллер завершит свою обработку, он вернет правильный вид. Последовательность продолжается таким образом на протяжении всей жизни приложения:
Action in the View
-> Call to Controller
-> Controller Logic
-> Controller returns the View.
Еще одно большое отличие от MVC заключается в том, что представление напрямую не связывается с моделью. Представление просто визуализируется и полностью не имеет состояния. В реализациях MVC View обычно не имеет никакой логики в коде позади. Это противоречит MVP, где это абсолютно необходимо, потому что, если View не делегирует Presenter, он никогда не будет вызван.
Еще один шаблон, на который стоит обратить внимание, - это модель представления. В этом шаблоне нет предъявителя. Вместо этого представление напрямую связывается с моделью представления. Модель презентации - это модель, созданная специально для просмотра. Это означает, что эта Модель может раскрывать свойства, которые никогда не будут добавлены в модель предметной области, поскольку это будет нарушением разделения проблем. В этом случае модель представления связывается с моделью предметной области и может подписываться на события, поступающие из этой модели. Затем представление подписывается на события, поступающие из модели презентации, и обновляется соответствующим образом. Модель представления может предоставлять команды, которые представление использует для вызова действий. Преимущество этого подхода состоит в том, что вы можете по существу полностью удалить выделенный код, так как PM полностью инкапсулирует все поведение представления. Этот шаблон является очень сильным кандидатом для использования в приложениях WPF и также называется Model-View-ViewModel.
В MSDN есть статья о модели представления и раздел в Руководстве по составным приложениям для WPF (прежняя призма) об отдельных шаблонах представления.
Это упрощение многих вариантов этих шаблонов проектирования, но именно так мне нравится думать о различиях между ними.
MVC
MVP
Я писал об этом некоторое время назад, цитируя Тодд Снайдер, отличный пост по разнице между двумя:
Вот основные различия между шаблоны:
Шаблон MVP
- Вид более слабо связан с моделью. Ведущий ответственный за привязку модели к вид.
- Легче unit test, поскольку взаимодействие с представлением осуществляется через интерфейс
- Обычно просмотр карты презентатора один к одному. Сложные представления могут иметь несколько презентаторов.
Шаблон MVC
- Контроллер основан на поведении и может использоваться совместно просмотры
- Может быть ответственным за определение того, какой вид для отображения
Это лучшее объяснение в Интернете, которое я мог найти.
Вот иллюстрации, которые представляют собой поток коммуникации
MVP - это не обязательно сценарий, когда представление является ответственным (см., Например, Taligent MVP).
Я сожалею, что люди все еще проповедуют это как шаблон ("Взгляд на ответственное лицо") в противоположность анти-шаблону, поскольку он противоречит "Это просто взгляд" (Прагматичный программист). "Это просто вид" гласит, что окончательный вид, показанный пользователю, является второстепенной задачей приложения. Шаблон Microsoft MVP значительно затрудняет повторное использование Views и удобно освобождает дизайнера Microsoft от поощрения плохой практики.
Чтобы быть совершенно откровенным, я думаю, что основные проблемы MVC справедливы для любой реализации MVP, и различия почти полностью семантические. Пока вы следите за разделением интересов между представлением (которое отображает данные), контроллером (который инициализирует и контролирует взаимодействие с пользователем) и моделью (базовые данные и/или службы)), вы получаете преимущества MVC., Если вы получаете преимущества, то кого действительно волнует, является ли ваш паттерн MVC, MVP или Supervising Controller? Единственный реальный образец остается как MVC, остальные просто отличаются его разновидностями.
Рассмотрим эту чрезвычайно захватывающую статью, в которой подробно перечислен ряд этих различных реализаций. Вы можете заметить, что все они в основном делают одно и то же, но немного по-другому.
Лично я считаю, что MVP был недавно вновь введен в качестве броского термина для сокращения споров между семантическими фанатиками, которые утверждают, является ли что-то действительно MVC или нет, или для оправдания инструментов быстрой разработки приложений Microsoft. Ни одна из этих причин в моих книгах не оправдывает его существование в качестве отдельного шаблона проектирования.
В большинстве случаев представление создает презентацию. Ведущий будет взаимодействовать с моделью и манипулировать представлением через интерфейс. Представление иногда взаимодействует с презентатором, как правило, через некоторый интерфейс. Это сводится к реализации; хотите ли вы, чтобы представление вызывало методы на презентаторе или вы хотите, чтобы представление имело события, которые прослушивает презентатор? Это сводится к следующему: вид знает о ведущей. Представление делегатов.
Контроллер создается или открывается на основе какого-либо события/запроса. Затем контроллер создает соответствующее представление и взаимодействует с моделью для дальнейшей настройки представления. Он сводится к: контроллер создает и управляет просмотром; представление подчинено контроллеру. Представление не знает о контроллере.
MVC (Model View Controller)
Ввод направляется сначала на контроллер, а не на вид. Этот вход может исходить от пользователя, взаимодействующего со страницей, но также может быть просто введением определенного URL-адреса в браузер. В любом случае, это Контроллер, который сопряжен с возможностью запуска некоторых функций. Между контроллером и представлением существует взаимосвязь "один-к-одному". Это объясняется тем, что один контроллер может выбирать различные представления для визуализации на основе выполняемой операции. Обратите внимание на стрелку в одну сторону от контроллера до View. Это связано с тем, что представление не имеет никакого знания или ссылки на контроллер. Контроллер действительно возвращает модель, поэтому есть знания между представлением и ожидаемой моделью, передаваемыми в нее, но не Контроллер, обслуживающий его.
MVP (презентатор представления модели)
Ввод начинается с представления, а не с презентатором. Существует сопоставление "один к одному" между представлением и ассоциированным презентатором. В представлении содержится ссылка на презентатора. Презентатор также реагирует на события, которые запускаются из представления, поэтому он знает, что связано с ним. Презентатор обновляет представление на основе запрошенных действий, которые он выполняет в модели, но представление не относится к модели.
Подробнее Ссылка
Есть много ответов на этот вопрос, но я чувствовал, что нужен какой-то действительно простой ответ, четко сопоставляющий эти два вопроса. Вот обсуждение, которое я придумал, когда пользователь ищет название фильма в приложении MVP и MVC:
Пользователь: Нажмите, нажмите...
Вид: кто это? [ MVP | MVC ]
Пользователь: Я только что нажал на кнопку поиска...
Вид: Хорошо, подожди секундочку... [ MVP | MVC ]
(Вид вызова вызывающего | Контроллер…) [ MVP | MVC ]
View: Hey Presenter | Controller, пользователь только что нажал на кнопку поиска, что мне делать? [ MVP | MVC ]
Ведущий | Контролер: Привет, вид, есть ли поисковый запрос на этой странице? [ MVP | MVC ]
Вид: Да,… вот оно… "пианино" [ MVP | MVC ]
Ведущий: Спасибо, просмотр,... пока я ищу поисковый запрос по модели, пожалуйста, покажите ему/ей индикатор выполнения [ MVP | MVC ]
(Ведущий | Контроллер вызывает модель…) [ MVP | MVC ]
Ведущий | Контролер: Эй, модель, у тебя есть совпадение по этому поисковому запросу?: "фортепиано" [ MVP | MVC ]
Модель: Эй, ведущий | Контроллер, позвольте мне проверить… [ MVP | MVC ]
(Модель делает запрос к базе данных фильмов…) [ MVP | MVC ]
( Спустя некоторое время... )
-------------- Это где MVP и MVC начинают расходиться ---------------
Модель: Я нашел для вас список, ведущий, вот он в формате JSON "[{" name ":" Piano Teacher "," year ": 2001}, {" name ":" Piano "," year ": 1993} ] "[ MVP ]
Модель: Есть некоторый результат, Контроллер. Я создал переменную поля в моем экземпляре и заполнил ее результатом. Это имя "searchResultsList" [ MVC ]
(Ведущий | Контроллер благодарит Модель и возвращается к Представлению) [ MVP | MVC ]
Ведущий: Спасибо за ожидание View, я нашел для вас список подходящих результатов и расположил их в презентабельном формате: ["Piano Teacher 2001", "Piano 1993"]. Пожалуйста, покажите это пользователю в вертикальном списке. Также, пожалуйста, спрячьте индикатор выполнения [ MVP ].
Контроллер: Спасибо за ожидание просмотра, я спросил модель о вашем поисковом запросе. Он говорит, что нашел список совпадающих результатов и сохранил их в переменной с именем "searchResultsList" внутри своего экземпляра. Вы можете получить это оттуда. Также, пожалуйста, скройте индикатор прогресса сейчас [ MVC ].
Просмотр: Большое спасибо Ведущий [ MVP ]
Представление: спасибо "Контроллер" [ MVC ] (Теперь представление задает себе вопрос: как мне представить результаты, полученные от модели, пользователю? Должен ли год производства фильма быть первым или последним...? Должен ли он быть в вертикальном или горизонтальном списке?...)
В случае, если вы заинтересованы, я пишу серию статей, посвященных приложения архитектурных паттерны (MVC, MVP, MVVP, чистая архитектура,...), сопровождающийся репо Github здесь. Несмотря на то, что образец написан для Android, основные принципы могут быть применены к любому носителю.
MVC = Model-View-Controller
Также стоит помнить, что существуют и другие типы MVP. Фаулер разбил шаблон на два - пассивный и контрольный контроллер.
При использовании пассивного представления в вашем представлении обычно реализуется мелкозернистый интерфейс с сопоставлением свойств более или менее непосредственно с подклассом пользовательского интерфейса. Например, у вас может быть ICustomerView с такими свойствами, как имя и адрес.
Ваша реализация может выглядеть примерно так:
public class CustomerView : ICustomerView
{
public string Name
{
get { return txtName.Text; }
set { txtName.Text = value; }
}
}
Ваш класс Presenter будет разговаривать с моделью и "сопоставлять" ее с представлением. Этот подход называется "Пассивный вид". Преимущество в том, что просмотр легко проверить, и легче перемещаться между платформами пользовательского интерфейса (Web, Windows/XAML и т.д.). Недостаток заключается в том, что вы не можете использовать такие вещи, как привязка данных (которая действительно эффективна в таких фреймах, как WPF и Silverlight).
Второй вкус MVP - Контролирующий Контроллер. В этом случае ваш View может иметь свойство Customer, которое затем снова привязывается к виджетам пользовательского интерфейса. Вам не нужно думать о синхронизации и микроконтроллере представления, а диспетчер Supervising может входить и помогать при необходимости, например, с закодированной логикой взаимодействия.
Третий "вкус" MVP (или кто-то, возможно, назвал бы его отдельным образцом) - это модель представления (или иногда называемая Model-View-ViewModel). По сравнению с MVP вы "объединяете" M и P в один класс. У вас есть объект вашего клиента, к которому привязаны данные вашего пользовательского интерфейса, но у вас также есть дополнительные поля пользовательского интерфейса, такие как "IsButtonEnabled" или "IsReadOnly" и т.д.
Я думаю, что лучший ресурс, который я нашел для архитектуры пользовательского интерфейса, - это серия сообщений в блогах, сделанных Джереми Миллером на Строить свою собственную таблицу CAB Содержание. Он рассмотрел все вкусы MVP и показал код С# для их реализации.
Я также писал о шаблоне Model-View-ViewModel в контексте Silverlight в YouCard Пересмотренный: реализация шаблона ViewModel.
Model-View-Controller
MVC - это образец архитектуры программного приложения. Он разделяет логику приложения на три отдельные части, способствуя модульности и простоте совместной работы и повторного использования. Это также делает приложения более гибкими и приветливыми к итерациям. Оно разделяет приложение на следующие компоненты:
Чтобы сделать это немного более понятным, представьте себе простое приложение со списком покупок. Все, что нам нужно, это список названий, количества и цены каждого товара, который нам нужно купить на этой неделе. Ниже мы опишем, как мы могли бы реализовать некоторые из этих функций, используя MVC.
Model-View-Presenter
Если вы хотите увидеть пример с простой реализацией, пожалуйста, проверьте этот пост на GitHub
Конкретный рабочий процесс запроса и отображения списка пользователей из базы данных может работать следующим образом: 
В чем разница между шаблонами MVC и MVP?
MVC Pattern
Контроллер основан на поведении и может быть разделен между представлениями
Может быть ответственным за определение того, какой вид отображать (шаблон переднего контроллера)
MVP Pattern
Вид более слабо связан с моделью. Докладчик отвечает за привязку модели к представлению.
Легче для модульного тестирования, потому что взаимодействие с представлением осуществляется через интерфейс
Обычно вид на карту докладчика один к одному. Сложные представления могут иметь несколько докладчиков.
Каждый из них обращается к различным проблемам и может даже объединяться вместе, чтобы иметь что-то вроде ниже
Существует также полное сравнение MVC, MVP и MVVM здесь
Обе эти структуры направлены на разделение проблем - например, взаимодействие с источником данных (моделью), логикой приложения (или превращением этих данных в полезную информацию) (Controller/Presenter) и отображаемым кодом (View). В некоторых случаях модель также может использоваться для превращения источника данных в абстракцию более высокого уровня. Хорошим примером этого является проект MVC Storefront.
Здесь обсуждается относительно различий между MVC и MVP.
Различие заключается в том, что в приложении MVC традиционно есть представление, и контроллер взаимодействует с моделью, но не друг с другом.
Проекты MVP имеют Presenter, чтобы получить доступ к модели и взаимодействовать с представлением.
Сказав это, ASP.NET MVC посредством этих определений представляет собой структуру MVP, потому что Controller обращается к Модели для заполнения представления, которое не имеет логики (просто отображает переменные, предоставленные контроллером).
Чтобы получить представление об отличии ASP.NET MVC от MVP, просмотрите эту презентацию MIX от Scott Hanselman.
Несколько лет назад я написал статью по теме шаблонов архитектуры интерактивных приложений, которая включает подробное обсуждение шаблонов MVC и вариантов шаблонов MVP. Вы можете найти статью здесь.
Оба являются шаблонами, пытающимися отделить презентационную и бизнес-логику, отделяя бизнес-логику от аспектов пользовательского интерфейса.
Архитектурно, MVP - это подход на основе Page Controller, где MVC - подход на основе Front Controller. Это означает, что в стандартном веб-формате MVP жизненный цикл страницы просто усиливается путем извлечения бизнес-логики из кода позади. Другими словами, страница является одним из обслуживающих HTTP-запросов. Другими словами, MVP IMHO является эволюционным типом расширения веб-формы. MVC с другой стороны полностью изменяет игру, потому что запрос перехватывается классом контроллера до загрузки страницы, бизнес-логика выполняется там, а затем в конечном результате контроллера обрабатывает данные, которые просто сбрасываются на страницу ( "вид" ) В этом смысле MVC (по крайней мере, для меня) много внимания уделяет вкусу диспетчерского контроля MVP с помощью механизма маршрутизации
Оба из них позволяют TDD и имеют нижние и верхние стороны.
Решение о том, как выбрать один из них, должно быть основано на том, сколько времени было потрачено на создание веб-формы веб-формы ASP NET. Если бы вы считали себя хорошим в веб-формах, я бы предложил MVP. Если бы вы чувствовали себя не так комфортно в таких вещах, как жизненный цикл страницы и т.д. MVC мог бы быть здесь.
Здесь еще одна ссылка на блог, дающая немного больше информации по этой теме
Я использовал MVP и MVC, и хотя мы, как разработчики, склонны сосредотачиваться на технических различиях обоих шаблонов, точка для MVP в IMHO гораздо больше связана с простотой принятия, чем с чем-либо еще.
Если Im работает в команде, которая уже является хорошим фоном в стиле разработки веб-форм, гораздо проще внедрить MVP, чем MVC. Я бы сказал, что MVP в этом сценарии - быстрая победа.
Мой опыт подсказывает мне, что перемещение команды из веб-форм в MVP, а затем из MVP в MVC относительно просто; переход от веб-форм к MVC сложнее.
Я оставляю ссылку на серию статей, опубликованных моим другом о MVP и MVC.
http://www.qsoft.be/post/Building-the-MVP-StoreFront-Gutthrie-style.aspx
В android есть версия mvc, которая является mvp: Что такое MVP?
Шаблон MVP позволяет отделить уровень представления от логики, так что все, что работает с интерфейсом, отделено от того, как мы представляем его на экране. В идеале шаблон MVP достигнет той же логики, которая может иметь совершенно разные и взаимозаменяемые представления.
Первое, что нужно прояснить, это то, что MVP не является архитектурным шаблоном, и он отвечает только за уровень представления. В любом случае всегда лучше использовать его для своей архитектуры, которая не использует его вообще.
Примером для mvp является https://github.com/antoniolg/androidmvp
Что такое MVC? Архитектура MVC является одной из самых старых моделей, доступных для достижения разделения проблем. MVC состоит из трех уровней: Model, View и Controller.
Классический MVC существовал в то время, когда каждый элемент управления/гаджета, который существовал на экране, считался немым, и каждый элемент управления соединен с его собственным контроллером для управления взаимодействием пользователей с ними. Поэтому, если 10 гаджетов существуют, то 10 контроллеров должны существовать. В этом случае каждый гаджет считается представлением. Появление систем Windows GUI изменило эту картину. Отношение Control-Controller стало устаревшим. Элементы управления получили интеллект, чтобы реагировать на действия, инициированные пользователем. В мире Windows вид - это поверхность, на которой все элементы управления/гаджеты существуют, поэтому существует потребность только в одном контроллере. Просмотр может принимать события и получать доступ к контроллерам для дальнейшей обработки.
Пример кода для mvc в android http://androidexample.com/Use_MVC_Pattern_To_Create_Very_Basic_Shopping_Cart__-_Android_Example/index.php?view=article_discription&aid=116&aaid=138
Разница между ними доступна здесь http://www.codeproject.com/Articles/288928/Differences-between-MVC-and-MVP-for-Beginners
Теперь из моего опыта вы должны использовать MVP для проекта на основе android, потому что это улучшенная версия MVC Model.
Что-то, чего я не понимаю, связано с тем, что привязка данных должна уменьшить тестируемость. Я имею в виду, что представление эффективно основывается на том, что можно рассматривать как один или несколько представлений базы данных, не так ли? Там могут быть соединения между строками в разных представлениях. В качестве альтернативы мы можем говорить объектно-ориентированными, а не реляционными, но это на самом деле ничего не меняет - у нас все еще есть один или несколько отдельных объектов данных.
Если мы рассматриваем программирование как структуры данных + алгоритмы, то не было бы лучше, если бы структуры данных были максимально ясными, а затем разработали алгоритмы, каждая из которых зависела как можно меньше от части данных с минимальной связью между алгоритмами?
Я ощущаю очень образные шаблоны FactoryFactoryFactory Java-esque здесь - мы хотим иметь множество представлений, несколько моделей, множество степеней свободы повсюду. Это почти так, что это движущая сила MVC и MVP и еще много чего. Теперь позвольте мне спросить: как часто вы стоите за это (и там определенно стоит стоимость)?
Я также не вижу обсуждения того, как эффективно управлять состоянием между HTTP-запросами. Разве мы не узнали от функциональных людей (и объемных ошибок, сделанных императивными спагетти), что состояние является злым и должно быть сведено к минимуму (и когда оно используется, должно быть хорошо понято)?
Я вижу много использования терминов MVC и MVP без значительных доказательств того, что люди критически относятся к ним. Ясно, что проблема заключается в "их", мне или обоим...
Вы можете найти ответы на этот вопрос: "Внедрение MVC с помощью Windows Forms" полезно, поскольку они говорят о различных вариантах при реализации MVC и MVP.
В MVP представление рисует данные от ведущего, который рисует и подготавливает/нормализует данные из модели, а в MVC контроллер рисует данные из модели и задает, нажимая на представление.
В MVP у вас может быть один просмотр, работающий с несколькими типами презентаторов и один ведущий, работающий с разными несколькими видами.
MVP обычно использует какую-то структуру привязки, такую как инфраструктура привязки Microsoft WPF или различные рамки привязки для HTML5 и Java.
В этих рамках пользовательский интерфейс /HTML 5/XAML знает, какое свойство презентатора отображает каждый элемент пользовательского интерфейса, поэтому, когда вы привязываете представление к ведущему, представление ищет свойства и умеет рисовать данные из их и как их установить, когда пользовательское значение изменено в пользовательском интерфейсе.
Итак, если, например, модель представляет собой автомобиль, то ведущий - это своего рода ведущий автомобиль, выставляющий вид автомобиля (год, производитель, места и т.д.). Представление знает, что текстовое поле, называемое "автопроизводителем", должно отображать свойство создателя презентатора.
Затем вы можете привязать к виду много разных типов презентаторов, все должны иметь свойство Maker - это может быть самолет, поезд или что-то еще, представление не заботится. Представление выводит данные от ведущего - независимо от того, какой - пока он реализует согласованный интерфейс.
Эта структура привязки, если вы ее разделите, это на самом деле контроллер:-)
Итак, вы можете посмотреть MVP как эволюцию MVC.
MVC замечательный, но проблема в том, что обычно его контроллер на просмотр. Контроллер A знает, как установить поля View A. Если теперь вы хотите, чтобы View A отображал данные модели B, вам нужен контроллер A, чтобы знать модель B, или вам нужен контроллер A для получения объекта с интерфейсом - это похоже на MVP только без привязок, или вам нужно переписать код UI в контроллере B.
Заключение. MVP и MVC являются как развязкой шаблонов пользовательского интерфейса, но MVP обычно использует структуру привязок, которая находится под MVC. THUS MVP находится на более высоком архитектурном уровне, чем MVC, и шаблон оболочки выше MVC.
Мой скромный короткий взгляд: MVP предназначен для больших масштабов, а MVC - для небольших масштабов. С MVC я когда-то ощущаю, что V и C могут видеть две стороны одного неделимого компонента, скорее привязанного к M, и неизбежно падает на это, когда он идет вниз - в более короткие масштабы, такие как элементы управления пользовательского интерфейса и базовые виджеты. На этом уровне детализации MVP имеет мало смысла. Когда кто-то, наоборот, переходит в более крупные масштабы, правильный интерфейс становится более важным, то же самое с однозначным распределением обязанностей, и здесь идет MVP.
С другой стороны, это правило масштаба большого пальца может очень мало весить, когда характеристики платформы благоприятствуют каким-то отношениям между компонентами, например, с сетью, где, по-видимому, проще реализовать MVC, больше, чем MVP.
Существует много версий MVC, этот ответ касается исходного MVC в Smalltalk. Вкратце, это
Этот разговор droidcon NYC 2017 - Чистый дизайн приложения с компонентами архитектуры разъясняет его
Есть это хорошее видео от дяди Боба, где он кратко объясняет MVC и MVP в конце.
IMO, MVP - это улучшенная версия MVC, где вы в основном отделяете заботу о том, что вы собираетесь показывать (данные), от того, как вы собираетесь показывать (представление). Presenter включает в себя своего рода бизнес-логику вашего пользовательского интерфейса, неявно навязывает, какие данные должны быть представлены, и предоставляет вам список глупых моделей представления. И когда приходит время показывать данные, вы просто подключаете свое представление (возможно, с теми же идентификаторами) к своему адаптеру и устанавливаете соответствующие поля представления, используя те модели представления с минимальным количеством вводимого кода (просто используя установщики). Основное преимущество заключается в том, что вы можете проверить свою бизнес-логику пользовательского интерфейса на множестве различных представлений, таких как отображение элементов в горизонтальном или вертикальном списке.
В MVC мы говорим через интерфейсы (границы), чтобы склеить разные слои. Контроллер - это плагин для нашей архитектуры, но он не имеет такого ограничения, чтобы навязывать то, что показывать. В этом смысле MVP является своего рода MVC с концепцией представлений, подключаемых к контроллеру через адаптеры.
Надеюсь, это поможет лучше.
Самый простой ответ - как представление взаимодействует с моделью. В MVP представление связано с презентатором, который действует как посредник между представлением и моделью, принимая входные данные из представления, получая данные из модели, затем выполняя бизнес-логику и, наконец, обновляя представление. В MVC модель обновляет представление напрямую, а не обратно через контроллер.
Я думаю, что это изображение Эрвина Вандервалька (и сопровождающая статья) является лучшим объяснением MVC, MVP и MVVM, их сходства и различий. Статья не отображается в результатах поиска по запросам "MVC, MVP и MVVM", поскольку в заголовке статьи нет слов "MVC" и "MVP"; но это лучшее объяснение, я думаю.
(Эта статья также соответствует тому, что дядя Боб Мартин сказал в одном из своих выступлений: что MVC изначально был разработан для небольших компонентов пользовательского интерфейса, а не для архитектуры системы)
Шаблон проектирования MVC, MVP и MVVM
https://medium.com/@ankit.sinhal/mvc-mvp-and-mvvm-design-pattern-6e169567bbad
MVP
MVP означает Model - View - Presenter. Это появилось в начале 2007 года, когда Microsoft представила приложения Windows Smart Client.
Ведущий выступает в качестве контрольной роли в MVP, который связывает просмотр событий и бизнес-логик с моделями.
Связывание событий будет реализовано в Presenter из интерфейса представления.
View является инициатором для пользовательских входов, а затем делегирует события в Presenter и ведущий обрабатывает привязки событий и получает данные из моделей.
Плюсы: В представлении есть только UI, а не какие-либо логики Высокий уровень тестируемости
Минусы: Бит сложный и более эффективный при реализации привязок событий
MVC
MVC означает Model-View-Controller. Контроллер отвечает за создание моделей и просмотр представлений с помощью моделей привязки.
Контроллер является инициатором, и он решает, какой вид визуализации.
Плюсы:Акцент на принципе единой ответственности Высокий уровень тестируемости
Минусы:Иногда слишком большая рабочая нагрузка для контроллеров, если пытаться отображать несколько просмотров в одном контроллере.
Здесь размещено выше сумма ошибок человека и неспособность понять простейшее рукопожатие между двумя машинами. Я объясню, используя здравый смысл, чтобы попытаться разбудить вас всех от этого бредового идеализма, который проник в умы тех, кто хочет их создать. И как бы глупо ни звучали все эти процессы, на самом деле клиентская машина запрашивает объектную модель (то есть файл HTML). Вот как все сводится.
Возможно, я сейчас на пенсии, но, черт возьми, вы, ребята, здесь спорите и обсуждаете полную чушь. И, честно говоря, независимо от того, что вы называете Рукопожатием между двумя машинами, не может быть ничего кроме одного Запроса, одного Ответа Объекта "Модель" и, наконец, Обозревателя клиентов, отображающего "Представление".
И в заключение, представление не существует в рукопожатии. Объектная модель - это только разметка, которую браузер может преобразовать в наборы виджетов GUI и методы Eval с помощью трех или более объектных моделей. HTML, CSS и JavaScript. И независимо от того, сколько кто-нибудь может сказать, что Сервер делает что-то необычное, это Конский Навоз.
"Сервер" не является "Контроллером", он является "Направителем" и направляет Ответ только путем отправки ответа "Модель" объекта. Клиентский браузер (который может быть вероятным контроллером) затем создает "представление" из объектной "модели", к которой сервер не имеет никакого отношения. Ваш компьютерный язык не может ни войти в объект модели, ни делегировать его. Все это - Создатель Разметки.
Весь этот беспорядок - это просто "Контроллер" на стороне клиента, который анализирует "Модель", чтобы отобразить "Вид" или CMV или MCV (отправленный как Модель в первом порядке), и вы не можете его изменить. Но это можно назвать просто запросом, объектной моделью ответа и представлением рендеринга или RRMV.
Многие люди не знают точно, в чем разница между контроллером и презентатором в MVC и MVP соответственно.
его простое уравнение, где
MVC View = просмотр и презентатор MVP
Модель MVP = контроллер и модель MVC
Дополнительная информация относится к этому http://includeblogh.blogspot.com.eg/2016/07/the-difference-and-relationship-between.html