遵循视图模型模式的最佳实践

我现在正在学习 ASP.NET MVC 一段时间。我遵循在互联网或书籍中找到的一些指南，并且我想确保在我的开发中遵循有关视图模型模式的良好实践。下面是一个博客实现的简单示例。您能否确认我走的路是正确的？假设我想在视图上显示帖子标题+描述，并在该帖子的评论下方显示。所以我有一个观点，其中有两个部分观点。

在我的控制器中：

    public ActionResult DetailPost(int postID)
    {
        // retrieve infos
        Post postModel = repository.Posts.FirstOrDefault(p => p.PostID == postID);
        IEnumerable<Comments> commentsModel = postModel.Comments;

        // prepare view model
        DetailPostViewModel detailPostViewModel = new DetailPostViewModel
                                                        {
                                                            Post = postModel,
                                                            Comments = commentsModel,
                                                        };

        return View(detailPostViewModel);
    }

所以在这里，我准备了一个由两部分组成的视图模型：

• 帖子信息
• 评论的枚举。

视图模型将传递给视图以遵循视图模型模式。

在我的详细信息视图中：

@model WebUI.ViewModels.DetailPostViewModel

@{
    ViewBag.Title = "Detail";
}

<h2>Detail</h2>

@Html.Partial("_DetailPost", Model.Post)
@Html.Partial("_Comments",  Model.Comments)

所以在这里，我使用了 DetailPostViewModel。对于我的部分视图，我传递了必要的信息，这些信息是实体！？我不知道这是否是正确的方法，还是我也必须在这里传递专门的视图模型？

在我的 _DetailPost 视图中：

@model Domain.Entities.Post

@Html.DisplayForModel()
...

因此，在我的部分视图中，我使用实体作为模型。是好还是坏？

在我的 _Comments 视图中：

@model IEnumerable<Domain.Entities.Comment>

@foreach (var item in Model)
{
    @Html.DisplayFor(Model => item.Title)
    @Html.DisplayFor(Model => item.Username)
}

因此，在我的部分视图中，我使用实体作为模型。是好还是坏？

感谢您的意见/建议。

EDIT

我尝试在 Automapper 的帮助下实现我的视图模型模式，但我遇到了一些问题，如下所述。我理解将一个对象映射到另一个对象的原理。在基本情况下它效果很好。现在，让我们看看更复杂的情况：我有一篇由一些属性（id、标题等）组成的帖子，并且每个帖子可以附加一些评论（对象）并且每个评论只能附加一个用户（对象） 。我想获得一个包含我所有帖子的视图模型，对于每一篇帖子，获取所有评论，并为每条评论附加用户。

以下是域实体：

public class Post
{
    public int    PostID    { get; set; }
    public string Title     { get; set; }
    ...
    public virtual ICollection<Comment> Comments { get; set; }
}

public class Comment
{
    public int    CommentID   { get; set; }
    public string CommentText { get; set; }
    ...
    public virtual <User> User { get; set; }
}

public class User
{
    public int UserID      { get; set; }
    public string Username { get; set; }
    ...
}

以下是视图模型：

public class PostVM
{
    public int    PostID    { get; set; }
    public string Title     { get; set; }
    ...
    public virtual ICollection<CommentVM> CommentsVM { get; set; }
}

public class CommentVM
{
    public int    CommentID   { get; set; }
    public string CommentText { get; set; }
    ...
    public virtual <UserVM> UserVM { get; set; }
}

public class UserVM
{
    public int UserID      { get; set; }
    public string Username { get; set; }
    ...
}

这是我的控制器：

// I would like to list all posts in the DB.
public ViewResult Index()
{
    PostVM viewModel = new PostVM 
                           {
                               ...
                           }

    return View(viewModel);
}

如何将（实体）帖子对象列表映射到我的视图模型对象和所有子对象（评论、用户）？

Thanks!

你很接近，但对我来说这不是视图模型的正确用法。您有以下内容：

public class DetailPostViewModel
{
    public Post Post { get; set; }
    public IEnumerable<Comment> Comments { get; set; }
}

这是某种混合伪视图模型。真实的视图模型不应引用任何域模型。

更正确的例子如下：

public class DetailPostViewModel
{
    public PostViewModel Post { get; set; }
    public IEnumerable<CommentViewModel> Comments { get; set; }
}

当然，PostViewModel 和 CommentViewModel 是其各自领域实体的相应视图模型。

另外，我将使用显示模板来代替部分：

@model WebUI.ViewModels.DetailPostViewModel

@{
    ViewBag.Title = "Detail";
}

<h2>Detail</h2>

@Html.DisplayFor(x => x.Post)
@Html.DisplayFor(x => x.Comments)

然后您将拥有各自的显示模板（~/Views/Shared/DisplayTemplates/PostViewModel.cshtml):

@model WebUI.ViewModels.PostViewModel
... some properties of a post

and (~/Views/Shared/DisplayTemplates/CommentViewModel.cshtml):

@model WebUI.ViewModels.CommentViewModel
@Html.DisplayFor(x => x.Title)
@Html.DisplayFor(x => x.Username)

显然，由于 Comments 是一个枚举，因此将自动为集合中的每个元素呈现显示模板。这样您就不需要在视图中编写任何循环。

就控制器逻辑而言，我个人喜欢使用自动映射器 http://automapper.org/在域实体和视图模型之间进行映射。

所以它可能看起来像这样：

public ActionResult DetailPost(int postID)
{
    // retrieve infos
    var postModel = repository.Posts.FirstOrDefault(p => p.PostID == postID);

    var viewModel = new DetailPostViewModel
    {
        Post = Mapper.Map<Post, PostViewModel>(postModel),
        Comments = Mapper.Map<IEnumerable<Comment>, IEnumerable<CommentViewModel>>(postModel.Comments)
    };
    return View(viewModel);
}

或者甚至更好：

public class PostViewModel
{
    ... some properties of a Post
    public IEnumerable<CommentViewModel> Comments { get; set; }
}

进而：

public ActionResult DetailPost(int postID)
{
    // retrieve infos
    var postModel = repository.Posts.FirstOrDefault(p => p.PostID == postID);
    var viewModel = Mapper.Map<Post, PostViewModel>(postModel);
    return View(viewModel);
}

然后你的视图将被强类型化为 PostViewModel：

@model WebUI.ViewModels.PostViewModel

@{
    ViewBag.Title = "Detail";
}

<h2>Detail</h2>

... some properties of a post

@Html.DisplayFor(x => x.Comments)

根据评论部分的要求，域模型和视图模型之间的映射如下所示：

Mapper.CreateMap<User, UserVM>();
Mapper
    .CreateMap<Comment, CommentVM>()
    .ForMember(
        dest => dest.UserVM, 
        opt => opt.MapFrom(src => src.User)
    );
Mapper
    .CreateMap<Post, PostVM>()
    .ForMember(
        dest => dest.CommentsVM, 
        opt => opt.MapFrom(src => src.Comments)
);

备注：两个ForMemeber如果属性在视图模型中以相同的方式命名，则不需要调用：User and Comments。 AutoMapper 依赖于标准命名约定，您也可以编写自己的自定义约定策略以避免单独映射每个成员。那么您所需要的就是在定义视图模型时保持一致并遵循约定。

然后在控制器中：

IEnumerable<Post> posts = ...
IEnumerable<PostVm> postVms = Mapper.Map<IEnumerable<Post>, IEnumerable<PostVM>>(posts);
return View(postVms);