Is there a way to white list a subclass via the attribute?
public class VoteQuestionViewModel
{
[Display(Name = "Vote Question")]
public string Name { get; set; }
public VoteTypeViewModel VoteType { get; set; }
}
public class VoteTypeViewModel
{
public int Id { get; set; }
[Display(Name = "Type of Question")]
public string Type { get; set; }
[Display(Name = "Description")]
public string Description { get; set; }
}
The below will will only work to white list class property, but it will not work to whitelist child class property:
public async Task<IActionResult> Create([Bind("Name, VoteType.Description")] VoteQuestionViewModel voteQuestion)
The method you included in your question is the only way. Bind works on posted values. In other words, it's looking at the key names in the form data. In that respect, there is no VoteType key and never will be: only the properties on that class that were posted, i.e. VoteType.Description.
That said, not only is it extremely bad practice to use Bind at all, but using it in conjunction with view models makes absolutely no sense. The whole point of Bind is to allow you to include/exclude a subset of properties on an entity class. Likewise, the whole purpose of a view model is to deal with only the data that the view needs to work with. Therefore, if you don't want a property to be included in the post, don't put it on the view model. Even then, view models come with the extra caveat that data has to be mapped to/from the entity class onto to them. That gives you the ability to explicitly decide what will and will not get mapped. For example, if you need Id for some reason in your view, but you don't want the user to be able to change it, simply don't map it from your view model back onto your entity.
I have a view that contains conditional logic to render partial views within the main view based on conditions in the model. Originally I included the properties required for the partial view in the main page's view model and everything was hunky dory. I simply created the partial view and had it inherit the same view model as the main page like so:
public class SomeViewModel
{
public int SomeProperty {get; set;}
public string SomeOtherProperty { get; set; }
etc ...
public string PartialViewProperty { get; set; }
}
Then in the partial view:
Inherits="System.Web.Mvc.ViewUserControl<SomeViewModel>"
But now I want to reuse the partial views on pages with different view models, so the partial view can no longer inherit the same view model as it's parent since the parent view models will be different. I thought of creating a separate model for the partial view and include that in the parent view, but in many cases there is only one property required in the partial view. I could just pass the property through ViewBag or something, but I prefer that all my views are strongly typed. If I go with creating a separate model for partial views my models will now look like this:
public class SomeViewModel
{
public int SomeProperty {get; set;}
public string SomeOtherProperty { get; set; }
public SomePartialViewModel SomeModelObject { get; set; }
}
public class SomePartialViewModel
{
public string PartialViewProperty { get; set; }
}
I'm sure this would work, but it doesn't feel right. It looks strange to me to see a class with only one property in it. I searched Google & SO for things like "class with only one property" etc and could not find examples of classes with just one property. So my questions are:
Are single property classes OK and I just didn't happen to find any examples?
Is there a better way of doing what I want to do that I am overlooking?
Are single property classes OK and I just didn't happen to find any examples?
I don't see anything wrong with this, and I know I've used this myself for certain things. The partial itself is still a different view to your main view, so essentially, that single-property class does represent everything the partial would need in order to be rendered.
Having said that, you could just strongly-type the partial to the type of the property in question. For example, taking your code above:
public class SomeViewModel
{
public int SomeProperty {get; set;}
public string SomeOtherProperty { get; set; }
public SomePartialViewModel SomeModelObject { get; set; }
}
public class SomePartialViewModel
{
public string PartialViewProperty { get; set; }
}
Rather than making the view strongly-typed against SomePartialViewModel, make it strongly-typed against string instead. That way, your parent view model can be simplified to this:
public class SomeViewModel
{
public int SomeProperty {get; set;}
public string SomeOtherProperty { get; set; }
etc ...
public string PartialViewProperty { get; set; }
}
And now you can pass the string to the partial:
#Html.Partial("SomeView", Model.PartialViewProperty)
My personal preference is not to do this. The simple reason being that you could pass any string to that view by mistake and the view would compile. Having a dedicated view model for each partial reduces the likelihood of that happening.
Is there a better way of doing what I want to do that I am overlooking?
You could possibly argue that what you're doing is overkill for smaller projects but, like you, I prefer my views to be strongly-typed. Partials are there to be reused and, to me, that means they should be self-sufficient.
Edit
Actually, we should be talking about validation here too. There are two ways you could look at it:
A partial is completely encapsulated for reuse, meaning its validation requirements should not change.
A partial encapsulates the data passed to it but may have different validation requirements based on which view it's called from.
In my mind, the first one is ideally how everything should be. That would mean validation rules would be applied to a dedicated view model for a particular partial.
However, we've all come across situations where validation requirements change. It may not be desirable but it may also not be unreasonable to expect validation requirements to change for a partial. In that case, having a dedicated view model for the partial would be a problem because the validation rules would apply for all invocations of that partial view.
By applying validation to the parent view model instead, you'd be able to change the validation requirements for the partial. For example:
public class ViewModelForViewA
{
public int Id { get; set; }
// other properties
[Required]
public string PartialProperty { get; set; }
}
public class ViewModelForViewB
{
public int Id { get; set; }
// other properties
// No longer required
public string PartialProperty { get; set; }
}
However, I still believe the first way is the right way. If a partial had different validation requirements in view A and view B, you could argue that it doesn't represent the same view.
They aren't real classes. They are just lowly view models. Don't let their abnormal appearance startle you.
In all seriousness, what you've described, with the partials having their own models is exactly how I have done it. Yes, some folks (and FXCop) will probably harp on you for it, but it's much cleaner and more extensible, as you've described in your post.
Is it possible to step through a model's foreign key to access another model in a View? I want to return one type of model to my view, but get the data from another model. For example, in my view:
#[ModelObject].[Field (ForeignKey)].[ForeignKey Field]
Edit:
Your feedback has been helpful so far, and it sounds like a View Model might be the way to go, but allow me to provide a little more information so that you can better advise.
I have an x.Id, and I want to find all Y objects that are associated with x.Id -- this mapping is held in a table XYMap where several Y.Ids map to one X.Id. Both of these models are in the same entity:
public class X
{
[Key]
public int xId {get; set;}
}
public class XYMap
{
[Key, ForeignKey("Y")]
public int yId { get; set; }
[ForeignKey("X")]
public int xId { get; set; }
}
public class Y
{
[Key]
public int yId { get; set; }
}
What I have tried to do is, given an x.Id called someXid:
var yIdList = db.XYMap.Where(item => item.xId == someXid).ToList()
I want to get all of the Y objects so I can display their data in the view.
It's possible, but not recommended. Perhaps the navigational property is setup with lazy loading and calling #Model.NavigationalField from the view results in a call to the database. The view shouldn't be responsible for these kind of calls.
I would recommend creating a ViewModel that combines the properties that you need from both entities.
I've had a read through Jimmy Bogards post from a whiel back on how they do view models, in my own project I've come across a few places where there is quite a lot of information that needs to displayed at one time on the screen such as a form that needs to be filled out where all fields are shown at once.
So our view models would look something like
public class FormViewModel
{
public string field1 {get;set;}
public int field2 {get;set;}
public DateTime field3 {get;set;}
public string field4 {get;set;}
...snip
public string field50 {get;set;}
}
Now the forms do have sections so we could introduce a bit of structure into the viewmodels like this:
public class FormViewModelSection1
{
public string field1 {get;set;}
public int field2 {get;set;}
}
public class FormViewModelSection2
{
public DateTime field3 {get;set;}
public string field4 {get;set;}
}
and then the main viewmodel becomes
public class FormViewModel
{
public FormViewModelSection1 {get;set;}
public FormViewModelSection2 {get;set;}
}
so we would return the more complex viewmodel to a main view that basically just delegates each of its sections out to be rendered through a renderpartial like
<div>
My form
<%: Html.RenderPartial("soemascx", Model.FormViewModelSection1)%>
</div>
or maybe use an editorfor to render the contents.
My question is, is the "recomposing" of the viewmodel a valid thing to do or is it undoing some of the benefits that are provided by making a view model so flat.
I'd say there's no right answer to your question. It all up to usability and functionality. Maybe even personal coding style.
Meaning as long is it is
working (displaying, posting back, validating etc)
serves the purpose
understandable by others (read maintainable)
consider it to be good solution. If you'd ask about what I'd do: I'd go with one flat class well decorated (data annotations) for names and validation, and structures supporting visual representation (like lists for combo boxes, enums (or whatever you comfortable with) for radio buttons.
As a note, I had some bad experience with hierarchies of view models (inheritance) - was working really poorly with validation (inherited data annotations don't work as expected with view model inheritance).
So to answer your specific question - no, you not doing anything wrong ... its up to you how to do it.
Hope this helps.
I personally don't separate my ViewModels into child ViewModels unless it's for something like a "UserControl" type thing, e.g. A small form on the side of the web page would be a separate ViewModel and the main page ViewModel will reference it.
But generally, I have a BaseViewModel which is an abstract class that has all the shared fields (like pagetitle etc), then I have a ViewModel for the View itself which inherits BaseViewModel. example:
public abstract class BaseViewModel
{
public string PageTitle { get; set; }
public string MetaDescription { get; set; }
public string MetaKeywords { get; set; }
}
I might have a small signup form that i use in a few of my pages. So i'll create a separate ViewModel for this small form. One benefit of separating this out into it's own object is that when the user submits the form, I can pass in the specific SignupViewModel object instead of the main page with all it's entities.
public sealed class SignupViewModel
{
[Required]
public string YourName { get; set; }
[Required]
public string YourEmail { get; set; }
}
Then for an basic web page with the above usercontrol:
public sealed class PageViewModel : BaseViewModel
{
public string PageID { get; set; }
public string PageContents { get; set; }
public SignupViewModel UserSignupForm { get; set; }
}
I suppose there's a number of different ways to tackle the same thing, but this above is how I do it.
I am new to ASP.NET MVC. I have a problem with understanding the purpose of a ViewModel.
What is a ViewModel and why do we need a ViewModel for an ASP.NET MVC Application?
If I get a good example about its working and explanation that would be better.
A view model represents the data that you want to display on your view/page, whether it be used for static text or for input values (like textboxes and dropdown lists) that can be added to the database (or edited). It is something different than your domain model. It is a model for the view.
Let us say that you have an Employee class that represents your employee domain model and it contains the following properties (unique identifier, first name, last name and date created):
public class Employee : IEntity
{
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public DateTime DateCreated { get; set; }
}
View models differ from domain models in that view models only contain the data (represented by properties) that you want to use on your view. For example, lets say that you want to add a new employee record, your view model might look like this:
public class CreateEmployeeViewModel
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
As you can see it only contains two of the properties. These two properties are also in the employee domain model. Why is this you may ask? Id might not be set from the view, it might be auto generated by the Employee table. And DateCreated might also be set in the stored procedure or in the service layer of your application. So Id and DateCreated are not needed in the view model. You might want to display these two properties when you view an employee’s details (an employee that has already been captured) as static text.
When loading the view/page, the create action method in your employee controller will create an instance of this view model, populate any fields if required, and then pass this view model to the view/page:
public class EmployeeController : Controller
{
private readonly IEmployeeService employeeService;
public EmployeeController(IEmployeeService employeeService)
{
this.employeeService = employeeService;
}
public ActionResult Create()
{
CreateEmployeeViewModel model = new CreateEmployeeViewModel();
return View(model);
}
public ActionResult Create(CreateEmployeeViewModel model)
{
// Do what ever needs to be done before adding the employee to the database
}
}
Your view/page might look like this (assuming you are using ASP.NET MVC and the Razor view engine):
#model MyProject.Web.ViewModels.CreateEmployeeViewModel
<table>
<tr>
<td><b>First Name:</b></td>
<td>#Html.TextBoxFor(m => m.FirstName, new { maxlength = "50", size = "50" })
#Html.ValidationMessageFor(m => m.FirstName)
</td>
</tr>
<tr>
<td><b>Last Name:</b></td>
<td>#Html.TextBoxFor(m => m.LastName, new { maxlength = "50", size = "50" })
#Html.ValidationMessageFor(m => m.LastName)
</td>
</tr>
</table>
Validation would thus be done only on FirstName and LastName. Using FluentValidation you might have validation like this:
public class CreateEmployeeViewModelValidator : AbstractValidator<CreateEmployeeViewModel>
{
public CreateEmployeeViewModelValidator()
{
RuleFor(m => m.FirstName)
.NotEmpty()
.WithMessage("First name required")
.Length(1, 50)
.WithMessage("First name must not be greater than 50 characters");
RuleFor(m => m.LastName)
.NotEmpty()
.WithMessage("Last name required")
.Length(1, 50)
.WithMessage("Last name must not be greater than 50 characters");
}
}
And with Data Annotations it might look this:
public class CreateEmployeeViewModel : ViewModelBase
{
[Display(Name = "First Name")]
[Required(ErrorMessage = "First name required")]
public string FirstName { get; set; }
[Display(Name = "Last Name")]
[Required(ErrorMessage = "Last name required")]
public string LastName { get; set; }
}
The key thing to remember is that the view model only represents the data that you want to use, nothing else. You can imagine all the unnecessary code and validation if you have a domain model with 30 properties and you only want to update a single value. Given this scenario you would only have this one value/property in the view model and not all the properties that are in the domain object.
A view model might not only have data from one database table. It can combine data from another table. Take my example above about adding a new employee record. Besides adding just the first and last names you might also want to add the department of the employee. This list of departments will come from your Departments table. So now you have data from the Employees and Departments tables in one view model. You will just then need to add the following two properties to your view model and populate it with data:
public int DepartmentId { get; set; }
public IEnumerable<Department> Departments { get; set; }
When editing employee data (an employee that has already been added to the database) it wouldn’t differ much from my example above. Create a view model, call it for example EditEmployeeViewModel. Only have the data that you want to edit in this view model, like first name and last name. Edit the data and click the submit button. I wouldn’t worry too much about the Id field because the Id value will probably been in the URL, for example:
http://www.yourwebsite.com/Employee/Edit/3
Take this Id and pass it through to your repository layer, together with your first name and last name values.
When deleting a record, I normally follow the same path as with the edit view model. I would also have a URL, for example:
http://www.yourwebsite.com/Employee/Delete/3
When the view loads up for the first time I would get the employee’s data from the database using the Id of 3. I would then just display static text on my view/page so that the user can see what employee is being deleted. When the user clicks the Delete button, I would just use the Id value of 3 and pass it to my repository layer. You only need the Id to delete a record from the table.
Another point, you don’t really need a view model for every action. If it is simple data then it would be fine to only use EmployeeViewModel. If it is complex views/pages and they differ from each other then I would suggest you use separate view models for each.
I hope this clears up any confusion that you had about view models and domain models.
View model is a class that represents the data model used in a specific view. We could use this class as a model for a login page:
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; }
}
Using this view model you can define the view (Razor view engine):
#model CamelTrap.Models.ViewModels.LoginPageVM
#using (Html.BeginForm()) {
#Html.EditorFor(m => m);
<input type="submit" value="Save" class="submit" />
}
And actions:
[HttpGet]
public ActionResult LoginPage()
{
return View();
}
[HttpPost]
public ActionResult LoginPage(LoginPageVM model)
{
...code to login user to application...
return View(model);
}
Which produces this result (screen is taken after submitting form, with validation messages):
As you can see, a view model has many roles:
View models documents a view by consisting only fields, that are represented in view.
View models may contain specific validation rules using data annotations or IDataErrorInfo.
View model defines how a view should look (for LabelFor,EditorFor,DisplayFor helpers).
View models can combine values from different database entities.
You can specify easily display templates for view models and reuse them in many places using DisplayFor or EditorFor helpers.
Another example of a view model and its retrieval: We want to display basic user data, his privileges and users name. We create a special view model, which contains only the required fields. We retrieve data from different entities from database, but the view is only aware of the view model class:
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; }
}
Retrieval:
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
}
Edit: I updated this answer on my Blog:
http://www.samwheat.com/post/The-function-of-ViewModels-in-MVC-web-development
My answer is a bit lengthy but I think it is important to compare view models to other types of commonly used models to understand why they are different and why they are necessary.
To summarize, and to directly answer the question that is asked:
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.
Here is a comparison of Entity models (a.ka. DTOs a.ka. models), Presentation Models, and View Models.
Data Transfer Objects a.k.a “Model”
A Data Transfer Object (DTO) is a class with properties that match a table schema in a database. DTOs are named for their common usage for shuttling data to and from a data store.
Characteristics of DTOs:
Are business objects – their definition is dependent on application data.
Usually contain properties only – no code.
Primarily used for transporting data to and from a database.
Properties exactly or closely match fields on a specific table in a data store.
Database tables are usually normalized therefore DTOs are usually normalized also. This makes them of limited use for presenting data. However, for certain simple data structures, they often do quite well.
Here are two examples of what DTOs might look like:
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; }
}
Presentation Models
A presentation model is a utility class that is used to render data on a screen or report. Presentation models are typically used to model complex data structures that are composed of data from multiple DTOs. Presentation models often represent a denormalized view of data.
Characteristics of Presentation Models:
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.
Presentation models are used “as needed” and “where needed” (whereas DTOs are usually tied to the database schema). A presentation model may be used to model data for an entire page, a grid on a page, or a dropdown on a grid on a page. Presentation models often contain properties that are other presentation models. Presentation models are often constructed for a single-use purpose such as to render a specific grid on a single page.
An example presentation model:
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); } }
}
View Models
A view model is similar to a presentation model in that is a backing class for rendering a view. However, it is very different from a Presentation Model or a DTO in how it is constructed. View models often contain the same properties as presentation models and DTOs and for this reason, they are often confused one for the other.
Characteristics of View Models:
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.
View Model Composition
As stated earlier, view models are composite objects in that they combine application properties and business data properties on a single object. Examples of commonly used application properties that are used on view models are:
Properties that are used to display application state such as error messages, user name, status, etc.
Properties used to format, display, stylize, or animate controls.
Properties used for data binding such as list objects and properties that hold intermediate data that is input by the user.
The following examples show why the composite nature of view models is important and how we can best construct a View Model that efficient and reusable.
Assume we are writing a web application. One of the requirements of the application design is that the page title, user name, and application name must be displayed on every page. If we want to create a page to display a presentation order object, we may modify the presentation model as follows:
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); } }
}
This design might work… but what if we want to create a page that will display a list of orders? The PageTitle, UserName, and ApplicationName properties will be repeated and become unwieldy to work with. Also, what if we want to define some page-level logic in the constructor of the class? We can no longer do that if we create an instance for every order that will be displayed.
Composition over inheritance
Here is a way we might re-factor the order presentation model such that it becomes a true view model and will be useful for displaying a single PresentationOrder object or a collection of PresentationOrder objects:
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; }
}
Looking at the above two classes we can see that one way to think about a view model is that it is a presentation model that contains another presentation model as a property. The top-level presentation model (i.e. view model) contains properties that are relevant to the page or application while the presentation model (property) contains properties that are relevant to application data.
We can take our design a step further and create a base view model class that can be used not only for PresentationOrders but for any other class as well:
public class BaseViewModel
{
// Application properties
public string PageTitle { get; set; }
public string UserName { get; set; }
public string ApplicationName { get; set; }
}
Now we can simplify our PresentationOrderVM like this:
public class PresentationOrderVM : BaseViewModel
{
// Business properties
public PresentationOrder Order { get; set; }
}
public class PresentationOrderVM : BaseViewModel
{
// Business properties
public List<PresentationOrder> Orders { get; set; }
}
We can make our BaseViewModel even more re-usable by making it generic:
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; }
}
Now our implementations are effortless:
public class PresentationOrderVM : BaseViewModel<PresentationOrder>
{
// done!
}
public class PresentationOrderVM : BaseViewModel<List<PresentationOrder>>
{
// done!
}
I didn't read all the posts but every answer seems to be missing one concept that really helped me "get it"...
If a Model is akin to a database Table, then a ViewModel is akin to a database View - A view typically either returns small amounts of data from one table or, complex sets of data from multiple tables (joins).
I find myself using ViewModels to pass the info into a view/form, and then transferring that data into a valid Model when the form posts back to the controller - also very handy for storing Lists(IEnumerable).
If you have properties specific to the view, and not related to the DB/Service/Data store, it is a good practice to use ViewModels. Say, you want to leave a checkbox selected based on a DB field (or two) but the DB field itself isn't a boolean. While it is possible to create these properties in the Model itself and keep it hidden from the binding to data, you may not want to clutter the Model depending on the amount of such fields and transactions.
If there are too few view-specific data and/or transformations, you can use the Model itself
A lot of big examples, let me explain in a clear and crispy way.
ViewModel = Model that is created to serve the view.
ASP.NET MVC view can't have more than one model so if we need to display properties from more than one model in the view, it is not possible. ViewModel serves this purpose.
View Model is a model class that can hold only those properties that are required for a view. It can also contain properties from more than one entity (tables) of the database. As the name suggests, this model is created specifically for the View requirements.
A few examples of View Models are below
To list data from more than entities in a view page – we can create a
View model and have properties of all the entities for which we want
to list data. Join those database entities and set the View model
properties and return to the View to show data of different
entities in one tabular form
The view model may define only specific fields of a single entity that is
required for the View.
ViewModel can also be used to insert, and update records into more than one entity however the main use of ViewModel is to display columns from multiple entities (model) into a single view.
The way of creating a ViewModel is the same as creating a Model, the way of creating a view for the ViewModel is the same as creating a view for a Model.
Here is a small example of List data using ViewModel.
Hope this will be useful.
View model a is simple class which can contain more than one class property. We use it to inherit all the required properties, e.g. I have two classes Student and Subject
Public class Student
{
public int Id {get; set;}
public string Name {get; set;}
}
Public class Subject
{
public int SubjectID {get; set;}
public string SubjectName {get; set;}
}
Now we want to display records student's Name and Subject's Name in View (In MVC), but it's not possible to add more than one classes like:
#model ProjectName.Model.Student
#model ProjectName.Model.Subject
the code above will throw an error...
Now we create one class and can give it any name, but this format "XyzViewModel" will make it easier to understand. It is inheritance concept.
Now we create a third class with the following name:
public class StudentViewModel:Subject
{
public int ID {get; set;}
public string Name {get; set;}
}
Now we use this ViewModel in View
#model ProjectName.Model.StudentViewModel
Now we are able to access all the properties of StudentViewModel and inherited class in View.
MVC doesn't have a view model: it has a model, view, and controller. A ViewModel is part of MVVM (Model-View-ViewModel). MVVM is derived from the Presentation Model and is popularized in WPF. There should also be a model in MVVM, but most people miss the point of that pattern completely and they will only have a view and a view model. The model in MVC is similar to the model in MVVM.
In MVC the process is split into 3 different responsibilities:
View is responsible for presenting the data to the user
A controller is responsible for the page flow
A model is responsible for the business logic
MVC is not very suitable for web applications. It is a pattern introduced by Smalltalk for creating desktop applications. A web environment behaves completely differently. It doesn't make much sense to copy a 40-year-old concept from desktop development and paste it into a web environment. However, a lot of people think this is ok because their application compiles and returns the correct values. That is, in my opinion, not enough to declare a certain design choice as ok.
An example of a model in a web application could be:
public class LoginModel
{
private readonly AuthenticationService authentication;
public LoginModel(AuthenticationService authentication)
{
this.authentication = authentication;
}
public bool Login()
{
return authentication.Login(Username, Password);
}
public string Username { get; set; }
public string Password { get; set; }
}
The controller can use it like this:
public class LoginController
{
[HttpPost]
public ActionResult Login(LoginModel model)
{
bool success = model.Login();
if (success)
{
return new RedirectResult("/dashboard");
}
else
{
TempData["message"] = "Invalid username and/or password";
return new RedirectResult("/login");
}
}
}
Your controller methods and your models will be small, easily testable, and to the point.
ViewModel is workaround that patches the conceptual clumsiness of the MVC framework. It represents the 4th layer in the 3-layer Model-View-Controller architecture. when Model (domain model) is not appropriate, too big (bigger than 2-3 fields) for the View, we create smaller ViewModel to pass it to the View.
View Model is a class that we can use for rendering data on View. Suppose you have two entities Place and PlaceCategory and you want to access data from both entities using a single model then we use ViewModel.
public class Place
{
public int PlaceId { get; set; }
public string PlaceName { get; set; }
public string Latitude { get; set; }
public string Longitude { get; set; }
public string BestTime { get; set; }
}
public class Category
{
public int ID { get; set; }
public int? PlaceId { get; set; }
public string PlaceCategoryName { get; set; }
public string PlaceCategoryType { get; set; }
}
public class PlaceCategoryviewModel
{
public string PlaceName { get; set; }
public string BestTime { get; set; }
public string PlaceCategoryName { get; set; }
public string PlaceCategoryType { get; set; }
}
So in the above Example, Place and Category are the two different entities and PlaceCategory ViewModel is ViewModel which we can use on View.
ViewModel is the model containing fields to use in MVC View. Using ViewModel for the view has the following benefits:
As the database model (Entity class) contains a single table's data. If required data from multiple tables, a single ViewModel can have multiple tables' fields.
User can not interact directly with the database model, so the Database layer or model is secured.
It is used to get data from the database model through the repository and pass it to view. Similarly, it utilizes for posting data to the database model to update database records.
If you want to study code on how to set up a "Baseline" web application with ViewModels I can advise you to download this code on GitHub: https://github.com/ajsaulsberry/BlipAjax. I developed large enterprise applications. When you do this it's problematic to set up a good architecture that handles all this "ViewModel" functionality. I think with BlipAjax you will have a very good "baseline" to start with. It's just a simple website, but great in its simplicity. I like the way they used the English language to point out what's really needed in the application.
A view model is a conceptual model of data. Its use is to for example either get a subset or combine data from different tables.
You might only want specific properties, so this allows you to only load those and not add unnecessary properties.
ViewModel contain fields that are represented in the view (for
LabelFor,EditorFor,DisplayFor helpers)
ViewModel can have specific validation rules using data annotations
or IDataErrorInfo.
ViewModel can have multiple entities or objects from different data
models or data source.
Designing 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; }
}
Presenting the viewmodel in the view
#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>
}
Working with Action
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);
}
In ViewModel put only those fields/data that you want to display on
the view/page.
Since view reperesents the properties of the ViewModel, hence it is
easy for rendering and maintenance.
Use a mapper when ViewModel become more complex.
View model is same as your datamodel but you can add 2 or more data model classes in it. According to that you have to change your controller to take 2 models at once
A viewmodel is a usually an aggregation/combination of two or more models.
Let's say we have a DB with two tables called Student and Course with two models each. On the client side we have two views to render each table.
Imagine you need another view that renders both students and courses? Then you can create a a so called viewmodel. Which is basically a class that takes both Models i.e Students and Courses.
Class CombinedStudentsCourses will be the view model and can be returned by the view.
public class Student
{
public string? Name{ get; set; }
public string? Email{ get; set; }
}
THIS is our view model with two models combined inside.
public class Course
{
public string? CourseName { get; set; }
public string? CourseCode { get; set; }
}
ViewModel i.e combining two or more models to satisfy the specific needs of our view.
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,);
}