Introduction
Creating a CRUD (Create, Read, Update, Delete) API in ASP.NET Core with a MySQL database is a common scenario in web development. In this article, we'll walk through building a complete ASP.NET Core Web API with a real-world use case. We'll create a model called CSharpCornerArticle
and implement CRUD operations for it using Entity Framework Core with MySQL.
Prerequisites
- Visual Studio or Visual Studio Code (with .NET Core SDK installed)
- MySQL Server and MySQL Workbench (for database setup)
Step 1. Set Up the Project
Open Visual Studio and create a new ASP.NET Core Web API project.
Step 2. Create the Model
In this case, our model will be named CSharpCornerArticle. Create a new class under the "Models" folder.
using System;
Author: Sardar Mudassar Ali Khan
namespace YourProjectName.Models
{
public class CSharpCornerArticle
{
public int Id { get; set; }
public string Title { get; set; }
public string Content { get; set; }
public DateTime PublishedDate { get; set; }
}
}
Step 3. Install Required Packages
You'll need the Entity Framework Core package for MySQL. Install it using the Package Manager Console or the Terminal.
dotnet add package Pomelo.EntityFrameworkCore.MySql
Step 4. Configure MySQL Connection
Open the appsettings.json
file and configure your MySQL connection.
{
"ConnectionStrings": {
"DefaultConnection": "Server=localhost;Database=YourDatabaseName;User=root;Password=YourPassword;"
},
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft": "Warning",
"Microsoft.Hosting.Lifetime": "Information"
}
},
// ...
}
Step 5. Create a Database Context
Create a database context class that inherits from DbContext.
using Microsoft.EntityFrameworkCore;
Author: Sardar Mudassar Ali Khan
namespace YourProjectName.Data
{
public class ApplicationDbContext: DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
{
}
public DbSet<CSharpCornerArticle> CSharpCornerArticles { get; set; }
}
}
Step 6. Configure Dependency Injection
In the Startup.cs
file, configure dependency injection for the ApplicationDbContext.
using Microsoft.EntityFrameworkCore;
using YourProjectName.Data;
Author: Sardar Mudassar Ali Khan
public void ConfigureServices(IServiceCollection services)
{
// ...
services.AddDbContext<ApplicationDbContext>(options =>
options.UseMySql(Configuration.GetConnectionString("DefaultConnection")));
// ...
}
Step 7. Create API Endpoints
Create a controller for CSharpCornerArticle
CRUD operations.
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using YourProjectName.Data;
using YourProjectName.Models;
Author: Sardar Mudassar Ali khan
namespace YourProjectName.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class CSharpCornerArticlesController : ControllerBase
{
private readonly ApplicationDbContext _context;
public CSharpCornerArticlesController(ApplicationDbContext context)
{
_context = context;
}
[HttpGet]
public async Task<ActionResult<IEnumerable<CSharpCornerArticle>>> GetCSharpCornerArticles()
{
return await _context.CSharpCornerArticles.ToListAsync();
}
[HttpGet("{id}")]
public async Task<ActionResult<CSharpCornerArticle>> GetCSharpCornerArticle(int id)
{
var article = await _context.CSharpCornerArticles.FindAsync(id);
if (article == null)
{
return NotFound();
}
return article;
}
[HttpPost]
public async Task<ActionResult<CSharpCornerArticle>> PostCSharpCornerArticle(CSharpCornerArticle article)
{
_context.CSharpCornerArticles.Add(article);
await _context.SaveChangesAsync();
return CreatedAtAction("GetCSharpCornerArticle", new { id = article.Id }, article);
}
[HttpPut("{id}")]
public async Task<IActionResult> PutCSharpCornerArticle(int id, CSharpCornerArticle article)
{
if (id != article.Id)
{
return BadRequest();
}
_context.Entry(article).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CSharpCornerArticleExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return NoContent();
}
[HttpDelete("{id}")]
public async Task<IActionResult> DeleteCSharpCornerArticle(int id)
{
var article = await _context.CSharpCornerArticles.FindAsync(id);
if (article == null)
{
return NotFound();
}
_context.CSharpCornerArticles.Remove(article);
await _context.SaveChangesAsync();
return NoContent();
}
private bool CSharpCornerArticleExists(int id)
{
return _context.CSharpCornerArticles.Any(e => e.Id == id);
}
}
}
Step 8. Run Migrations
In the Package Manager Console or Terminal, run the following command to create the database and tables.
dotnet ef migrations add InitialCreate
dotnet ef database update
Step 9. Test the API
You can now test your API using tools like Postman or Swagger.
- Create: Send a POST request to /api/CSharpCornerArticles with JSON data.
- Read: Send a GET request to /api/CSharpCornerArticles to retrieve all articles or /api/CSharpCornerArticles/{id} to get a specific article.
- Update: Send a PUT request to /api/CSharpCornerArticles/{id} with JSON data.
- Delete: Send a DELETE request to /api/CSharpCornerArticles/{id}.
That's it! You've created a complete ASP.NET Core Web API for CRUD operations with a MySQL database using Entity Framework Core. You can now integrate this API into your front-end application or any other client.