Complete CRUD Operations in MVC 4 Using Entity Framework 5 Without Writing Code

Akhil Mittal
8y
298.8k
0
13

Article

Introduction

This article describes how to perform basic CRUD operations in an MVC4 application using Entity Framework 5 without writing a single line of code. Entity Framework and MVC have advanced to the level that we don't need to put effort into doing extra work.

MVC
- Model: The business entity on which the overall application operates. Many applications use a persistent storage mechanism (such as a database) to store data. MVC does not specifically mention the data access layer because it is understood to be encapsulated by the Model.
- View: The user interface that renders the model into a form of interaction.
- Controller: Handles a request from a view and updates the model that results in a change in the Model's state.
To implement MVC in .NET we need mainly three classes (View, Controller and the Model).
Entity Framework

Let's have a look at the standard definition of Entity Framework given by Microsoft:

"The Microsoft ADO.NET Entity Framework is an Object/Relational Mapping (ORM) framework that enables developers to work with relational data as domain-specific objects, eliminating the need for most of the data access plumbing code that developers usually need to write. Using the Entity Framework, developers issue queries using LINQ, then retrieve and manipulate data as strongly typed objects. The Entity Framework's ORM implementation provides services like change tracking, identity resolution, lazy loading, and query translation so that developers can focus on their application-specific business logic rather than the data access fundamentals."

In simple terms, Entity Framework is an Object/Relational Mapping (ORM) framework. It is an enhancement to ADO.NET, an upper layer to ADO.Net that gives developers an automated mechanism for accessing and storing the data in the database.

Hope this provides a glimpse at an ORM and EntityFramework.
MVC Application

Step 1: Create a database named "LearningKO" and add a table named "student" to it, the script of the table is as follows:
1. USE [LearningKO]
2. GO
3. /****** Object: Table [dbo].[Student] Script Date: 12/04/2013 23:58:12 ******/
4. SETANSI_NULLS ON
5. GO
6. SETQUOTED_IDENTIFIER ON
7. GO
8. CREATETABLE [dbo].[Student](
9. [StudentId] [nvarchar](10)NOT NULL,
10. [FirstName] [nvarchar](50)NULL,
11. [LastName] [nvarchar](50)NULL,
12. [Age] [int]NULL,
13. [Gender] [nvarchar](50)NULL,
14. [Batch] [nvarchar](50)NULL,
15. [Address] [nvarchar](50)NULL,
16. [Class] [nvarchar](50)NULL,
17. [School] [nvarchar](50)NULL,
18. [Domicile] [nvarchar](50)NULL,
19. CONSTRAINT [PK_Student] PRIMARYKEY CLUSTERED
20. (
21. [StudentId]ASC
22. )WITH(PAD_INDEX = OFF,STATISTICS_NORECOMPUTE = OFF,IGNORE_DUP_KEY =OFF,ALLOW_ROW_LOCKS =ON,ALLOW_PAGE_LOCKS =ON)ON [PRIMARY]
23. )ON [PRIMARY]
24. GO
25. INSERT [dbo].[Student]([StudentId], [FirstName], [LastName], [Age], [Gender], [Batch], [Address], [Class], [School], [Domicile]) VALUES(N'1',N'Akhil',N'Mittal', 28,N'Male',N'2006',N'Noida',N'Tenth',N'LFS',N'Delhi')
26. INSERT [dbo].[Student]([StudentId], [FirstName], [LastName], [Age], [Gender], [Batch], [Address], [Class], [School], [Domicile]) VALUES(N'2',N'Parveen',N'Arora', 25,N'Male',N'2007',N'Noida',N'8th',N'DPS',N'Delhi')
27. INSERT [dbo].[Student]([StudentId], [FirstName], [LastName], [Age], [Gender], [Batch], [Address], [Class], [School], [Domicile]) VALUES(N'3',N'Neeraj',N'Kumar', 38,N'Male',N'2011',N'Noida',N'10th',N'MIT',N'Outside Delhi')
28. INSERT [dbo].[Student]([StudentId], [FirstName], [LastName], [Age], [Gender], [Batch], [Address], [Class], [School], [Domicile]) VALUES(N'4',N'Ekta',N'Mittal', 25,N'Female',N'2005',N'
29. Noida',N'12th',N'LFS',N'Delhi')
Step 2: Open your Visual Studio (the Visual Studio Version should be greater than or equal to 12) and add an MVC internet application as in the following:

I have given it the name "KnockoutWithMVC4".

Step 3: You'll get a fully structured MVC application with default Home controller in the Controller folder. By default Entity Framework is downloaded as a package in the application folder, but if not then you can add the Entity Framework package by right-clicking the project, select "Manage nugget packages" and search and install the Entity Framework.

Step 4: Right-click the project file, select "Add a new item" and add the ADO .Net Entity Data Model, follow the procedure in the wizard as shown below:

Generate a model from the database, select your server and "LearningKO" database name, the connection string will automatically be added to your Web.Config, name that connection string "LearningKOEntities".

Select tables to be added to the model. In our case it's the "Student" table.

Step 5: Now add a new controller to the Controller folder, right-click the controller folder and add a controller named "Student". Since we have already created our data model, we can choose for an option where CRUD actions are created by the chosen Entity Framework data model.
- Name your controller as "StudentController",
Step 6: We see out student controller prepared with all the CRUD operation actions as shown below:
1. using System;
2. using System.Collections.Generic;
3. using System.Data;
4. using System.Data.Entity;
5. using System.Linq;
6. using System.Web;
7. using System.Web.Mvc;
8. namespace KnockoutWithMVC4.Controllers
9. {
10. publicclassStudentController : Controller
11. {
12. private LearningKOEntities db = new LearningKOEntities();
13. //
14. // GET: /Student/
15. public ActionResult Index()
16. {
17. return View(db.Students.ToList());
18. }
19. //
20. // GET: /Student/Details/5
21. public ActionResult Details(string id = null)
22. {
23. Student student = db.Students.Find(id);
24. if (student == null)
25. {
26. return HttpNotFound();
27. }
28. return View(student);
29. }
30. //
31. // GET: /Student/Create
32. public ActionResult Create()
33. {
34. return View();
35. }
36. //
37. // POST: /Student/Create
38. [HttpPost]
39. [ValidateAntiForgeryToken]
40. public ActionResult Create(Student student)
41. {
42. if (ModelState.IsValid)
43. {
44. db.Students.Add(student);
45. db.SaveChanges();
46. return RedirectToAction("Index");
47. }
48. return View(student);
49. }
50. //
51. // GET: /Student/Edit/5
52. public ActionResult Edit(string id = null)
53. {
54. Student student = db.Students.Find(id);
55. if (student == null)
56. {
57. return HttpNotFound();
58. }
59. return View(student);
60. }
61. //
62. // POST: /Student/Edit/5
63. [HttpPost]
64. [ValidateAntiForgeryToken]
65. public ActionResult Edit(Student student)
66. {
67. if (ModelState.IsValid)
68. {
69. db.Entry(student).State = EntityState.Modified;
70. db.SaveChanges();
71. return RedirectToAction("Index");
72. }
73. return View(student);
74. }
75. //
76. // GET: /Student/Delete/5
77. public ActionResult Delete(string id = null)
78. {
79. Student student = db.Students.Find(id);
80. if (student == null)
81. {
82. return HttpNotFound();
83. }
84. return View(student);
85. }
86. //
87. // POST: /Student/Delete/5
88. [HttpPost, ActionName("Delete")]
89. [ValidateAntiForgeryToken]
90. public ActionResult DeleteConfirmed(string id)
91. {
92. Student student = db.Students.Find(id);
93. db.Students.Remove(student);
94. db.SaveChanges();
95. return RedirectToAction("Index");
96. }
97. protectedoverridevoid Dispose(bool disposing)
98. {
99. db.Dispose();
100. base.Dispose(disposing);
101. }
102. }
103. }
Step 7: Open the "App_Start" folder and change the name of the controller from "Home" to "Student".

The code will become:
1. publicstaticvoid RegisterRoutes(RouteCollection routes)
2. {
3. routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
4. routes.MapRoute(
5. name: "Default",
6. url: "{controller}/{action}/{id}",
7. defaults: new { controller = "Student", action = "Index", id = UrlParameter.Optional });
8. }
Step 8: Now press F5 to run the application, and you'll see the list of all students we added into the Student table while creating it as displayed. Since the CRUD operations are automatically written, we have action results for a display list and other edit, delete and create operations. Note that views for all the operations are created in the "Views" folder under the "Student" folder name.

run the application

Now you can perform all the operations on this list.

MVC Code

Since I have not provided any validation checks on the model or created an existing student id, the code may break, so I am calling Edit Action in the create when we find that the id already exists.

MVC Edit Action

Now create a new student.

We see that the student is created successfully and added to the list.

student created successfully

In the database:

Similarly for an edit:

edit the data

Change any field and press "Save".The change will be reflected in the list and the database.

change in the list and the database

For delete:

delete the data

Student deleted.

And in the database:

database Data After delete

Not a single line of code has been written.

Code written

Conclusion

In this tutorial we learned to set up an environment for MVC and Entity Framework 5 and perform CRUD operations on a Student model without writing a single line of code. You can expand the application by adding multiple Controllers, Models and Views.

Note: a few of the images in this article were obtained via Google search.