Data is the heart of every application. A user enters data into the application, edits the entered data, and searches the data. We can even say that an application that we build is just an interface for the operations that we perform on the application data. So, it is absolutely necessary for any framework to provide a mechanism to handle data operations easier and more manageable. Models in ASP.NET MVC are used to represent the business domain data.
In this chapter, you'll be learning about the following topics:
Models and their purpose
Creating a simple model and using it in the controller and views of the ASP.NET MVC application
Creating a model specific to a View model
Data flow in an ASP.NET MVC application in the context of models and ViewModels
Purpose of the Entity Framework along with its features and benefits
Adding, updating, and deleting data using the Entity Framework
Using the Entity Framework in ASP.NET MVC applications
Models are simple POCO (Plain Old C# Objects) classes representing your business domain data. For an e-commerce business, model classes would be Product, Order, and Inventory. If you are building an application for a university, model classes would be Student, Teacher, and Subject. Models represent the business domain data in your application and they are not aware of the underlying database that is being used in your application. In fact, you don't even need a database to work with models.
They can represent the data stored in an XML file or CSV file or any other data in your application. Having said that, these models could be used to interact with your database (in most cases) but they don't have any dependency to the database.
The following steps describe how to create an ASP.NET Core application that uses Models:
Make sure to create an ASP.NET 5 application with an empty template. Install the ASP.NET Core NuGet package and configure this, as discussed in an earlier chapter.
Create...
Model binding is the process of mapping the Model data coming from the View to the ViewModel parameter of the action method in the Controller.
Let us consider a simple form with a couple of form fields—Name and EmailID. On the submission of the form, these values would be mapped to the ViewModel object of the action method of the Controller. Model binding takes care of this mapping. The Model binder looks for a match in the form fields, query strings, and request parameters.
In the preceding example, any class with these properties would be picked up by ModelBinder without any issues.
As the following Person class contains the Name and EmailID properties, the model binder would not complain about using this model for mapping the entered values in the form:
public class Person {
public string Name { get; set; }
public string EmailID { get; set; }
}
The following code snippet shows how to use the Person class in the action method:
public ActionResult Add...
The Entity Framework is the Object Relational Mapping (ORM) framework that enables developers to work on domain-specific objects directly for data access instead of working on database queries. This reduces a lot of the code complexity in the data access layer in the application.
Before discussing the Entity Framework and its features, let us pause for a moment and think about the steps that we follow when we try to save some information to the database when using ADO.NET:
Construct the business domain object.
Create a connection to your database.
Open the connection.
Create a command object along with the command type.
Add the properties of your business domain object to the parameters of the command object.
Execute the command that saves the data into the database.
We have to follow the previously mentioned six steps for common operations such as saving a piece of data into the database.
If you are using an ORM framework such as the Entity Framework, you just need three steps...
Using the Entity Framework in ASP.NET MVC applications
There is not much difference between using the Entity Framework in a console application and ASP.NET MVC application. Now, we are going to build a simple application with a single screen as shown in the following image. In this screen, we will have a form where the user will enter the information about the employee; once the user submits the form, the information will be saved to the database and reflected in the following screenshots:
We can create a simple Model for the employee. We need to build a ViewModel for this View, as we need to get the employee information from the user and we need to show a list of employees as well on the same screen.
Let us create an ASP.NET Core application, adding the employee and showing the list of employees. The following is the step-by-step instructions to create the application for the previously mentioned objective:
Create an ASP.NET Core project in Visual Studio by selecting an empty ASP.NET 5 application...
We have created the business entity—the Employee class. Now, we can proceed with the migration. Migration is a two-step process: in the first step, we create the migration files. This can be done by executing the following command from the command prompt from the context of the project:
dnx ef migrations add InitialMigration
This command will create the migration files in your project, as shown in the following screenshot:
Then execute the following command to create the database:
This command will read the migration files created in the previous step and create the database along with the associated tables:
Run the application. You will get the following screen, where the user can enter the employee information in the form. As we are using the strongly typed model in our view, it takes the default values for all the properties. The Name and Designation are properties of type string and the default values are empty string for these fields, Salary is of type decimal...
In this chapter, we learned what a Model is and how it fits in the ASP.NET MVC application. Then, we created a simple Model, built model data in a Controller, passed the Model to the View, and shown the data using the View. We have learned about the Models specific to a View and have discussed the flow of the data with respect to Models. We learned about the Entity Framework, an ORM framework from Microsoft, and how it simplifies database access from your .NET application. We have created simple console application where we have inserted, updated, and deleted the records. Finally, we have built an ASP.NET Core application that uses Model, ViewModel, and Entity Framework.
