A Quick Start on MVC

ntroduction
In this session we will describe the basic CRUD operations using MVC and Entity Framework.

The main advantage of these parts is we don't need to write any code.

About MVC: ASP.NET MVC Overview 

We need to use the following procedure to create our first MVC application.

Procedure

Step 1

Frist step we need to create a new MVC application.



Step 2

Select the option Internet Application and select the view engine as Razor.



Step 3

Now our solution is created.



Step 4

A close look at our solution. We are now just concentrating on the three folders Controllers, Models and Views.



Step 5

Right-click on the Models => Add=> New Item.



Step 6

Select the Data option and click on the Entity Data Model.



Step 7

If you want to install the latest version of the Entity Framework then you can install it through Manage NuGet Packages.



Step 8

Click on the option Generate from database.



Step 9

Here we need to create a new database connection.



Step 10

In this window we need to provide the inputs like our server name and select the database name from the dropdown box .Then we have the option to test our server connection.



Step 11

The next step is to select the tables from the selected database.



Step 12

Now the .edmx is created and in our model folder the model classes are created.



Step 13

Now we need to create a new controller. Right-click on the Controller then seelct Add => Controller.



Step 14

We need to edit the Controller name and select the Scaffolding options as MVC controller with read/write actions and views, using the Entity Framework.



Step 15

Likewise select the Model class name and Data context class name.



Step 16

Now our Employee controller is created with some auto-generated code.



Code

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. using MyFirstMVCApp.Models;  
9.   
10. namespace MyFirstMVCApp.Controllers  
11. {  
12.     public class EmployeeController : Controller  
13.     {  
14.         private MVC_TrainingEntities db = new MVC_TrainingEntities();  
15.   
16.         //  
17.         // GET: /Employee/  
18.   
19.         public ActionResult Index()  
20.         {  
21.             return View(db.Employees.ToList());  
22.         }  
23.   
24.         //  
25.         // GET: /Employee/Details/5  
26.   
27.         public ActionResult Details(int id = 0)  
28.         {  
29.             Employee employee = db.Employees.Find(id);  
30.             if (employee == null)  
31.             {  
32.                 return HttpNotFound();  
33.             }  
34.             return View(employee);  
35.         }  
36.   
37.         //  
38.         // GET: /Employee/Create  
39.   
40.         public ActionResult Create()  
41.         {  
42.             return View();  
43.         }  
44.   
45.         //  
46.         // POST: /Employee/Create  
47.   
48.         [HttpPost]  
49.         [ValidateAntiForgeryToken]  
50.         public ActionResult Create(Employee employee)  
51.         {  
52.             if (ModelState.IsValid)  
53.             {  
54.                 db.Employees.Add(employee);  
55.                 db.SaveChanges();  
56.                 return RedirectToAction("Index");  
57.             }  
58.   
59.             return View(employee);  
60.         }  
61.   
62.         //  
63.         // GET: /Employee/Edit/5  
64.   
65.         public ActionResult Edit(int id = 0)  
66.         {  
67.             Employee employee = db.Employees.Find(id);  
68.             if (employee == null)  
69.             {  
70.                 return HttpNotFound();  
71.             }  
72.             return View(employee);  
73.         }  
74.   
75.         //  
76.         // POST: /Employee/Edit/5  
77.   
78.         [HttpPost]  
79.         [ValidateAntiForgeryToken]  
80.         public ActionResult Edit(Employee employee)  
81.         {  
82.             if (ModelState.IsValid)  
83.             {  
84.                 db.Entry(employee).State = EntityState.Modified;  
85.                 db.SaveChanges();  
86.                 return RedirectToAction("Index");  
87.             }  
88.             return View(employee);  
89.         }  
90.   
91.         //  
92.         // GET: /Employee/Delete/5  
93.   
94.         public ActionResult Delete(int id = 0)  
95.         {  
96.             Employee employee = db.Employees.Find(id);  
97.             if (employee == null)  
98.             {  
99.                 return HttpNotFound();  
100.             }  
101.             return View(employee);  
102.         }  
103.   
104.         //  
105.         // POST: /Employee/Delete/5  
106.   
107.         [HttpPost, ActionName("Delete")]  
108.         [ValidateAntiForgeryToken]  
109.         public ActionResult DeleteConfirmed(int id)  
110.         {  
111.             Employee employee = db.Employees.Find(id);  
112.             db.Employees.Remove(employee);  
113.             db.SaveChanges();  
114.             return RedirectToAction("Index");  
115.         }  
116.   
117.         protected override void Dispose(bool disposing)  
118.         {  
119.             db.Dispose();  
120.             base.Dispose(disposing);  
121.         }  
122.     }  
123. }  

Next we need to check our Views folder, yes it has one folder named “Employee” and its views are auto-generated.



Please have a look at our Index.cshtml.

1. @model IEnumerable<MyFirstMVCApp.Models.Employee>  
2.   
3. @{  
4.     ViewBag.Title = "Index";  
5. }  
6.   
7. <h2>Index</h2>  
8.   
9. <p>  
10.     @Html.ActionLink("Create New", "Create")  
11. </p>  
12. <table>  
13.     <tr>  
14.         <th>  
15.             @Html.DisplayNameFor(model => model.EmpNo)  
16.         </th>  
17.         <th>  
18.             @Html.DisplayNameFor(model => model.EmpName)  
19.         </th>  
20.         <th>  
21.             @Html.DisplayNameFor(model => model.Salary)  
22.         </th>  
23.         <th>  
24.             @Html.DisplayNameFor(model => model.Idx)  
25.         </th>  
26.         <th>  
27.             @Html.DisplayNameFor(model => model.DeptNo)  
28.         </th>  
29.         <th></th>  
30.     </tr>  
31.   
32. @foreach (var item in Model) {  
33.     <tr>  
34.         <td>  
35.             @Html.DisplayFor(modelItem => item.EmpNo)  
36.         </td>  
37.         <td>  
38.             @Html.DisplayFor(modelItem => item.EmpName)  
39.         </td>  
40.         <td>  
41.             @Html.DisplayFor(modelItem => item.Salary)  
42.         </td>  
43.         <td>  
44.             @Html.DisplayFor(modelItem => item.Idx)  
45.         </td>  
46.         <td>  
47.             @Html.DisplayFor(modelItem => item.DeptNo)  
48.         </td>  
49.         <td>  
50.             @Html.ActionLink("Edit", "Edit", new { id = item.EmpNo }) |  
51.             @Html.ActionLink("Details", "Details", new { id = item.EmpNo }) |  
52.             @Html.ActionLink("Delete", "Delete", new { id = item.EmpNo })  
53.         </td>  
54.     </tr>  
55. }  
56.   
57. </table>  

In the App_Start: we need to initialize the starting page in this file.

Open the RouteConfig file and edit the controller name and action name.



Yes! Our first MVC application is completed.

 

Source Collected from CSharpcorner.com

http://www.c-sharpcorner.com/UploadFile/a9d961/a-quick-start-on-mvc/