.NET EF Core Tutorial: Build a REST API in 3 Steps 2025

dotnet new webapi -n ProductApi

cd ProductApi

dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Design

public class Product
{
    public int Id { get; set; }
    public required string Name { get; set; }
    public decimal Price { get; set; }
    public DateTime CreatedDate { get; set; }
}

using Microsoft.EntityFrameworkCore;

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

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

Open your Program.cs file and add the following lines right after the var builder = WebApplication.CreateBuilder(args); line:

// Add this using statement at the top of Program.cs
using Microsoft.EntityFrameworkCore;

// Add the DbContext to the services container.
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection") ?? "Data Source=products.db";

builder.Services.AddDbContext<ApiDbContext>(options =>
    options.UseSqlite(connectionString));

This code tells the application to use our ApiDbContext and configure it to connect to a SQLite database file named products.db. If a connection string named "DefaultConnection" exists in our configuration (like appsettings.json), it will use that instead.

Step 2: Creating the Database with Migrations

We've defined our data model in C#, but how does the actual database get created? That's where EF Core Migrations come in. Migrations translate your C# models into SQL scripts that create or update your database schema.

In your terminal, run the following command:

dotnet ef migrations add InitialCreate

This command inspects your DbContext and models, compares them to the last migration (there isn't one yet), and generates the C# code necessary to create the database schema. You'll see a new Migrations folder appear in your project.

Now, apply this migration to the database:

dotnet ef database update

This command executes the migration, creating the products.db file and the Products table inside it. Just like that, your database is ready!

Step 3: Building the API Endpoints

With our database ready, it's time for the main event: creating the API endpoints. We'll use .NET 8's Minimal APIs, which are clean, fast, and perfect for this task. We'll add endpoints for all the basic CRUD operations at the bottom of Program.cs, right before app.Run();.

First, let's define a group for our product endpoints to keep things organized.

var productsGroup = app.MapGroup("/products");

GET /products - Fetch All Products

This endpoint will return a list of all products in the database.

productsGroup.MapGet("/", async (ApiDbContext db) =>
    await db.Products.ToListAsync());

GET /products/{id} - Fetch a Single Product

This endpoint retrieves a specific product by its ID. If the product isn't found, it returns a 404 Not Found status.

productsGroup.MapGet("/{id}", async (int id, ApiDbContext db) =>
    await db.Products.FindAsync(id)
        is Product product
            ? Results.Ok(product)
            : Results.NotFound());

POST /products - Create a New Product

This endpoint accepts a new product in the request body, adds it to the database, and returns the newly created product with a 201 Created status.

productsGroup.MapPost("/", async (Product product, ApiDbContext db) =>
{
    product.CreatedDate = DateTime.UtcNow;
    db.Products.Add(product);
    await db.SaveChangesAsync();

    return Results.Created($"/products/{product.Id}", product);
});

PUT /products/{id} - Update an Existing Product

This endpoint updates an existing product. It finds the product by ID, updates its properties, and saves the changes.

productsGroup.MapPut("/{id}", async (int id, Product inputProduct, ApiDbContext db) =>
{
    var product = await db.Products.FindAsync(id);

    if (product is null) return Results.NotFound();

    product.Name = inputProduct.Name;
    product.Price = inputProduct.Price;

    await db.SaveChangesAsync();

    return Results.NoContent();
});

DELETE /products/{id} - Delete a Product

Finally, this endpoint removes a product from the database.

productsGroup.MapDelete("/{id}", async (int id, ApiDbContext db) =>
{
    if (await db.Products.FindAsync(id) is Product product)
    {
        db.Products.Remove(product);
        await db.SaveChangesAsync();
        return Results.Ok(product);
    }

    return Results.NotFound();
});

Putting It All to the Test

Your API is now complete! The easiest way to test it is by running the application:

dotnet run

Now, open your browser and navigate to the URL provided in the console, adding /swagger to the end (e.g., https://localhost:7123/swagger). You'll see the beautiful Swagger UI, which documents and lets you test your API endpoints directly.

Try it out!

1. Expand the POST /products endpoint, click "Try it out", fill in a name and price, and click "Execute". You should get a 201 response.
2. Now, expand the GET /products endpoint, click "Try it out", and "Execute". You'll see the product you just created in the response!

From Zero to API Hero

And there you have it! In just three steps, you've built a modern, high-performance REST API using .NET 8 and Entity Framework Core. You've set up a project, modeled your data, created a database schema with migrations, and implemented a full set of CRUD endpoints.

This simple but powerful foundation is the starting point for almost any backend application. From here, you could explore:

• Validation: Using libraries like FluentValidation to validate incoming data.
• Repository Pattern: Abstracting your data access logic for better testability.
• Authentication & Authorization: Securing your endpoints with JWTs.
• Docker: Containerizing your new API for easy deployment.

Happy coding!