我应该在这里使用视图模型吗？

Question

假设我有两个模型： 事物和状态。 Thingy 有一个 Status，而 Status 有很多 Thingie。这是典型的“对象和对象类型关系”。

我有一个观点，我只想要每种状态下的事物数量。或者基本上是 Status.Name 和 Status.Thingies.Count 的列表。我完全可以做到这一点，但是以以下形式创建视图模型是“正确”：

ThingiesByStatusViewModel
-StatusName
-StatusThingiesCount

并将其与 AutoMapper 之类的东西挂钩。

对于这样一个简单的例子，它可能没有多大区别，但它会帮助我更好地理解正确的“关注点分离”。

Answer 1

我应该在这里使用视图模型吗？

这是一个反问句吗？

您的视图模型看起来与您建议的完全一样，并且完全适合您尝试在此处显示的内容：

public class ThingiesByStatusViewModel
{
    public string StatusName { get; set; }
    public int StatusThingiesCount { get; set; }
}

然后您的控制器将返回 IEnumerable。然后，在您的视图中，您可以简单地使用显示模板：

@Html.DisplayForModel()

和相应的显示模板 (~/Views/Shared/DisplayTemplates/ThingiesByStatusViewModel.cshtml)：

@model AppName.Models.ThingiesByStatusViewModel
<div>
    <span>StatusName: @Model.StatusName</span>
    <span>Number of thingies: @Model.StatusThingiesCount</span>
</div>

现在让我们看看映射层。假设我们有以下域：

public class Thingy
{ }

public class Status
{
    public string StatusName { get; set; }
    public IEnumerable<Thingy> Thingies { get; set; }
}

并且有一个 IEnumerable 实例。

映射定义可能如下所示：

Mapper
    .CreateMap<Status, ThingiesByStatusViewModel>()
    .ForMember(
        dest => dest.StatusThingiesCount,
        opt => opt.MapFrom(src => src.Thingies.Count())
    );

最后控制器操作将是：

public ActionResult Foo()
{
    IEnumerable<Status> statuses = _repository.GetStatuses();
    IEnumerable<ThingiesByStatusViewModel> statusesVM = Mapper.Map<IEnumerable<Status>, IEnumerable<ThingiesByStatusViewModel>>(statuses);
    return View(statusesVM);
}

Answer 2

我个人不喜欢将不平凡的类型发送到视图，因为这样设计视图的人可能会觉得有义务开始将业务逻辑填充到视图中，这是个坏消息。

在您的场景中，我会将 StatusName 属性添加到您的视图模型中并享受成功。

Answer 3

是的，你应该使用VM。

我猜，你有时间做一些实验，所以尽量用正确的方式来做。下次，你会做得更快。

如果当前的示例很简单 - 那么练习会更容易。

另外，将来你的应用程序将会增长，你永远不知道什么时候需要扩展它。因此，以正确的方式实施它可以为您提供良好的未来可维护性。

Answer 4

答案是肯定的。当然。为什么不呢？它只会涉及大约 1% 的代码！

想一想：

1. ViewModel 的用途是作为将数据发送到视图的容器。

2. 因此，它可以“塑造”发送到视图的数据，这些数据可能与您的域模型不对应。例如，如果 Thingies 有 50 个属性（或表中的列...），您可能只需要其中的 3 个属性。

3. 为了提供这种形状的数据，我使用了“Service”类。 EG、StatusService（通过接口绑定以允许 DI，例如 IStatusService）。因此，Service 类获取存储库的实例，提供在控制器中使用的方法以及构建 ViewModel 来打包视图数据的特殊只读属性。

使用这种做事方式，您可以很容易地看到编写 ViewModel 所付出的努力是很危险的。就代码行数而言，大概是 1%。

想要证据吗？

看一下下面的内容：

典型的控制器如下：

控制器：

//注意使用：service.ViewModel

namespace ES.eLearningFE.Areas.Admin.Controllers
{
    public partial class StepEditorController : Controller
    {
        IStepEditorService service;
        public StepEditorController(IStepEditorService service)
        {
            this.service = service;
        }

        [HttpGet]
        public virtual ActionResult List(int IdCourse)
        {
            service.CourseId = IdCourse;
            return View(service.Steps());
        }

        [HttpGet]
        public virtual ActionResult Edit(int IdCourse, int IdStep)
        {
            service.CourseId = IdCourse;
            service.CurrentStepId = IdStep;
            return View(service.ViewModel);
        }

        [HttpPost]
        public virtual ActionResult Edit(CourseStep step)
        {
            service.CourseId = step.CourseId;
            service.CurrentStepId = step.CourseStepId; 
            service.CourseId = step.CourseId;
            try
            {
                UpdateModel(service.CurrentStep);
                service.Save();
                return RedirectToAction(Actions.Edit(step.CourseId, step.CourseStepId));
            }
            catch
            {
                // Refactor notice : empty catch block : Return errors!
            }
            return View(service.ViewModel);
        }

        [HttpGet]
        public virtual ActionResult New(int IdCourse)
        {
            service.CourseId = IdCourse;
            return View(service.ViewModel);
        }
        [HttpPost]
        public virtual ActionResult New(CourseStep step)
        {
            service.CourseId = step.CourseId;            
            if (ModelState.IsValid)
            {
                service.AddStep(step);
                try
                {
                    service.Save();
                    service.CurrentStepId = step.CourseStepId;
                    return View(Views.Edit, service.ViewModel);
                }
                catch
                {
                    // Refactor notice : empty catch block : Return errors!
                }
            }
            return View(service.ViewModel);
        }
    }
}

服务：

服务类如下所示：

//注意以下属性： public StepEditorVM ViewModel

namespace ES.eLearning.Domain.Services.Admin
{
    public class SqlStepEditorService : IStepEditorService
    {
        DataContext db;

        public SqlStepEditorService(DbDataContextFactory contextFactory)
        {
            db = contextFactory.Make();
            CoursesRepository = new SqlRepository<Course>(db);
            StepsRepository = new SqlRepository<CourseStep>(db);
        }

        #region IStepEditorService Members

        public StepEditorVM ViewModel
        {
            get
            {
                if (CurrentStep != null)
                {
                    return new StepEditorVM
                    {
                        CurrentStep = this.CurrentStep,
                        Steps = this.Steps()
                    };
                }
                else // New Step
                {
                    return new StepEditorVM
                    {
                        CurrentStep = new CourseStep(),
                        Steps = this.Steps()
                    };
                }
            }
        }

        public CourseStep CurrentStep
        {
            get
            {
                return FindStep(CurrentStepId, CourseId);
            }
        }

        // Refactor notice : Expose Steps with a CourseId parameter, instead of reading from the CourseId property?
        public List<CourseStep> Steps()
        {
            if (CourseId == null) throw new ApplicationException("Cannot get Steps [CourseId == null]");
            return (from cs in StepsRepository.Query where cs.CourseId == CourseId select cs).ToList();
        }

        // Refactor notice :  Pattern for dealing with null input parameters
        public int ? CourseId { get; set; }
        public int ? CurrentStepId { get; set; }

        public CourseStep FindStep(int ? StepId, int ? CourseId)
        {
            // Refactor notice :  Pattern for dealing with null input parameters
            if (CourseId == null) throw new ApplicationException("Cannot Find Step [CourseId == null]");
            if (CurrentStepId == null) throw new ApplicationException("Cannot Find Step [StepId == null]");
            try
            {
                return (from cs in StepsRepository.Query where ((cs.CourseStepId == StepId) && (cs.CourseId == CourseId)) select cs).First();
            }
            catch
            {
                return null;
            }
        }

        public void AddStep(CourseStep step)
        {
            StepsRepository.Add(step);
        }

        public void DeleteStep(CourseStep step)
        {
            StepsRepository.Delete(step);
        }

        public void Clear()
        {
            CurrentStepId = null;
            CourseId = null;
        }

        public void Save()
        {
            db.SubmitChanges();
        }

        #endregion

        #region Repositories

        private IRepository<Course> CoursesRepository
        {
            get;
            set;
        }

        private IRepository<CourseStep> StepsRepository
        {
            get;
            set;
        }

        #endregion
    }
}

界面：

界面看起来像：

namespace ES.eLearning.Domain.Services.Interfaces
{
    public interface IStepEditorService
    {
        StepEditorVM ViewModel { get; }

        CourseStep CurrentStep { get; }
        List<CourseStep> Steps();
        int ? CourseId { get; set; }
        int ? CurrentStepId { get; set; }
        CourseStep FindStep(int ? StepId, int ? CourseId);
        void AddStep(CourseStep step);
        void DeleteStep(CourseStep step);
        void Clear();
        void Save();
    }
}

ViewModel 类：

最后，ViewModel 类本身：

namespace ES.eLearning.Domain.ViewModels
{
    public class StepEditorVM
    {
        public CourseStep CurrentStep { get; set; }
        public List<CourseStep> Steps { get; set; }
    }
}

与其他所有类相比，它什么都不是。

那么为什么不这样做呢？

其他部分：

通用存储库：

namespace ES.eLearning.Domain
{
    public class SqlRepository<T> : IRepository<T> where T : class
    {
        DataContext db;
        public SqlRepository(DataContext db)
        {
            this.db = db;
        }

        #region IRepository<T> Members

        public IQueryable<T> Query
        {
            get { return db.GetTable<T>(); }
        }

        public List<T> FetchAll()
        {
            return Query.ToList();
        }

        public void Add(T entity)
        {
            db.GetTable<T>().InsertOnSubmit(entity);
        }

        public void Delete(T entity)
        {
            db.GetTable<T>().DeleteOnSubmit(entity);
        }

        public void Save()
        {
            db.SubmitChanges();
        }

        #endregion
    }
}

IRepository：

namespace Wingspan.Web.Mvc
{
    public interface IRepository<TEntity> where TEntity : class
    {
        List<TEntity> FetchAll();
        IQueryable<TEntity> Query {get;}
        void Add(TEntity entity);
        void Delete(TEntity entity);
        void Save();
    }
}

注意：这是我现在正在做的事情，所以这是一项正在进行的工作，比最终的事情要简单得多，但这肯定是第一次和第二次迭代，它让您了解了您的工作的结构。

当客户想要在视图等中添加新功能时，额外的复杂性就会逐渐增加。但即便如此，这是一个您可以轻松构建并测试更改的框架。

在我看来，这样做的原因很大程度上是为了提供一种编写代码的结构化方式。在创建相应的视图之前，您可以在一个早上将整个事情写下来。

也就是说，一切都进行得非常快，并且您确切地知道自己要做什么。

完成此操作后，您可以创建视图并看看会发生什么...

开玩笑吧，美妙之处在于，当您到达视图时，您知道自己在做什么，知道您的数据、它的形状以及视图设计就是流动的。然后，您添加视图所需的额外内容，嘿，很快，工作就完成了。

当然，另一个原因是测试。但即使在这里，您也可以从高度结构化的方法中受益：您的测试也将遵循非常独特的模式。很容易写。

要点：

上面的要点是强调与总体工作相比，编写 ViewModel 所花费的精力是多么少。