Carregando Post...

CRUD com ASP.NET Core MVC Usando ADO.NET and Visual Studio 2017

Introdução

Neste artigo, vou explicar como criar um aplicativo da Web MVC no ASP.NET Core 2.0 usando o ADO.NET. Nós estaremos criando um exemplo de Employee Record Management System e executando operações CRUD nele.

Nós usaremos o Visual Studio 2017 (versão 15.3.5 ou superior) e o SQL Server.

Pré-requisitos

  • Instale o .NET Core 2.0.0 ou acima do SDK  daqui
  • Instale o Visual Studio 2017 Community Edition (Versão 15.3.5 ou superior) a partir  daqui

Agora, estamos prontos para prosseguir com a criação do nosso aplicativo da web MVC.

Antes de continuar, eu recomendaria o download do código-fonte do Github .

Criando Tabela e Procedimentos Armazenados

Estaremos usando uma tabela de banco de dados para armazenar todos os registros dos funcionários.

Abra o SQL Server e use o seguinte script para criar a  tabela tblEmployee  .

  1. Create table tblEmployee(
  2. EmployeeId int IDENTITY(1,1) NOT NULL,
  3. Name varchar(20) NOT NULL,
  4. City varchar(20) NOT NULL,
  5. Department varchar(20) NOT NULL,
  6. Gender varchar(6) NOT NULL
  7. )

Agora, criaremos procedimentos armazenados para adicionar, excluir, atualizar e obter dados de funcionários.

Para inserir um registro de funcionário

  1. Create procedure spAddEmployee
  2. (
  3. @Name VARCHAR(20),
  4. @City VARCHAR(20),
  5. @Department VARCHAR(20),
  6. @Gender VARCHAR(6)
  7. )
  8. as
  9. Begin
  10. Insert into tblEmployee (Name,City,Department, Gender)
  11. Values (@Name,@City,@Department, @Gender)
  12. End

Para atualizar um registro de funcionário

  1. Create procedure spUpdateEmployee
  2. (
  3. @EmpId INTEGER ,
  4. @Name VARCHAR(20),
  5. @City VARCHAR(20),
  6. @Department VARCHAR(20),
  7. @Gender VARCHAR(6)
  8. )
  9. as
  10. begin
  11. Update tblEmployee
  12. set Name=@Name,
  13. City=@City,
  14. Department=@Department,
  15. Gender=@Gender
  16. where EmployeeId=@EmpId
  17. End

Para excluir um registro de funcionário

  1. Create procedure spDeleteEmployee
  2. (
  3. @EmpId int
  4. )
  5. as
  6. begin
  7. Delete from tblEmployee where EmployeeId=@EmpId
  8. End

Para ver todos os registros de funcionários

  1. Create procedure spGetAllEmployees
  2. as
  3. Begin
  4. select *
  5. from tblEmployee
  6. order by EmployeeId
  7. End

Agora, nossa parte do banco de dados foi concluída. Então, vamos continuar a criar o aplicativo MVC usando o Visual Studio.

Criar aplicativo da web do MVC

Abra o Visual Studio e selecione File >> New >> Project.


Depois de selecionar o projeto, uma caixa de diálogo “Novo projeto” será aberta. Selecione .NET Core dentro do menu Visual C # no painel esquerdo. 
Em seguida, selecione “ASP.NET Core Web Application” nos tipos de projeto disponíveis. Coloque o nome do projeto como  MVCDemoApp  e pressione OK. Consulte esta imagem.

Depois de clicar em OK, uma nova caixa de diálogo será aberta pedindo para selecionar o modelo do projeto. Você pode observar dois menus suspensos no canto superior esquerdo da janela do modelo. Selecione “.NET Core” e “ASP.NET Core 2.0” desses menus suspensos. Em seguida, selecione o modelo “Aplicativo da Web (Model-View-Controller)” e pressione OK.

Agora nosso projeto será aberto. Você pode observar que temos pastas Modelos, Visualizações e Controladores já criadas. Nós estaremos adicionando nossos arquivos apenas a estas pastas.

Adicionando o Controlador ao Aplicativo

Clique com o botão direito na pasta Controllers e selecione Add >> New Item

Uma caixa de diálogo "Add New Item" será aberta. Selecione Web no painel esquerdo, selecione “MVC Controller Class” no painel templates e coloque o nome como  EmployeeController.cs . Pressione OK.

Agora nosso  EmployeeController  foi criado. Vamos colocar toda a nossa lógica de negócios neste controlador.

Adicionando o modelo ao aplicativo

Clique com o botão direito na   pasta Models e selecione Add >> Class. Nomeie sua classe  Employee.cs. Esta classe conterá as propriedades do nosso modelo Employee.

Adicione mais um arquivo de classe à   pasta Modelos . Nomeie-o como  EmployeeDataAccessLayer.cs . Esta classe conterá nossas operações relacionadas ao banco de dados.

Agora, a pasta Modelos possui a seguinte estrutura.

Abra  Employee.cs  e coloque o seguinte código nele. Como estamos adicionando os validadores necessários aos campos da classe Employee, precisamos usar System.ComponentModel.DataAnnotations na parte superior.


  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel.DataAnnotations;
  4. using System.Linq;
  5. using System.Threading.Tasks;
  6. namespace MVCDemoApp.Models
  7. {
  8. public class Employee
  9. {
  10. public int ID { get; set; }
  11. [Required]
  12. public string Name { get; set; }
  13. [Required]
  14. public string Gender { get; set; }
  15. [Required]
  16. public string Department { get; set; }
  17. [Required]
  18. public string City { get; set; }
  19. }
  20. }

Abra  EmployeeDataAccessLayer.cs  e coloque o seguinte código para manipular as operações do banco de dados. Certifique-se de colocar sua string de conexão.

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Data;
  4. using System.Data.SqlClient;
  5. using System.Linq;
  6. using System.Threading.Tasks;
  7. namespace MVCDemoApp.Models
  8. {
  9. public class EmployeeDataAccessLayer
  10. {
  11. string connectionString = "Put Your Connection string here";
  12. //To View all employees details
  13. public IEnumerable<Employee> GetAllEmployees()
  14. {
  15. List<Employee> lstemployee = new List<Employee>();
  16. using (SqlConnection con = new SqlConnection(connectionString))
  17. {
  18. SqlCommand cmd = new SqlCommand("spGetAllEmployees", con);
  19. cmd.CommandType = CommandType.StoredProcedure;
  20. con.Open();
  21. SqlDataReader rdr = cmd.ExecuteReader();
  22. while (rdr.Read())
  23. {
  24. Employee employee = new Employee();
  25. employee.ID = Convert.ToInt32(rdr["EmployeeID"]);
  26. employee.Name = rdr["Name"].ToString();
  27. employee.Gender = rdr["Gender"].ToString();
  28. employee.Department = rdr["Department"].ToString();
  29. employee.City = rdr["City"].ToString();
  30. lstemployee.Add(employee);
  31. }
  32. con.Close();
  33. }
  34. return lstemployee;
  35. }
  36. //To Add new employee record
  37. public void AddEmployee(Employee employee)
  38. {
  39. using (SqlConnection con = new SqlConnection(connectionString))
  40. {
  41. SqlCommand cmd = new SqlCommand("spAddEmployee", con);
  42. cmd.CommandType = CommandType.StoredProcedure;
  43. cmd.Parameters.AddWithValue("@Name", employee.Name);
  44. cmd.Parameters.AddWithValue("@Gender", employee.Gender);
  45. cmd.Parameters.AddWithValue("@Department", employee.Department);
  46. cmd.Parameters.AddWithValue("@City", employee.City);
  47. con.Open();
  48. cmd.ExecuteNonQuery();
  49. con.Close();
  50. }
  51. }
  52. //To Update the records of a particluar employee
  53. public void UpdateEmployee(Employee employee)
  54. {
  55. using (SqlConnection con = new SqlConnection(connectionString))
  56. {
  57. SqlCommand cmd = new SqlCommand("spUpdateEmployee", con);
  58. cmd.CommandType = CommandType.StoredProcedure;
  59. cmd.Parameters.AddWithValue("@EmpId", employee.ID);
  60. cmd.Parameters.AddWithValue("@Name", employee.Name);
  61. cmd.Parameters.AddWithValue("@Gender", employee.Gender);
  62. cmd.Parameters.AddWithValue("@Department", employee.Department);
  63. cmd.Parameters.AddWithValue("@City", employee.City);
  64. con.Open();
  65. cmd.ExecuteNonQuery();
  66. con.Close();
  67. }
  68. }
  69. //Get the details of a particular employee
  70. public Employee GetEmployeeData(int? id)
  71. {
  72. Employee employee = new Employee();
  73. using (SqlConnection con = new SqlConnection(connectionString))
  74. {
  75. string sqlQuery = "SELECT * FROM tblEmployee WHERE EmployeeID= " + id;
  76. SqlCommand cmd = new SqlCommand(sqlQuery, con);
  77. con.Open();
  78. SqlDataReader rdr = cmd.ExecuteReader();
  79. while (rdr.Read())
  80. {
  81. employee.ID = Convert.ToInt32(rdr["EmployeeID"]);
  82. employee.Name = rdr["Name"].ToString();
  83. employee.Gender = rdr["Gender"].ToString();
  84. employee.Department = rdr["Department"].ToString();
  85. employee.City = rdr["City"].ToString();
  86. }
  87. }
  88. return employee;
  89. }
  90. //To Delete the record on a particular employee
  91. public void DeleteEmployee(int? id)
  92. {
  93. using (SqlConnection con = new SqlConnection(connectionString))
  94. {
  95. SqlCommand cmd = new SqlCommand("spDeleteEmployee", con);
  96. cmd.CommandType = CommandType.StoredProcedure;
  97. cmd.Parameters.AddWithValue("@EmpId", id);
  98. con.Open();
  99. cmd.ExecuteNonQuery();
  100. con.Close();
  101. }
  102. }
  103. }
  104. }

Agora, vamos continuar a criar nossas visualizações.

Adicionando Views ao Aplicativo

Para adicionar visualizações para nossa classe de controlador, precisamos criar uma pasta dentro da  pasta Views  com o mesmo nome de nosso controlador e, em seguida, adicionar nossas visualizações a essa pasta.

Clique com o botão direito do mouse na  pasta Views  e, em seguida, em Add >> New Folder e nomeie a pasta como  Employee .

Agora clique com o botão direito do mouse na   pasta Views / Employee e selecione Add >> New Item.

Uma caixa de diálogo "Add New Item" será aberta. Selecione Web no painel esquerdo, selecione “MVC View Page” no painel templates e coloque o nome como  Index.cshtml . Pressione OK.

Assim, criamos nossa primeira visão. Da mesma forma, adicione mais 4 visualizações na   pasta Views / Employee ,  Create.cshtml, Delete.cshtml, Details.cshtml  e  Edit.cshtml.

Agora, nossa  pasta de visualizações  ficará assim

Desde que nossas visões foram criadas, nós colocaremos códigos em View e Controller para executar operações CRUD.

Criar vista

Essa visualização será usada para adicionar novos dados de funcionários ao banco de dados.

Abra o  Create.cshtml  e coloque o seguinte código nele.

  1. @model MVCDemoApp.Models.Employee
  2. @{
  3. ViewData["Title"] = "Create";
  4. }
  5. <h2>Create</h2>
  6. <h4>Employees</h4>
  7. <hr />
  8. <div class="row">
  9. <div class="col-md-4">
  10. <form asp-action="Create">
  11. <div asp-validation-summary="ModelOnly" class="text-danger"></div>
  12. <div class="form-group">
  13. <label asp-for="Name" class="control-label"></label>
  14. <input asp-for="Name" class="form-control" />
  15. <span asp-validation-for="Name" class="text-danger"></span>
  16. </div>
  17. <div class="form-group">
  18. <label asp-for="Gender" class="control-label"></label>
  19. <select asp-for="Gender" class="form-control">
  20. <option value="">-- Select Gender --</option>
  21. <option value="Male">Male</option>
  22. <option value="Female">Female</option>
  23. </select>
  24. <span asp-validation-for="Gender" class="text-danger"></span>
  25. </div>
  26. <div class="form-group">
  27. <label asp-for="Department" class="control-label"></label>
  28. <input asp-for="Department" class="form-control" />
  29. <span asp-validation-for="Department" class="text-danger"></span>
  30. </div>
  31. <div class="form-group">
  32. <label asp-for="City" class="control-label"></label>
  33. <input asp-for="City" class="form-control" />
  34. <span asp-validation-for="City" class="text-danger"></span>
  35. </div>
  36. <div class="form-group">
  37. <input type="submit" value="Create" class="btn btn-default" />
  38. </div>
  39. </form>
  40. </div>
  41. </div>
  42. <div>
  43. <a asp-action="Index">Back to List</a>
  44. </div>
  45. @section Scripts {
  46. @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
  47. }

To handle database operations, we will create an object of EmployeeDataAccessLayer class inside the EmployeeController class.

  1. public class EmployeeController : Controller
  2. {
  3. EmployeeDataAccessLayer objemployee = new EmployeeDataAccessLayer();
  4. // GET: /<controller>/
  5. public IActionResult Index()
  6. {
  7. }
  8. }

Para lidar com a lógica de negócios da criação, abra  EmployeeController.cs  e coloque o seguinte código nela.

  1. [HttpGet]
  2. public IActionResult Create()
  3. {
  4. return View();
  5. }
  6. [HttpPost]
  7. [ValidateAntiForgeryToken]
  8. public IActionResult Create([Bind] Employee employee)
  9. {
  10. if (ModelState.IsValid)
  11. {
  12. objemployee.AddEmployee(employee);
  13. return RedirectToAction("Index");
  14. }
  15. return View(employee);
  16. }

TO atributo [Bind] é usado com o parâmetro "employee" para proteger contra overposting. Para saber mais sobre over-posting, visite  aqui

Visualização do índice

Essa visualização exibirá todos os registros de funcionários presentes no banco de dados. Além disso, também forneceremos os métodos de ação Editar, Detalhes e Excluir em cada registro.

Abra  Index.cshtml  e coloque o seguinte código nele

  1. @model IEnumerable<MVCDemoApp.Models.Employee>
  2. @{
  3. ViewData["Title"] = "Index";
  4. }
  5. <h2>Index</h2>
  6. <p>
  7. <a asp-action="Create">Create New</a>
  8. </p>
  9. <table class="table">
  10. <thead>
  11. <tr>
  12. <th>
  13. @Html.DisplayNameFor(model => model.Name)
  14. </th>
  15. <th>
  16. @Html.DisplayNameFor(model => model.Gender)
  17. </th>
  18. <th>
  19. @Html.DisplayNameFor(model => model.Department)
  20. </th>
  21. <th>
  22. @Html.DisplayNameFor(model => model.City)
  23. </th>
  24. <th></th>
  25. </tr>
  26. </thead>
  27. <tbody>
  28. @foreach (var item in Model)
  29. {
  30. <tr>
  31. <td>
  32. @Html.DisplayFor(modelItem => item.Name)
  33. </td>
  34. <td>
  35. @Html.DisplayFor(modelItem => item.Gender)
  36. </td>
  37. <td>
  38. @Html.DisplayFor(modelItem => item.Department)
  39. </td>
  40. <td>
  41. @Html.DisplayFor(modelItem => item.City)
  42. </td>
  43. <td>
  44. <a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
  45. <a asp-action="Details" asp-route-id="@item.ID">Details</a> |
  46. <a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
  47. </td>
  48. </tr>
  49. }
  50. </tbody>
  51. </table>

Para lidar com a lógica de negócios da visualização Index, abra  EmployeeController.cs  e adicione o seguinte código no método Index.

  1. public IActionResult Index()
  2. {
  3. List<Employee> lstEmployee = new List<Employee>();
  4. lstEmployee = objemployee.GetAllEmployees().ToList();
  5. return View(lstEmployee);
  6. }

Editar vista

Essa visão nos permitirá editar os dados de um funcionário existente.

Abra  Edit.cshtml  e coloque o seguinte código nele.

  1. @model MVCDemoApp.Models.Employee
  2. @{
  3. ViewData["Title"] = "Edit";
  4. }
  5. <h2>Edit</h2>
  6. <h4>Employees</h4>
  7. <hr />
  8. <div class="row">
  9. <div class="col-md-4">
  10. <form asp-action="Edit">
  11. <div asp-validation-summary="ModelOnly" class="text-danger"></div>
  12. <input type="hidden" asp-for="ID" />
  13. <div class="form-group">
  14. <label asp-for="Name" class="control-label"></label>
  15. <input asp-for="Name" class="form-control" />
  16. <span asp-validation-for="Name" class="text-danger"></span>
  17. </div>
  18. <div class="form-group">
  19. <label asp-for="Gender" class="control-label"></label>
  20. <select asp-for="Gender" class="form-control">
  21. <option value="">-- Select Gender --</option>
  22. <option value="Male">Male</option>
  23. <option value="Female">Female</option>
  24. </select>
  25. <span asp-validation-for="Gender" class="text-danger"></span>
  26. </div>
  27. <div class="form-group">
  28. <label asp-for="Department" class="control-label"></label>
  29. <input asp-for="Department" class="form-control" />
  30. <span asp-validation-for="Department" class="text-danger"></span>
  31. </div>
  32. <div class="form-group">
  33. <label asp-for="City" class="control-label"></label>
  34. <input asp-for="City" class="form-control" />
  35. <span asp-validation-for="City" class="text-danger"></span>
  36. </div>
  37. <div class="form-group">
  38. <input type="submit" value="Save" class="btn btn-default" />
  39. </div>
  40. </form>
  41. </div>
  42. </div>
  43. <div>
  44. <a asp-action="Index">Back to List</a>
  45. </div>
  46. @section Scripts {
  47. @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
  48. }

Para manipular a lógica de negócios da visualização Editar, abra  EmployeeController.cs  e adicione o seguinte código a ela.

  1. [HttpGet]
  2. public IActionResult Edit(int? id)
  3. {
  4. if (id == null)
  5. {
  6. return NotFound();
  7. }
  8. Employee employee = objemployee.GetEmployeeData(id);
  9. if (employee == null)
  10. {
  11. return NotFound();
  12. }
  13. return View(employee);
  14. }
  15. [HttpPost]
  16. [ValidateAntiForgeryToken]
  17. public IActionResult Edit(int id, [Bind]Employee employee)
  18. {
  19. if (id != employee.ID)
  20. {
  21. return NotFound();
  22. }
  23. if (ModelState.IsValid)
  24. {
  25. objemployee.UpdateEmployee(employee);
  26. return RedirectToAction("Index");
  27. }
  28. return View(employee);
  29. }

Como você pode observar, temos dois métodos de ação Editar, um para o HttpGet e outro para o HttpPost. O método de ação HttpGet Edit buscará os dados do funcionário e preencherá os campos da visualização de edição. Quando o usuário clicar no botão Salvar após a edição do registro, será gerada uma solicitação de Post, que é manipulada pelo método de ação HttpPost Edit.

Visualização de detalhes

Essa visualização exibirá os detalhes de um funcionário específico.

Abra o  Details.cshtml  e coloque o seguinte código nele.

  1. @model MVCDemoApp.Models.Employee
  2. @{
  3. ViewData["Title"] = "Details";
  4. }
  5. <h2>Details</h2>
  6. <div>
  7. <h4>Employees</h4>
  8. <hr />
  9. <dl class="dl-horizontal">
  10. <dt>
  11. @Html.DisplayNameFor(model => model.Name)
  12. </dt>
  13. <dd>
  14. @Html.DisplayFor(model => model.Name)
  15. </dd>
  16. <dt>
  17. @Html.DisplayNameFor(model => model.Gender)
  18. </dt>
  19. <dd>
  20. @Html.DisplayFor(model => model.Gender)
  21. </dd>
  22. <dt>
  23. @Html.DisplayNameFor(model => model.Department)
  24. </dt>
  25. <dd>
  26. @Html.DisplayFor(model => model.Department)
  27. </dd>
  28. <dt>
  29. @Html.DisplayNameFor(model => model.City)
  30. </dt>
  31. <dd>
  32. @Html.DisplayFor(model => model.City)
  33. </dd>
  34. </dl>
  35. </div>
  36. <div>
  37. <a asp-action="Edit" asp-route-id="@Model.ID">Edit</a> |
  38. <a asp-action="Index">Back to List</a>
  39. </div>

Para manipular a lógica de negócios da visualização Detalhes, abra o  EmployeeController.cs  e adicione o código a seguir.

  1. [HttpGet]
  2. public IActionResult Details(int? id)
  3. {
  4. if (id == null)
  5. {
  6. return NotFound();
  7. }
  8. Employee employee = objemployee.GetEmployeeData(id);
  9. if (employee == null)
  10. {
  11. return NotFound();
  12. }
  13. return View(employee);
  14. }

Excluir visualização

Essa visão nos ajudará a remover os dados dos funcionários.

Abra  Delete.cshtml  e coloque o seguinte código nele.

  1. @model MVCDemoApp.Models.Employee
  2. @{
  3. ViewData["Title"] = "Delete";
  4. }
  5. <h2>Delete</h2>
  6. <h3>Are you sure you want to delete this?</h3>
  7. <div>
  8. <h4>Employees</h4>
  9. <hr />
  10. <dl class="dl-horizontal">
  11. <dt>
  12. @Html.DisplayNameFor(model => model.Name)
  13. </dt>
  14. <dd>
  15. @Html.DisplayFor(model => model.Name)
  16. </dd>
  17. <dt>
  18. @Html.DisplayNameFor(model => model.Gender)
  19. </dt>
  20. <dd>
  21. @Html.DisplayFor(model => model.Gender)
  22. </dd>
  23. <dt>
  24. @Html.DisplayNameFor(model => model.Department)
  25. </dt>
  26. <dd>
  27. @Html.DisplayFor(model => model.Department)
  28. </dd>
  29. <dt>
  30. @Html.DisplayNameFor(model => model.City)
  31. </dt>
  32. <dd>
  33. @Html.DisplayFor(model => model.City)
  34. </dd>
  35. </dl>
  36. <form asp-action="Delete">
  37. <input type="hidden" asp-for="ID" />
  38. <input type="submit" value="Delete" class="btn btn-default" /> |
  39. <a asp-action="Index">Back to List</a>
  40. </form>
  41. </div>

Para manipular a lógica de negócios da exibição Excluir, abra  EmployeeController.cs  e adicione o seguinte código a ela.

  1. [HttpGet]
  2. public IActionResult Delete(int? id)
  3. {
  4. if (id == null)
  5. {
  6. return NotFound();
  7. }
  8. Employee employee = objemployee.GetEmployeeData(id);
  9. if (employee == null)
  10. {
  11. return NotFound();
  12. }
  13. return View(employee);
  14. }
  15. [HttpPost, ActionName("Delete")]
  16. [ValidateAntiForgeryToken]
  17. public IActionResult DeleteConfirmed(int? id)
  18. {
  19. objemployee.DeleteEmployee(id);
  20. return RedirectToAction("Index");
  21. }

Para completar a operação Delete, precisamos de dois métodos Delete que aceitem o mesmo parâmetro (Employee Id). Mas dois métodos com o mesmo nome e assinatura de método criarão um erro de tempo de compilação e se renomearmos o método Delete, o roteamento não poderá encontrá-lo como segmentos de URL de mapas asp.net para métodos de ação por nome. Então, para resolver esse problema, colocamos o atributo ActionName ("Delete") no método DeleteConfirmed. Esse atributo executa o mapeamento para o sistema de roteamento para que uma URL que inclua / Delete / para uma solicitação POST encontre o método DeleteConfirmed.

Quando clicamos no link Excluir na página Índice, ele envia uma solicitação Obter e retorna uma Visualização do funcionário usando o método HttpGet Delete. Quando clicamos no botão Excluir nesta visualização, ele enviará uma solicitação Post para excluir o registro que é manipulado pelo método HttpPost DeleteConfirmed. Executar uma operação de exclusão em resposta a uma solicitação Get (ou, nesse caso, executar uma operação de edição, criar operação ou qualquer outra operação que altere dados) abre uma falha de segurança. Por isso, temos dois métodos separados.

E é isso. Criamos nosso primeiro aplicativo da web ASP.NET Core MVC. Antes de lançar o aplicativo, vamos configurar os URLs de rota. Abra o   ficheiro Startup.cs para definir o formato do encaminhamento. Desloque-se para o método app.UseMvc, onde pode definir o URL do percurso. Certifique-se de que o URL do seu percurso está definido desta forma.


  1. app.UseMvc(routes =>
  2. {
  3. routes.MapRoute(
  4. name: "default",
  5. template: "{controller=Home}/{action=Index}/{id?}");
  6. });

Esse padrão de url define o HomeController como controlador padrão e o método Index como método de ação padrão, enquanto o parâmetro Id é opcional. Os parâmetros de rota padrão e opcional não precisam estar presentes no caminho da URL para uma correspondência. Se não anexarmos nenhum nome de controlador na URL, o HomeController assumirá como controlador padrão e o método Index de HomeController como método de ação padrão. Da mesma forma, se acrescentarmos apenas o nome do Controlador na URL, ele navegará para o método de ação Index desse controlador.

Agora pressione F5 para iniciar o aplicativo e navegue até Controlador Employee anexando  / Employee no URL.

Você pode ver a página como mostrado abaixo.

Clique em  CreateNew  para navegar até  Create  view. Adicione um novo registro de funcionário, conforme mostrado na imagem abaixo.

Se perdermos os dados em qualquer campo durante a criação do registro de funcionários, receberemos uma mensagem de erro de validação de campo obrigatória.

Depois de inserir os dados em todos os campos, clique no botão "Criar". O novo registro de funcionário será criado e você será redirecionado para a visão Índice, exibindo registros de todos os funcionários. Aqui, também podemos ver os métodos de ação Editar, Detalhes e Excluir.

Se quisermos editar um registro de funcionário existente, clique no link Editar ação. Ele abrirá a visualização de edição, conforme abaixo, onde podemos alterar os dados do funcionário.

Aqui nós mudamos o departamento de funcionários Swati de Finanças para HR.Clique em “Salvar” para retornar à visualização Índice para ver as alterações atualizadas, conforme destacado na imagem abaixo.

Se perdermos algum campo durante a edição de registros de funcionários, a visualização Editar também exibirá a mensagem de erro de validação de campo obrigatória

Se você quiser ver os detalhes de qualquer funcionário, clique no link de ação Detalhes, que abrirá a visualização Detalhes, como mostra a imagem abaixo.

Clique em “Back to List” para voltar à visualização Index. Agora, vamos executar a operação Excluir em um funcionário chamado Venkat. Clique no link Excluir ação que abrirá a visualização Excluir solicitando uma confirmação para exclusão.

Assim que clicarmos no botão Excluir, ele enviará a solicitação HttpPost para excluir o registro do funcionário e seremos redirecionados para a visualização Índice. Aqui, podemos ver que o funcionário com o nome Venkat foi removido do nosso registro.


Conclusão

Aprendemos sobre como criar um aplicativo da web MVC de amostra com o ASP.Net Core 2.0 usando o ADO.NET e o SQL server. Publique seu feedback valioso na seção de comentários.





Comentários

Deixe um Comentário

Posts Recentes

24/Outubro/2018

Jogos

19/Setembro/2018

CRUD com ASP.NET Core MVC...

18/Setembro/2018

Autenticação usando o...


Onde estamos ? clique no mapaFechar Mapa

Entre em Contato

Escreva para nós, vamos trocar algumas ideias!

Telefone

(24) 9219-6805

24992196805

Email

heitorhog@outlook.com

Localização

Rua Professor João de Deus, 908,Quarteirão Brasileiro Petrópolis RJ