Building a RESTful .NET Core Web API with CRUD Operations using Entity Framework

RESTful APIs (Application Programming Interfaces) are the backbone of modern web applications. They offer a well-defined architectural style for clean communication between clients and servers. This blog post dives into creating a CRUD (Create, Read, Update, Delete) operation API using ASP.NET Core Web API and Entity Framework Core for data access.

Prerequisites:

• Visual Studio (or any other .NET-compatible IDE)
• Basic understanding of C#, .NET concepts, and SQL databases
• Entity Framework Core knowledge (helpful but not mandatory)

Setting Up the Project:

1. Open your IDE and create a new ASP.NET Core Web API project.
2. Choose a suitable project name and location.
3. Select the target framework version (e.g., .NET 6.0).
4. During project creation, install the following NuGet packages:
   • Microsoft.EntityFrameworkCore.SqlServer (or your preferred database provider)
   • Microsoft.EntityFrameworkCore.Tools

Defining the Model:

Our API will manage products. Let's create a model class named Product:

public class Product
{
  public int Id { get; set; }
  public string Name { get; set; }
  public string Description { get; set; }
  public decimal Price { get; set; }
}

Database Context:

Entity Framework Core uses a DbContext class to interact with the database. Create a new class named ProductContext inheriting from DbContext:

public class ProductContext : DbContext
{
  public ProductContext(DbContextOptions<ProductContext> options) : base(options) { }

  public DbSet<Product> Products { get; set; }
}

This class defines a Products DbSet property represents a table in the database. The constructor injects the DbContext options used for database configuration.

Database Migration (Optional):

You can use Entity Framework Core migrations to create the database schema if you don't have an existing database. In the Package Manager Console, run the following commands:

Add-Migration InitialCreate
Update-Database

This creates a migration file and applies it to your database, creating the tables based on your model definitions.

Dependency Injection:

In the Startup.cs file, register the ProductContext service in the dependency injection container:

public void ConfigureServices(IServiceCollection services)
{
  // ... other service registrations

  services.AddDbContext<ProductContext>(options =>
  {
    options.UseSqlServer(@"Connection string to your SQL Server database");
  });

  services.AddControllers();
}

Replace the placeholder with your actual SQL Server connection string.

Creating the Controller:

The controller class handles incoming HTTP requests for our API endpoints. Let's create a ProductsController:

[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
  private readonly ProductContext _context;

  public ProductsController(ProductContext context)
  {
    _context = context;
  }

  // ... (Controller methods will be defined here)
}

The controller is injected with the ProductContext instance through dependency injection.

Implementing CRUD Operations with Entity Framework:

Now, let's define methods within the controller class for each CRUD operation, leveraging Entity Framework Core for data access:

• Create (POST):

[HttpPost]
public async Task<IActionResult> CreateProduct(Product product)
{
  _context.Products.Add(product);
  await _context.SaveChangesAsync();

  return CreatedAtRoute("GetProduct", new { id = product.Id }, product);
}

This method adds the new product to the Products DbSet and saves the changes to the database using SaveChangesAsync. It then returns a Created response with the newly created product details and location.

• Read (GET):

• Get all products:

[HttpGet]
public async Task<IActionResult> GetProducts()
{
  return Ok(await _context.Products.ToListAsync());
}

This method retrieves all products from the database using ToListAsync and returns them as an Ok response.

• Get a specific product by ID:

[HttpGet("{id}")]
public async Task<IActionResult> GetProduct(int id)
{
  var product = await _context.Products.FindAsync(id);
  if (product == null)
  {
    return NotFound();
  }
  return Ok(product);
}

This method retrieves the data of the product which ID is passed using FindAsync Method.

• Update (PUT):

[HttpPut("{id}")]
public async Task<IActionResult> UpdateProduct(int id, Product product)
{
  if (id != product.Id)
  {
    return BadRequest();
  }

  _context.Products.Update(product);
  await _context.SaveChangesAsync();

  return NoContent();
}

This method checks if the ID in the URL matches the ID in the product object. It then updates the existing product in the database context and saves the changes. A successful update returns a NoContent response.

• Delete (DELETE):

[HttpDelete("{id}")]
public async Task<IActionResult> DeleteProduct(int id)
{
  var product = await _context.Products.FindAsync(id);
  if (product == null)
  {
    return NotFound();
  }

  _context.Products.Remove(product);
  await _context.SaveChangesAsync();

  return NoContent();
}

This method finds the product by ID. If found, it removes it from the database context and saves the changes. A successful deletion returns a NoContent response.

Error Handling:

It's crucial to implement proper error handling in your API. You can use appropriate HTTP status codes (e.g., BadRequest for invalid requests, and InternalServerError for unexpected errors) to communicate errors to the client. Consider using exception filters to centralize error-handling logic.

Consuming the API:

Clients (web applications, mobile apps, etc.) can interact with your API using tools like Postman. Here's a simple GET request to retrieve all products:

GET http://localhost:5000/api/products

The response will be a JSON array containing all product details.

Deployment Considerations:

For production deployment, you'll need to publish your API to a web server like IIS or Azure App Service. Configure the database connection string to point to your production database.

Conclusion:

Building RESTful APIs with ASP.NET Core Web API and Entity Framework Core provides a robust and scalable approach for managing data in your web applications. This blog post has given you a foundation for creating CRUD operations in your API. Remember to explore advanced features like security, validation, and authorization for a production-ready API.

And Keep Learning till the Next Time

Assalamualaikum - Allahuma Barik

Peace Out✌️