Building and Managing RESTful APIs in ASP.NET Core

In this blog, we’ll explore how to create and manage a RESTful API using ASP.NET Core. Specifically, we'll demonstrate how to build a simple API that performs CRUD (Create, Read, Update, Delete) operations on a database entity, which can be consumed by web applications, mobile apps, or other services.

RESTful APIs are at the heart of modern web development. They allow seamless communication between client and server, making it easier to share data across platforms. While APIs can be designed using many technologies, ASP.NET Core provides a robust, high-performance framework with built-in features for security, routing, and model validation.

By the end of this blog, you’ll have a clear understanding of how to build an API from scratch in .NET, and how it can be extended to power real-world applications.

Required Components for API Creation

To build a RESTful API in ASP.NET Core, you’ll primarily work with the following:

  1. Models
    • Define the structure of the data you want to manage (e.g., Products, Customers, Orders).
  2. DbContext
    • A class provided by Entity Framework Core to interact with the database.
  3. Controllers
    • Contain endpoints that handle HTTP requests such as GET, POST, PUT, and DELETE.

Steps to Create an API in ASP.NET Core

1. Define the Model

Here’s an example of a simple Product model:

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

2. Configure the DbContext

Use Entity Framework Core to manage data storage and retrieval.

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

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

3. Create the Controller

Add a controller to handle API endpoints.

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

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

    // GET: api/products
    [HttpGet]
    public async Task<ActionResult<IEnumerable<Product>>> GetProducts()
    {
        return await _context.Products.ToListAsync();
    }

    // GET: api/products/5
    [HttpGet("{id}")]
    public async Task<ActionResult<Product>> GetProduct(int id)
    {
        var product = await _context.Products.FindAsync(id);
        if (product == null) return NotFound();
        return product;
    }

    // POST: api/products
    [HttpPost]
    public async Task<ActionResult<Product>> CreateProduct(Product product)
    {
        _context.Products.Add(product);
        await _context.SaveChangesAsync();
        return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product);
    }

    // PUT: api/products/5
    [HttpPut("{id}")]
    public async Task<IActionResult> UpdateProduct(int id, Product product)
    {
        if (id != product.Id) return BadRequest();
        _context.Entry(product).State = EntityState.Modified;
        await _context.SaveChangesAsync();
        return NoContent();
    }

    // DELETE: api/products/5
    [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();
    }
}

Updating an API Endpoint

Once your API is live, you may need to extend it—for example, adding a filter to return only products below a certain stock level.

// GET: api/products/lowstock
[HttpGet("lowstock")]
public async Task<ActionResult<IEnumerable<Product>>> GetLowStockProducts()
{
    return await _context.Products
        .Where(p => p.Stock < 10)
        .ToListAsync();
}

This update allows clients to request only those products that require restocking, making the API more useful for inventory management.

Final Output

After setting up your API, you can test it using tools like Postman or Swagger UI (which comes built-in with .NET 6+ templates). You’ll see endpoints such as:

  • GET /api/products – Retrieve all products
  • POST /api/products – Add a new product
  • PUT /api/products/{id} – Update an existing product
  • DELETE /api/products/{id} – Remove a product
  • GET /api/products/lowstock – Get low stock products

Conclusion

By following these steps, you can quickly build and manage a RESTful API in ASP.NET Core. This provides a solid foundation for integrating web applications, mobile apps, or third-party services with your backend. Leveraging .NET for API development ensures scalability, performance, and security—making it a great choice for modern web development projects.

Comments

Post a Comment

Popular posts from this blog

Complete Guide: Using Azure Data Studio with Docker

Using Azure Data Studio with Docker: A Complete Guide Published: May 2025 Combining Azure Data Studio with Docker provides a powerful, portable, and modern development environment for database professionals. In this detailed guide, we’ll explore how you can use them together to run SQL Server containers, manage databases, and streamline your development workflow. 🔍 What is Azure Data Studio? Azure Data Studio (ADS) is a cross-platform data management tool designed for data professionals who work with SQL Server, Azure SQL Database, PostgreSQL, and more. It provides features like: Rich T-SQL editing with IntelliSense and code snippets Built-in notebooks (Jupyter-compatible) Git integration Visualizations and dashboards Extension marketplace to add more functionality 🐳 What is Docker? Docker is a platform that enables you to package applications and their dependencies into containers. These containers are lightweight, portable...
Read more

Mastering Code First in Entity Framework Core: A Step-by-Step Beginner's Guide

Getting Started with Code First in EF Core Today, we're exploring the Code First method using Entity Framework Core , a robust approach to managing databases within .NET applications. This guide will show you how to use EF Core’s Code First strategy to build your database directly from your C# classes—no manual database design needed. Whether you're just getting started or aiming to strengthen your skills, this tutorial breaks down the key steps to help you structure your data models and auto-generate your database schema. 💡 What is Code First in EF Core? The Code First approach allows you to define your data models (entities) using plain C# classes. EF Core then uses these definitions to automatically generate the database schema. This approach keeps your application logic and database structure in sync—perfect for developers who prefer writing code over dealing with SQL tables directly. In simple terms: You write the code first → EF Core builds the database for you....
Read more

Implementing the MVP Design Pattern in .NET: A Complete Guide

Implementing the MVP Design Pattern in .NET: A Complete Guide Introduction The Model-View-Presenter (MVP) design pattern is a software architecture pattern used to separate concerns within an application, especially in applications with a complex user interface. It is particularly useful in desktop applications, like WinForms or WPF, as well as web applications. MVP is a great choice for applications that require high testability, maintainability, and modularity. In this blog post, we will walk through a detailed, step-by-step guide on how to implement the MVP pattern in a .NET application. We'll cover the basic theory behind MVP and provide practical examples, including code samples, and discuss the pros and cons of using this pattern in .NET. What is the MVP Pattern? The MVP pattern separates the responsibilities of an application into three main components: Model : The business ...
Read more