ASP.NET 设计模式 MVP

前言

ASP.NET webform 使用后置代码页面隔离业务逻辑。但使用ASP.NET webform 做应用开发会存在以下不足：

1. 后置代码页中混合了表现层、业务逻辑层、数据访问层的代码。出现这种情况的原因是后置代码负责事件触发，流程控制，业务规则和表现逻辑，业务逻辑和数据访问的协调者等多种角色。
2. 后置代码页测试不方便。

Model-View-Presenter模式

Model-View-Presenter（模型-视图-呈现器，MVP）模式的重点是让呈现器控制整个表示层的逻辑流。从层次上来讲，MVP属于表现层的设计模式。MVP模式由如下三个不同的部分组成：

1. Model：view展示或修改的业务数据。Model是对应用状态和业务功能的封装，可以看成是同时包含数据和行为的领域模型（Domain Model）
2. View：实现可视化界面的呈现，将用户的输入委托给Presenter 。一般地，View会实现一个相应的接口。
3. Presenter：Model和View的枢纽

MVP具有很多变体，其中最为常用的一种变体为Passive View（被动视图）。Passive View，Model、View和Presenter之间的关系如下图所示

图片来源

View和Model之间不能直接交互，之间的交互是通过Presenter进行的

Presenter接受View的UI请求，Presenter与Model进行通信，检索View的业务数据，完成后，Presenter更新View

View直接依赖于Presenter，Presenter间接依赖View，Presenter直接依赖的是View实现的接口

Passive View模式的基本特征总结

以下引用自Artech的博文谈谈关于MVP模式中V-P交互问题

Passive View，顾名思义，View是被动的。那么主动是谁呢？答案是Presenter。对于Presenter的主动性，我个人是这么理解的：

• Presenter是整个MVP体系的控制中心，而不是单纯的处理View请求的人；
• View仅仅是用户交互请求的汇报者，对于响应用户交互相关的逻辑和流程，View不参与决策，真正的决策者是Presenter；
• View向Presenter发送用户交互请求应该采用这样的口吻：“我现在将用户交互请求发送给你，你看着办，需要我的时候我会协助你”，不应该是这样：“我现在处理用户交互请求了，我知道该怎么办，但是我需要你的支持，因为实现业务逻辑的Model只信任你”；
• 对于绑定到View上的数据，不应该是View从Presenter上“拉”回来的，应该是Presenter主动“推”给View的；
• View尽可能不维护数据状态，因为其本身仅仅实现单纯的、独立的UI操作；Presenter才是整个体系的协调者，它根据处理用于交互的逻辑给View和Model安排工作。

实现一个完整的demo（代码有点多，后面给出源程序压缩包）

1、建立领域模型层

建立Model类库项目

Post类

[ActiveRecord("Posts")]
public class Post:ActiveRecordBase<Post>
{
    [PrimaryKey("PostId")]
    public int Id { get; set; }

    [Property]
    public string Subject { get; set; }

    [Property]
    public string Text { get; set; }

    [Property]
    public DateTime DateAdded { get; set; }

    [BelongsTo("CategoryId")]
    public Category Category { get; set; }

    [HasMany(Cascade = ManyRelationCascadeEnum.AllDeleteOrphan, Inverse = true)]
    public IList<Comment> Comments { get; set; }

}

Category类

[ActiveRecord("Categories")]
public class Category:ActiveRecordBase<Category>
{
    [PrimaryKey("CategoryId")]
    public int Id { get; set; }

    [Property(Column = "Category")]
    public string CategoryName { get; set; }

    [HasMany]
    public IList<Post> Posts { get; set; }
}

Comment类

[ActiveRecord("Comments")]
public class Comment : ActiveRecordBase<Comment>
{
    [PrimaryKey("CommentId")]
    public int Id { get; set; }

    [Property]
    public string Text { get; set; }

    [Property]
    public string Author { get; set; }

    [Property]
    public DateTime DateAdded { get; set; }

    [BelongsTo("PostId")]
    public Post Post { get; set; }

}

添加资源库的契约接口，该接口为业务实体持久化提供了标准方法

IRepository接口

public interface IRepository<T> where T:class
{
    T Find(int id);
    void Add(T entity);
    void Save(T entity);
    void Remove(T entity);
}

ICategoryRepository接口

public interface ICategoryRepository : IRepository<Category>
{
    IEnumerable<Category> FindAll();
}

IPostRepository接口

public interface IPostRepository:IRepository<Post>
{
    IEnumerable<Post> FindAll();
    IEnumerable<Post> FindAll(int index, int count);
    int GetAllPostCount();
    //IEnumerable<Post> FindAll();
    //IEnumerable<Post> FindAll(int index, int count);
    //IEnumerable<Post> FindBy(Query query);
    //IEnumerable<Post> FindBy(Query query, int index, int count);
}

创建领域服务类PostService

public class PostService
{
    private ICategoryRepository _categoryRepository;
    private IPostRepository _postRepository;
    public PostService(ICategoryRepository categoryRepository,IPostRepository postRepository)
    {
        _categoryRepository = categoryRepository;
        _postRepository = postRepository;
    }
    public IList<Post> GetAllPostsIn(int categoryId)
    {
        return _categoryRepository.Find(categoryId).Posts;
    }
    public IList<Comment> GetPostAllComments(int postId)
    {
        return _postRepository.Find(postId).Comments;
    }

    public int GetAllPostCount()
    {

        return _postRepository.GetAllPostCount();
    }
}

2、建立资源库(repository)

/// <summary>
/// CategoryRepository
/// </summary>

public class CategoryRepository : ICategoryRepository
{
    public IEnumerable<Category> FindAll()
    {
        return Category.FindAll();
    }

    public Category Find(int id)
    {
        return Category.Find(id);
    }

    public void Add(Category entity)
    {
        entity.Create();
    }

    public void Save(Category entity)
    {
        entity.Save();
    }

    public void Remove(Category entity)
    {
        entity.Delete();
    }
}


/// <summary>
/// CommentRepository
/// </summary>
public class CommentRepository : ICommentRepository
{
    public Comment Find(int id)
    {
        return Comment.Find(id);
    }

    public void Add(Comment entity)
    {
        entity.Create();
    }

    public void Save(Comment entity)
    {
        entity.Save();
    }

    public void Remove(Comment entity)
    {
        entity.Delete();
    }
}


/// <summary>
/// PostRepository
/// </summary>
public class PostRepository : IPostRepository
{
    public IEnumerable<Post> FindAll()
    {
        return Post.FindAll();
    }

    public IEnumerable<Post> FindAll(int index, int count)
    {
        return Post.FindAll().Skip(index * count).Take(count);
    }

    public Post Find(int id)
    {
        return Post.Find(id);
    }

    public void Add(Post entity)
    {
        entity.Create();
    }

    public void Save(Post entity)
    {
        entity.Save();
    }

    public void Remove(Post entity)
    {
        entity.Delete();
    }

    public int GetAllPostCount()
    {
        ScalarQuery query = new ScalarQuery(typeof(Post), @"select count(post.Category) from Post post)");

        return int.Parse(Post.ExecuteQuery(query).ToString());
    }
}

建立service层

public class BlogService
{
    private IPostRepository _postRepository;
    private ICommentRepository _commentRepository;
    private ICategoryRepository _categoryRepository;
    private PostService _service;

    public BlogService(ICategoryRepository categoryRepository, IPostRepository postRepository, ICommentRepository commentRepository)
    {
        _service = new PostService(categoryRepository, postRepository);
        _categoryRepository = categoryRepository;
        _postRepository = postRepository;
        _commentRepository = commentRepository;
    }
    #region Post
        public IEnumerable<Post> FindAllPost()
        {
            return _postRepository.FindAll();
        }

        public IEnumerable<Post> FindAllPost(int index, int count)
        {
            return _postRepository.FindAll().Skip(index * count).Take(count);
        }

        public Post FindPostBy(int id)
        {
            return _postRepository.Find(id);
        }

        public void AddPost(Post entity)
        {
            _postRepository.Add(entity);
        }

        public void SavePost(Post entity)
        {
            _postRepository.Save(entity);
        }

        public void RemovePost(Post entity)
        {
            _postRepository.Remove(entity);
        }

        public int GetAllPostCount()
        {
            return _postRepository.GetAllPostCount();
        }

        public IList<Post> GetAllPostsIn(int categoryId)
        {
            return _service.GetAllPostsIn(categoryId);
        }

        #endregion

    #region Category

        public IEnumerable<Category> FindAllCategories()
        {
            return _categoryRepository.FindAll();
        }

        public Category FindCategoryBy(int id)
        {
            return _categoryRepository.Find(id);
        }

        public void AddCategory(Category entity)
        {
            _categoryRepository.Add(entity);
        }

        public void SaveCategory(Category entity)
        {
            _categoryRepository.Save(entity);
        }

        public void RemoveCategory(Category entity)
        {
            _categoryRepository.Remove(entity);
        }

        #endregion

    #region Comment

        public Comment FindComment(int id)
        {
            return _commentRepository.Find(id);
        }

        public void AddComment(Comment entity)
        {
            _commentRepository.Add(entity);
        }

        public void SaveComment(Comment entity)
        {
            _commentRepository.Save(entity);
        }

        public void RemoveComment(Comment entity)
        {
            _commentRepository.Remove(entity);
        }

        #endregion
}

创建Presenter层

添加IHomeView、IPostDetailView、ICategoryPostView接口（View接口解耦了Presenter与View之间的依赖）

/// <summary>
/// IHomeView
/// </summary>
public interface IHomeView
{
    IEnumerable<Category> CategoryList { set; }

    IEnumerable<Post> Post { set; }

    int PostCount { set; }
}

/// <summary>
/// IPostDetailView
/// </summary>
public interface IPostDetailView
{
    IEnumerable<Category> CategoryList { set; }
    Post Post { set; }
    IList<Comment> Comments { set; }
    event EventHandler<CommentEventArgs> NewComment;
}


/// <summary>
/// ICategoryPostView
/// </summary>
public interface ICategoryPostView
{
    IEnumerable<Category> CategoryList { set; }

    IEnumerable<Post> Post { set; }
}

添加相应的呈现器HomePresenter、PostDetailPresenter、CategoryPostPresenter

/// <summary>
/// HomePresenter
/// </summary>
public class HomePresenter:IPresenter
{
    private IHomeView _homeView;
    private BlogService _service;
    public HomePresenter(IHomeView homeView,BlogService service)
    {
        _homeView = homeView;
        _service = service;
    }
    public void Display()
    {
        _homeView.CategoryList = _service.FindAllCategories();
        _homeView.Post = _service.FindAllPost(0, 10);
        _homeView.PostCount = _service.GetAllPostCount();
    }
}


/// <summary>
/// PostDetailPresenter
/// </summary>
public class PostDetailPresenter : IPresenter
{
    private IPostDetailView _postDetailView;
    private BlogService _service;
    private int _postId;
    public PostDetailPresenter(IPostDetailView postDetailView, BlogService service, int postId)
    {
        _postDetailView = postDetailView;
        _service = service;
        _postId = postId;
        _postDetailView.NewComment += new EventHandler<Event.CommentEventArgs>(_postDetailView_NewComment);
    }

    void _postDetailView_NewComment(object sender, Event.CommentEventArgs e)
    {
        Comment comment=new Comment ();
        comment.Author=e.CommentAuthor;
        comment.Text=e.CommentText;
        comment.DateAdded = DateTime.Now;
        comment.Post = _service.FindPostBy(_postId);
        _service.AddComment(comment);
    }
    public void Display()
    {
        _postDetailView.CategoryList = _service.FindAllCategories();
        _postDetailView.Post = _service.FindPostBy(_postId);
        _postDetailView.Comments = _service.FindPostBy(_postId).Comments;
    }
}


/// <summary>
/// CategoryPostPresenter
/// </summary>
public class CategoryPostPresenter : IPresenter
{
    private ICategoryPostView _categoryPostView;
    private BlogService _service;
    private int _categoryId;
    public CategoryPostPresenter(ICategoryPostView categoryPostView, BlogService service, int categoryId)
    {
        _categoryPostView = categoryPostView;
        _service = service;
        _categoryId = categoryId;
    }
    public void Display()
    {
        _categoryPostView.CategoryList = _service.FindAllCategories();
        _categoryPostView.Post = _service.GetAllPostsIn(_categoryId);
    }
}

三个呈现器实现共同的呈现接口IPresenter

public interface IPresenter
{
    void Display();
}

创建web应用程序 作为view

index.aspx.cs

public partial class Index : System.Web.UI.Page, IHomeView
{
    IPresenter _presenter;
    int _pageCount;
    protected override void OnPreInit(EventArgs e)
    {

        _presenter = new HomePresenter(this, ObjectFactory.GetInstance<BlogService>());
        base.OnPreInit(e);
    }
    protected void Page_Load(object sender, EventArgs e)
    {
        _presenter.Display();
    }

    public IEnumerable<Model.Category> CategoryList
    {
        set
        {

            rptCategory.DataSource = value;
            rptCategory.DataBind();
        }
    }

    public IEnumerable<Model.Post> Post
    {
        set
        {
            rptPostList.DataSource = value;
            rptPostList.DataBind();
        }
    }

    public int PostCount
    {
        set { _pageCount = value; }
    }
}

CategoryPost.aspx.cs

public partial class CategoryPost : System.Web.UI.Page, ICategoryPostView
{
    IPresenter _presenter;
    protected override void OnPreInit(EventArgs e)
    {
        int categoryId;
        int.TryParse(Request.QueryString["categoryid"], out categoryId);

        _presenter = new CategoryPostPresenter(this, ObjectFactory.GetInstance<BlogService>(), categoryId);
        base.OnPreInit(e);
    }
    protected void Page_Load(object sender, EventArgs e)
    {
        _presenter.Display();
    }

    public IEnumerable<Model.Category> CategoryList
    {
        set
        {
            rptCategory.DataSource = value;
            rptCategory.DataBind();
        }
    }

    public IEnumerable<Model.Post> Post
    {
        set
        {
            rptPostList.DataSource = value;
            rptPostList.DataBind();
        }
    }
}

PostDetail.aspx.cs

public partial class PostDetail : System.Web.UI.Page,IPostDetailView
{
    IPresenter _presenter;
    public event EventHandler<CommentEventArgs> NewComment;
    protected virtual void OnNewComment(CommentEventArgs e)
    {
        if (NewComment != null)
        {
            NewComment(this, e);
        }
    }

    protected override void OnPreInit(EventArgs e)
    {
        int postId;
        int.TryParse(Request.QueryString["postId"], out postId);

        _presenter = new PostDetailPresenter(this, ObjectFactory.GetInstance<BlogService>(), postId);
        base.OnPreInit(e);
    }
    protected void Page_Load(object sender, EventArgs e)
    {
        _presenter.Display();
    }

    public IEnumerable<Model.Category> CategoryList
    {
        set
        {
            rptCategory.DataSource = value;
            rptCategory.DataBind();
        }
    }

    public Model.Post Post
    {
        set {
            lbltitle.Text = value.Subject;
            lblDateAdded.Text = value.DateAdded.ToShortDateString();
            litContent.Text = value.Text;
        }
    }

    public IList<Model.Comment> Comments
    {
        set
        {
            rptCommentList.DataSource = value;
            rptCommentList.DataBind();
        }
    }

    protected void btnCommit_Click(object sender, EventArgs e)
    {
        int postId;
        int.TryParse(Request.QueryString["postid"], out postId);

        CommentEventArgs eventArgs = new CommentEventArgs(txtText.Text, txtAuthor.Text,postId);
        OnNewComment(eventArgs);
    }
}

MVP模式中的顺序图

下载地址：源代码下载

参考资料：谈谈关于MVP模式中V-P交互问题

　　　　　Professional ASP.NET Design Patterns

　　　　　在ASP.NET中实现Model-View-Presenter(MVP)

　　　　　使用ASP.NET实现Model View Presenter(MVP)