视图模型通常是两个或多个模型的聚合/组合。

假设我们有一个DB，它有两个表，分别叫Student和Course，每个表有两个模型。在客户端，我们有两个视图来呈现每个表。

想象一下，您需要另一个同时呈现学生和课程的视图?然后你可以创建一个所谓的视图模型。这基本上是一个采用两种模型的类，即学生和课程。

类combinedstudentcourses将是视图模型，并可以由视图返回。

public class Student
{
    public string? Name{ get; set; }
    public string? Email{ get; set; }        
}

这是我们的视图模型，其中有两个模型。

public class Course
{
    public string? CourseName { get; set; }
    public string? CourseCode { get; set; }        
}

ViewModel，即组合两个或多个模型来满足视图的特定需求。

public class SchoolSystem
{
    public Students Student { get; set; }
    public Courses Course { get; set; }        
}
 public ActionResult<SchoolSystem> Index()
    {
      var SchoolSystemViewModel = new SchoolSystem();
        // now we have access two to tables i.e two models in our 
        //view.
      return this.View("SchoolSystemView", SchoolSystemViewModel,);
    }

很多大的例子，让我用一种清晰明了的方式解释。

ViewModel =为视图创建的模型。

ASP。NET MVC视图不能有多个模型，所以如果我们需要在视图中显示来自多个模型的属性，这是不可能的。ViewModel就是这个目的。

视图模型是一个模型类，它只能保存视图所需的那些属性。它还可以包含来自数据库的多个实体(表)的属性。顾名思义，这个模型是专门为View需求创建的。

下面是一些视图模型的例子

要在视图页中列出来自多个实体的数据，可以创建一个 查看模型，并拥有我们想要的所有实体的属性 列出数据。连接这些数据库实体并设置View模型 属性，并返回到视图以显示不同的数据 一个表格形式的实体 视图模型可能只定义单个实体的特定字段 视图所需。

ViewModel还可以用于将记录插入和更新到多个实体中，但ViewModel的主要用途是将多个实体(模型)中的列显示到单个视图中。

创建ViewModel的方法与创建Model的方法相同，为ViewModel创建视图的方法与为Model创建视图的方法相同。

下面是一个使用ViewModel的列表数据的小示例。

希望这对你有用。

视图模型是表示特定视图中使用的数据模型的类。我们可以使用这个类作为登录页面的模型:

public class LoginPageVM
{
    [Required(ErrorMessage = "Are you really trying to login without entering username?")]
    [DisplayName("Username/e-mail")]
    public string UserName { get; set; }
    [Required(ErrorMessage = "Please enter password:)")]
    [DisplayName("Password")]
    public string Password { get; set; }
    [DisplayName("Stay logged in when browser is closed")]
    public bool RememberMe { get; set; }
}

使用这个视图模型，你可以定义视图(Razor视图引擎):

@model CamelTrap.Models.ViewModels.LoginPageVM

@using (Html.BeginForm()) {
    @Html.EditorFor(m => m);
    <input type="submit" value="Save" class="submit" />
}

和行动:

[HttpGet]
public ActionResult LoginPage()
{
    return View();
}

[HttpPost]
public ActionResult LoginPage(LoginPageVM model)
{
    ...code to login user to application...
    return View(model);
}

产生这个结果(提交表单后，屏幕显示验证消息):

正如你所看到的，视图模型有很多角色:

视图模型通过只包含在视图中表示的字段来记录视图。 视图模型可能包含使用数据注释或IDataErrorInfo的特定验证规则。 视图模型定义了视图的外观(对于LabelFor,EditorFor,DisplayFor helper)。 视图模型可以组合来自不同数据库实体的值。 你可以很容易地为视图模型指定显示模板，并使用DisplayFor或EditorFor helper在许多地方重用它们。

视图模型及其检索的另一个示例:我们希望显示基本用户数据、他的权限和用户名。我们创建一个特殊的视图模型，它只包含必需的字段。我们从数据库的不同实体中检索数据，但是视图只知道视图模型类:

public class UserVM {
    public int ID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public bool IsAdministrator { get; set; }
    public string MothersName { get; set; }
}

检索:

var user = db.userRepository.GetUser(id);

var model = new UserVM() {
   ID = user.ID,
   FirstName = user.FirstName,
   LastName = user.LastName,
   IsAdministrator = user.Proviledges.IsAdministrator,
   MothersName = user.Mother.FirstName + " " + user.Mother.LastName
} 

ViewModel包含在视图中表示的字段(用于 LabelFor、EditorFor DisplayFor助手) ViewModel可以使用数据注释拥有特定的验证规则 或IDataErrorInfo。 ViewModel可以有来自不同数据的多个实体或对象 模型或数据源。

设计视图模型

public class UserLoginViewModel 
{ 
    [Required(ErrorMessage = "Please enter your username")] 
    [Display(Name = "User Name")]
    [MaxLength(50)]
    public string UserName { get; set; }

    [Required(ErrorMessage = "Please enter your password")]
    [Display(Name = "Password")]
    [MaxLength(50)]
    public string Password { get; set; } 
} 

在视图中显示视图模型

@model MyModels.UserLoginViewModel 
@{
    ViewBag.Title = "User Login";
    Layout = "~/Views/Shared/_Layout.cshtml";
}
@using (Html.BeginForm())
{
    <div class="editor-label">
        @Html.LabelFor(m => m.UserName)
    </div>
    <div class="editor-field">
        @Html.TextBoxFor(m => m.UserName)
        @Html.ValidationMessageFor(m => m.UserName)
    </div>
    <div class="editor-label">
        @Html.LabelFor(m => m.Password)
    </div>
    <div class="editor-field">
        @Html.PasswordFor(m => m.Password)
        @Html.ValidationMessageFor(m => m.Password)
    </div>
    <p>
        <input type="submit" value="Log In" />
    </p>
}

行动起来

public ActionResult Login()
{ 
    return View();
}

[HttpPost]
public ActionResult Login(UserLoginViewModel user)
{
    // To access data using LINQ
    DataClassesDataContext mobjentity = new DataClassesDataContext();

    if (ModelState.IsValid) 
    { 
        try
        {
            var q = mobjentity.tblUsers.Where(m => m.UserName == user.UserName && m.Password == user.Password).ToList();  

            if (q.Count > 0) 
            { 
                 return RedirectToAction("MyAccount");
            }
            else
            {
                ModelState.AddModelError("", "The user name or password provided is incorrect.");
            }
        }
        catch (Exception ex)
        {
        } 
    } 
    return View(user);
} 

在ViewModel中只放置那些你想要显示的字段/数据 视图/页。 由于view表示ViewModel的属性，因此它是 易于渲染和维护。 当ViewModel变得更加复杂时，使用mapper。

视图模型是数据的概念模型。例如，它的用途是获取一个子集或组合来自不同表的数据。

您可能只需要特定的属性，因此这允许您只加载那些属性，而不添加不必要的属性。

编辑:我在我的博客上更新了这个答案:

http://www.samwheat.com/post/The-function-of-ViewModels-in-MVC-web-development

我的回答有点长，但我认为将视图模型与其他类型的常用模型进行比较是很重要的，这样可以理解为什么它们不同，为什么它们是必要的。

总结一下，直接回答问题:

Generally speaking, a view model is an object that contains all the properties and methods necessary to render a view. View model properties are often related to data objects such as customers and orders and in addition, they also contain properties related to the page or application itself such as user name, application name, etc. View models provide a convenient object to pass to a rendering engine to create an HTML page. One of many reasons to use a view model is that view models provide a way to unit test certain presentation tasks such as handling user input, validating data, retrieving data for display, etc.

下面是实体模型的比较。dto方。模型)、表示模型和视图模型。

数据传输对象，又称“模型”

数据传输对象(DTO)是具有与数据库中的表模式匹配的属性的类。dto的命名源于它们在数据存储间来回传输数据的常用用法。 dto的特点:

业务对象-它们的定义依赖于应用程序数据。 通常只包含属性-没有代码。 主要用于向数据库传输数据和从数据库传输数据。 属性与数据存储中特定表上的字段完全匹配或紧密匹配。

数据库表通常是规范化的，因此dto通常也是规范化的。这使得它们在显示数据时用处有限。然而，对于某些简单的数据结构，它们通常表现得很好。

下面是dto的两个示例:

public class Customer
{
    public int ID { get; set; }
    public string CustomerName { get; set; }
}


public class Order
{
    public int ID { get; set; }
    public int CustomerID { get; set; }
    public DateTime OrderDate { get; set; }
    public Decimal OrderAmount { get; set; }
}

 

演示模型

表示模型是用于在屏幕或报表上呈现数据的实用程序类。表示模型通常用于对由来自多个dto的数据组成的复杂数据结构进行建模。表示模型通常表示非规范化的数据视图。

表示模型的特点:

Are business objects – their definition is dependent on application data. Contain mostly properties. Code is typically limited to formatting data or converting it to or from a DTO. Presentation Models should not contain business logic. Often present a denormalized view of data. That is, they often combine properties from multiple DTOs. Often contain properties of a different base type than a DTO. For example, dollar amounts may be represented as strings so they can contain commas and a currency symbol. Often defined by how they are used as well as their object characteristics. In other words, a simple DTO that is used as the backing model for rendering a grid is in fact also a presentation model in the context of that grid.

表示模型是“根据需要”和“在需要的地方”使用的(而dto通常绑定到数据库模式)。表示模型可用于为整个页面、页面上的网格或页面上网格上的下拉列表建模。表示模型通常包含其他表示模型的属性。表示模型通常是为单一用途而构造的，例如在单个页面上呈现特定的网格。

一个演示模型示例:

public class PresentationOrder
{
    public int OrderID { get; set; }
    public DateTime OrderDate { get; set; }
    public string PrettyDate { get { return OrderDate.ToShortDateString(); } }
    public string CustomerName { get; set; }
    public Decimal OrderAmount { get; set; }
    public string PrettyAmount { get { return string.Format("{0:C}", OrderAmount); } }
}

视图模型

视图模型与表示模型相似，都是用于呈现视图的支持类。然而，它在构造方式上与表示模型或DTO有很大不同。视图模型通常包含与表示模型和dto相同的属性，因此，它们经常被混淆。

视图模型的特点:

Are the single source of data used to render a page or screen. Usually, this means that a view model will expose every property that any control on the page will need to render itself correctly. Making the view model the single source of data for the view greatly improves its capability and value for unit testing. Are composite objects that contain properties that consist of application data as well as properties that are used by application code. This characteristic is crucial when designing the view model for reusability and is discussed in the examples below. Contain application code. View Models usually contain methods that are called during rendering and when the user is interacting with the page. This code typically relates to event handling, animation, visibility of controls, styling, etc. Contain code that calls business services for the purpose of retrieving data or sending it to a database server. This code is often mistakenly placed in a controller. Calling business services from a controller usually limits the usefulness of the view model for unit testing. To be clear, view models themselves should not contain business logic but should make calls to services which do contain business logic. Often contain properties that are other view models for other pages or screens. Are written “per page” or “per screen”. A unique View Model is typically written for every page or screen in an application. Usually derive from a base class since most pages and screens share common properties.

视图模型组合

如前所述，视图模型是复合对象，因为它们组合了单个对象上的应用程序属性和业务数据属性。视图模型中常用的应用程序属性示例如下:

用于显示应用程序状态的属性，如错误消息、用户名、状态等。 用于设置控件的格式、显示、样式化或动画化的属性。 用于数据绑定的属性，如列表对象和保存用户输入的中间数据的属性。

下面的例子说明了为什么视图模型的复合性质是重要的，以及我们如何才能最好地构建一个高效且可重用的视图模型。

假设我们正在编写一个web应用程序。应用程序设计的要求之一是必须在每个页面上显示页面标题、用户名和应用程序名。如果我们想要创建一个页面来显示表示订单对象，我们可以修改表示模型如下所示:

public class PresentationOrder
{
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }
    public int OrderID { get; set; }
    public DateTime OrderDate { get; set; }
    public string PrettyDate { get { return OrderDate.ToShortDateString(); } }
    public string CustomerName { get; set; }
    public Decimal OrderAmount { get; set; }
    public string PrettyAmount { get { return string.Format("{0:C}", OrderAmount); } }
}

这种设计可能可行，但如果我们想创建一个显示订单列表的页面呢?PageTitle、UserName和ApplicationName属性将会重复出现，并且变得难以处理。另外，如果我们想在类的构造函数中定义一些页级逻辑呢?如果我们为将要显示的每个订单创建一个实例，就不能再这样做了。

复合优于继承

下面是一种重构订单表示模型的方法，这样它就变成了一个真正的视图模型，对于显示单个PresentationOrder对象或PresentationOrder对象的集合非常有用:

public class PresentationOrderVM
{
    // Application properties
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }

    // Business properties
    public PresentationOrder Order { get; set; }
}


public class PresentationOrderVM
{
    // Application properties
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }

    // Business properties
    public List<PresentationOrder> Orders { get; set; }
}

查看上面的两个类，我们可以看到考虑视图模型的一种方式是，它是一个包含另一个表示模型作为属性的表示模型。顶层表示模型(即视图模型)包含与页面或应用程序相关的属性，而表示模型(属性)包含与应用程序数据相关的属性。

我们可以进一步设计并创建一个基视图模型类，它不仅可以用于PresentationOrders，还可以用于任何其他类:

public class BaseViewModel
{
    // Application properties
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }
}

现在我们可以像这样简化我们的PresentationOrderVM:

public class PresentationOrderVM : BaseViewModel
{
    // Business properties
    public PresentationOrder Order { get; set; }
}

public class PresentationOrderVM : BaseViewModel
{
    // Business properties
    public List<PresentationOrder> Orders { get; set; }
}

我们可以通过使BaseViewModel泛型来使它更具可重用性:

public class BaseViewModel<T>
{
    // Application properties
    public string PageTitle { get; set; }
    public string UserName { get; set; }
    public string ApplicationName { get; set; }

    // Business property
    public T BusinessObject { get; set; }
}

现在我们的实现很轻松:

public class PresentationOrderVM : BaseViewModel<PresentationOrder>
{
    // done!
}

public class PresentationOrderVM : BaseViewModel<List<PresentationOrder>>
{
    // done!
}