Embarking on a journey into ASP.NET Core and Entity Framework? The CRUD operationsโCreate, Read, Update, and Deleteโare the fundamentals of interacting with a database in your application. This comprehensive guide walks you through a practical example of implementing CRUD operations using ASP.NET Core and Entity Framework Code First.
Before we dive into the nitty-gritty, let's ensure you have both ASP.NET Core and Entity Framework Core installed in your environment. If you're using the .NET Core CLI, you can add the necessary packages to your project using the following commands:
Getting Started: Setup and Project Configuration
The first step is to create a new ASP.NET Core MVC project and install the required packages. In the terminal, run:
```bash dotnet new mvc -n CrudExample cd CrudExample dotnet add package Microsoft.EntityFrameworkCore.SqlServer dotnet add package Microsoft.EntityFrameworkCore Designer ```
These commands create a new MVC project called "CrudExample" and add the necessary Entity Framework Core packages. Now, let's set up our Model class and DbContext.
Creating the Model Class
For this example, we'll use a simple `Student` model. Create a new class named `Student.cs` in the `Models` folder.
```csharp namespace CrudExample.Models { public class Student { public int Id { get; set; } public string Name { get; set; } public string Major { get; set; } } } ```
Setting Up DbContext
Next, create a new class named `ApplicationDbContext.cs` in the `Data` folder. This class will inherit from `DbContext` and contain a `DbSet` property for our `Student` model.
```csharp
using CrudExample.Models;
using Microsoft.EntityFrameworkCore;
namespace CrudExample.Data
{
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions Now that we have our model and DbContext set up, let's configure the database connection in the `Startup.cs` file.
Database Configuration and Migrations
Open the `Startup.cs` file and locate the `ConfigureServices` method. Here, we'll configure the database connection and enable Entity Framework Core to use migrations.
First, add the following using directive at the top of the file:
```csharp using CrudExample.Data; using Microsoft.EntityFrameworkCore; ```
Then, modify the `ConfigureServices` method as follows:
```csharp
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext Make sure to replace the connection string with your actual database connection string in the `appsettings.json` file. Now, let's create a migration and update the database.
Using Migrations to Create the Database Schema
In the terminal, navigate to your project directory and run the following commands to create and apply migrations:
```bash dotnet ef migrations add InitialCreate dotnet ef database update ```
These commands create a new migration with the name "InitialCreate" and update the database based on the migrations previously created. Now we have our database schema ready for CRUD operations.
Implementing CRUD Operations
ASP.NET Core provides built-in scaffolding for CRUD operations using Controllers. We'll use this feature to generate the CRUD controllers for our `Student` model. In the terminal, run:
```bash dotnet aspnet-codegenerator controller -m Student -dc ApplicationDbContext -udl -n StudentsController ```
This command generates a CRUD controller for the `Student` model using the `ApplicationDbContext` as the data context. Let's explore each CRUD operation in the generated `StudentsController.cs` file.
Create: Adding a New Student
The `Create` action in the controller is responsible for handling the creation of a new `Student`. The action receives a `Student` object as a model, populates the view with the object, and handles the POST request to insert the new student into the database.
To test the creation of a new student, run your application and navigate to the "Students" > "Create" page. Fill in the required fields and submit the form to see the new student added to the database.
Read: Displaying List of Students
The `Index` action in the controller retrieves a list of `Student` objects from the database and passes it to the view for rendering. You can see this in action by navigating to the "Students" > "Index" page in your running application.
The view also includes a search box that filters the list of students based on the entered name. This is an example of how to implement sorting and filtering functionality in your ASP.NET Core application.
Update: Editing an Existing Student
The `Edit` action in the controller enables editing of an existing `Student`. The action retrieves the student data from the database, populates the view with the data, and handles the POST request to update the student in the database.
To test the editing functionality, run your application, navigate to the "Students" > "Index" page, and click on the "Edit" link next to any student. Fill in the updated information and submit the form to see the changes saved in the database.
Delete: Removing a Student
The `Delete` action in the controller handles the removal of a `Student` from the database. The action receives the student ID as a parameter, retrieves the student data from the database, passes it to the view for confirmation, and handles the POST request to delete the student.
To test the deletion functionality, run your application, navigate to the "Students" > "Index" page, and click on the "Delete" link next to any student. Confirm the deletion and refresh the index page to see the student removed from the list.
Congratulations! You've successfully implemented CRUD operations using ASP.NET Core and Entity Framework Code First. This hands-on example covers the basic CRUD functionality, but keep in mind that real-world applications may require more advanced features, such as security, validation, and error handling.
Embrace the power of ASP.NET Core and Entity Framework Core to build efficient, data-driven web applications. Happy coding!