Real-World Example: Building a Simple Blog with Dapper in .NET Core

Real-World Example: Building a Simple Blog with Dapper in .NET Core

Dapper is a lightweight and high-performance micro-ORM that provides direct SQL execution while still offering powerful object mapping capabilities. In this article, we'll build a simple blog application that demonstrates CRUD operations on articles using Dapper for data access.

🚀 Project Setup

1. Create a .NET Core Web API Project

dotnet new webapi -n DapperBlogApp
cd DapperBlogApp

2. Install Required Packages

dotnet add package Dapper
dotnet add package System.Data.SqlClient

3. Set Up the Database

CREATE TABLE Articles (
    Id INT PRIMARY KEY IDENTITY,
    Title NVARCHAR(200) NOT NULL,
    Content NVARCHAR(MAX) NOT NULL,
    Author NVARCHAR(100) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE()
);

📦 Building the Data Access Layer with Dapper

1. Define the Article Model

public class Article
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public string Author { get; set; }
    public DateTime CreatedAt { get; set; }
}

2. Implement the Repository Pattern

using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using Dapper;

public class ArticleRepository
{
    private readonly string _connectionString;

    public ArticleRepository(string connectionString)
    {
        _connectionString = connectionString;
    }

    public IEnumerable<Article> GetAll()
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            return connection.Query<Article>("SELECT * FROM Articles");
        }
    }

    public Article GetById(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            return connection.QuerySingleOrDefault<Article>(
                "SELECT * FROM Articles WHERE Id = @Id",
                new { Id = id });
        }
    }

    public void Create(Article article)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var sql = "INSERT INTO Articles (Title, Content, Author) VALUES (@Title, @Content, @Author)";
            connection.Execute(sql, article);
        }
    }

    public void Update(Article article)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var sql = "UPDATE Articles SET Title = @Title, Content = @Content, Author = @Author WHERE Id = @Id";
            connection.Execute(sql, article);
        }
    }

    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            connection.Execute("DELETE FROM Articles WHERE Id = @Id", new { Id = id });
        }
    }
}

🌐 Building the API Controller

1. Implement the Article Controller

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

[ApiController]
[Route("api/[controller]")]
public class ArticlesController : ControllerBase
{
    private readonly ArticleRepository _repository;

    public ArticlesController(ArticleRepository repository)
    {
        _repository = repository;
    }

    [HttpGet]
    public ActionResult<IEnumerable<Article>> Get()
    {
        return Ok(_repository.GetAll());
    }

    [HttpGet("{id}")]
    public ActionResult<Article> Get(int id)
    {
        var article = _repository.GetById(id);
        if (article == null) return NotFound();
        return Ok(article);
    }

    [HttpPost]
    public IActionResult Create(Article article)
    {
        _repository.Create(article);
        return Created("", article);
    }

    [HttpPut("{id}")]
    public IActionResult Update(int id, Article article)
    {
        var existingArticle = _repository.GetById(id);
        if (existingArticle == null) return NotFound();

        article.Id = id;
        _repository.Update(article);
        return NoContent();
    }

    [HttpDelete("{id}")]
    public IActionResult Delete(int id)
    {
        _repository.Delete(id);
        return NoContent();
    }
}

⚙️ Configuring Dependency Injection

Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddSingleton(new ArticleRepository(connectionString));

var app = builder.Build();

app.UseAuthorization();
app.MapControllers();
app.Run();

appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=YOUR_SERVER;Database=YOUR_DB;User Id=YOUR_USER;Password=YOUR_PASSWORD;"
  }
}

🧪 Testing the Blog API

  • Create Article: POST /api/articles
  • Get All Articles: GET /api/articles
  • Get by ID: GET /api/articles/1
  • Update: PUT /api/articles/1
  • Delete: DELETE /api/articles/1
{
  "title": "Getting Started with Dapper",
  "content": "Dapper is a fast and efficient micro-ORM...",
  "author": "John Doe"
}

✅ Conclusion

This article demonstrated how to build a simple blog application using Dapper in .NET Core. We structured our application with a repository pattern, created a RESTful API, and optimized database interactions using Dapper’s high-performance capabilities.

Comments

Post a Comment

Popular posts from this blog

Debouncing & Throttling in RxJS: Optimizing API Calls and User Interactions

RxJS Debounce vs Throttle in Angular – Best Practices & Examples What is RxJS — quick primer RxJS (Reactive Extensions for JavaScript) provides Observables and operators to model and manipulate streams of asynchronous events — from keystrokes and HTTP requests to timers and WebSocket messages. 💡 Why this matters: Operators like debounceTime and throttleTime help you control event frequency, reducing wasted CPU and network work while improving UX. 1. Debouncing — emit after silence Debouncing delays emitting a value until a specified period of inactivity. It's best for typeahead inputs where only the final value after the user stops typing is relevant. Live search example (production-ready) // search.component.ts import { Component, OnDestroy } from '@angular/core'; import { FormControl } from '@angular/forms'; import { Subject } from 'rxjs'; import { debounc...
Read more

Promises in Angular

🚀 Promises in Angular – The Complete Beginner’s Guide (with Examples) 📘 Introduction In modern Angular development, handling asynchronous operations is essential. Whether you're fetching data from an API, loading files, or wrapping browser-native APIs, Promises offer a clean and readable way to deal with one-time asynchronous operations. This guide explains: What Promises are How they compare with Observables Real-world examples using .then() and async/await When to use Promises vs Observables in Angular 📚 Table of Contents 🔍 What is a Promise? 🔁 Promise Lifecycle ✨ Key Features 📌 Syntax 💻 Example 1: Fetch 💻 Example 2: setTimeout 📊 Promises vs Observables 🎯 When to Use Promises 📦 Angular Service Example 🔄 Observable vs Promise ❓ FAQ ✅ Summary 🔍 What is a Promise? A Promise is a JavaScript object that represents the eventual success (fulfilled) or failure (rejected) of an asynchronous operation. 📌 Com...
Read more

Comprehensive Guide to C# and .NET Core OOP Concepts and Language Features

Comprehensive Guide to C# and .NET Core OOP Concepts Class A class is a blueprint for creating objects that encapsulate both data and behavior. Access Modifiers : public, internal, abstract, sealed control visibility and inheritance. Static Classes : Cannot be instantiated, contain only static members. Partial Classes : Split across files using partial keyword for better organization. public class Car { public string Model; public void Drive() => Console.WriteLine($"{Model} is driving."); } Analogy: A car blueprint used to build many actual cars. Benefits: Reusability, Encapsulation, Abstraction, Inheritance Object An object is an instance of a class. Managed by Garbage Collector for automatic memory cleanup. Boxing/Unboxing allows value types to be treated a...
Read more