Clean Architecture in ASP.NET Core: DTOs, CRUD Operations, and Project Layout

Elif Güzen — Sat, 05 Apr 2025 19:05:54 +0000

When you first start learning software development, everything can feel overwhelming and confusing.
All the terminology — controllers, HTTP requests, DTOs — might sound like a foreign language.
Trust me, I’ve been there too. I still am learning every day.
But here’s the great part: with every step forward, things start to make sense.
In this article, I want to share my own learning journey and walk you through building a simple yet complete API in ASP.NET Core that covers all essential CRUD operations — Create, Read, Update, and Delete.
By writing this, I reinforce my own learning, and hopefully, I can help you as well if you're on the same path.
Let’s dive in together! 🚀

This image shows the file and folder structure of our project.
Let’s go through each part so you understand how everything connects.

📁 Controllers
Here we manage our API endpoints.
• ClassroomsController.cs → Handles all operations related to classrooms.
• StudentsController.cs → Manages student-related API endpoints.
• TeachersController.cs → Handles API requests for teachers.
Each controller contains CRUD operations for its respective entity.
📁 Data
• AppDbContext.cs → Manages the connection to the database and defines the structure of our tables.
📁 Models > Dtos (Data Transfer Objects)
Our DTOs live here.
DTOs allow us to send clean and secure data to the outside world.
• Classroom > ClassroomDetailDto.cs → Provides detailed class information, including teacher and students.
• Student > StudentDto.cs → Contains student data for external use.
• Teacher > TeacherCreateDto.cs & TeacherDto.cs
o TeacherCreateDto.cs → Model used when creating new teachers.
o TeacherDto.cs → Simplified data for teacher information shared outside.
📁 Models > Entities
These are the database entity models. They represent our actual database tables and work with Entity Framework.
• Classroom.cs → Classroom entity.
• Student.cs → Student entity.
• Teacher.cs → Teacher entity.
Entities are the core data structures in our application.

In short:
• Entities: Actual database models.
• DTOs: Clean, external-facing models for API communication.
• Controllers: Handle incoming API requests.
• AppDbContext: Central class for managing database connections.
This structure keeps our application clean, maintainable, and scalable!

🧩** Why Do We Use DTOs (Data Transfer Objects)?**

Before we continue, let’s talk about DTOs — Data Transfer Objects.
A DTO is a simple object that only contains the data we want to send or receive in our API responses.
But why not just send our full database entity? Here’s why:
• 🚫 Security: Our database entities might include sensitive data (like passwords, internal IDs, or timestamps) that we don’t want to expose to the outside world.
• 🎯 Clarity and Focus: DTOs help us send only the necessary data. Clean and minimal responses improve performance and make APIs easier to use and understand.
• ⚙️ Decoupling: By using DTOs, we create a layer between our internal data models and external responses. This way, if our database structure changes, we won’t break external systems or frontends.
• 📊 Validation and Transformation: DTOs are great for validating input data and transforming it before saving it to the database.
In short:
DTOs keep our APIs clean, secure, and future-proof.
When building real-world applications, this separation between internal data and external output is crucial for maintainability and scalability.

🎯 Why Are CRUD Operations So Important?

First, let's answer this question:
Why do we focus so much on CRUD operations? Where do we use them in real projects?
The answer is simple: Everywhere.
CRUD forms the backbone of data management in almost every application. Let’s see some real-world examples:
• 🎓 Educational Platforms: Add new students (Create), list them (Read), update their info (Update), or remove records (Delete).
• 🛒 E-commerce Websites: Add products (Create), display them to users (Read), update prices or stock (Update), and remove discontinued items (Delete).
• 📰 Content Management Systems (CMS): Publish new articles (Create), read posts (Read), edit them (Update), or delete old content (Delete).

  •   💼 Business Applications: Manage employees, projects, and clients — CRUD is everywhere.

In short: if there’s data, CRUD operations are involved.
Learning CRUD means learning how to build real-world, functional applications.

🧩 Step 1: Setting Up the Controller
The TeachersController class will handle all requests related to teachers.

Explanation:
• [Route("[controller]")]: Automatically sets the route to /teachers.
• AppDbContext context: Injects our database connection.
• ControllerBase: Provides built-in methods like Ok(), NotFound(), etc.

➕ Step 2: Create (POST Request)
Let's add a new teacher:

Line by Line:
• [HttpPost]: Defines a POST endpoint.
• [FromBody]: Parses incoming JSON data.
• ModelState.IsValid: Validates the data.
• We create a new Teacher object and save it to the database.
• CreatedAtAction(): Returns 201 Created with the location of the new resource.
✅ Create is done!

📖 Step 3: Read (GET Requests)

1️) List All Teachers

Explanation:
• We retrieve all teachers from the database.
• Use DTO to return only needed fields.
• Ok() sends a 200 response with the data.
2) Get Teacher by ID

Explanation:
• Get the id from the URL.
• Find(id): Search by primary key.
• Return 404 if not found, otherwise return 200 with data.

✅ Read is done!

✏️ Step 4: Update (PUT Request)
Now let’s update an existing teacher:

Explanation:
• [HttpPut("{id}")]: Defines a PUT endpoint.
• Validate input.
• Find the existing teacher.
• Update the teacher's name and save changes.
• Return updated teacher with 200 response.

✅ Update is done!

🗑️ Step 5: Delete (DELETE Request)
Finally, let’s delete a teacher:

Explanation:
• [HttpDelete("{id}")]: Defines a DELETE endpoint.
• Find the teacher by ID.
• If not found, return 404.
• Remove from the database and save changes.
• NoContent(): Returns 204 No Content to indicate success.

✅ Delete is done!

🚀 Summary
In this article, we built a fully functional CRUD API with ASP.NET Core, and explained every step.
What we learned:
✅ How to set up controllers
✅ POST: Create new records
✅ GET: Read data
✅ PUT: Update existing records
✅ DELETE: Remove records
✅ How to use DTOs for clean and secure data responses
✅ How CRUD operations power real-world applications
And remember...
Don't forget: it might feel difficult at first, but every line of code moves you forward. Keep learning! 🚀

DEV Community: Elif Güzen

Clean Architecture in ASP.NET Core: DTOs, CRUD Operations, and Project Layout