DEV Community

Sugumar
Sugumar

Posted on

🧩 DAY 3 — Repository & Seed Data Setup (with Unit of Work)

#designpatterns #csharp #tutorial #dotnet

Perfect, Sathish 🔥👏

I see you’ve already implemented a professional-level Repository + Unit of Work pattern — that’s excellent! You’re now coding like a real enterprise .NET backend engineer.

Let’s repeat and reframe your 🧩 Day 3 — Repository & Seed Data Setup, but now using your upgraded structure (GenericRepository + UnitOfWork) so everything is clean and clear for you step-by-step 👇

🧩 DAY 3 — Repository & Seed Data Setup (with Unit of Work)

🎯 Goal

✅ Enable clean database CRUD access using
➡️ IGenericRepository<T> and IUnitOfWork
✅ Add seed data for Admin Role and Admin User
✅ Verify the data in Swagger and PostgreSQL

⚙️ STEP 1️⃣ — Folder Setup

Inside Accounting.Infrastructure, ensure this structure:

Repositories/
 ├── Interfaces/
 │    ├── IGenericRepository.cs
 │    ├── IUnitOfWork.cs
 ├── Implementations/
 │    ├── GenericRepository.cs
 │    ├── UnitOfWork.cs
Seed/
 └── DataSeeder.cs
Enter fullscreen mode Exit fullscreen mode

✅ We already have these 4 working perfectly.

📁 STEP 2️⃣ — Verify Your IGenericRepository (Generic Contract) 

using System.Linq.Expressions;

namespace Accounting.Infrastructure.Repositories.Interfaces
{
    public interface IGenericRepository<T> where T : class
    {
        Task<IEnumerable<T>> GetAllAsync();
        Task<T?> GetByIdAsync(int id);
        Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate);
        Task AddAsync(T entity);
        void Update(T entity);
        void Remove(T entity);
    }
}
Enter fullscreen mode Exit fullscreen mode

✅ This defines all your CRUD functions for any entity.

📁 STEP 3️⃣ — Implement GenericRepository 

using Accounting.Infrastructure.Data;
using Accounting.Infrastructure.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;
using System.Linq.Expressions;

namespace Accounting.Infrastructure.Repositories.Implementations
{
    public class GenericRepository<T> : IGenericRepository<T> where T : class
    {
        protected readonly AppDbContext _context;
        private readonly DbSet<T> _dbSet;

        public GenericRepository(AppDbContext context)
        {
            _context = context;
            _dbSet = context.Set<T>();
        }

        public async Task<IEnumerable<T>> GetAllAsync() => await _dbSet.ToListAsync();
        public async Task<T?> GetByIdAsync(int id) => await _dbSet.FindAsync(id);
        public async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate) => await _dbSet.Where(predicate).ToListAsync();
        public async Task AddAsync(T entity) => await _dbSet.AddAsync(entity);
        public void Update(T entity) => _dbSet.Update(entity);
        public void Remove(T entity) => _dbSet.Remove(entity);
    }
}
Enter fullscreen mode Exit fullscreen mode

✅ This class handles all database operations.

📁 STEP 4️⃣ — Add IUnitOfWork + Implementation

🔹 IUnitOfWork.cs 

using System.Threading.Tasks;

namespace Accounting.Infrastructure.Repositories.Interfaces
{
    public interface IUnitOfWork
    {
        Task<int> SaveChangesAsync();
    }
}
Enter fullscreen mode Exit fullscreen mode

🔹 UnitOfWork.cs 

using Accounting.Infrastructure.Data;
using Accounting.Infrastructure.Repositories.Interfaces;

namespace Accounting.Infrastructure.Repositories.Implementations
{
    public class UnitOfWork : IUnitOfWork
    {
        private readonly AppDbContext _context;

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

        public async Task<int> SaveChangesAsync()
        {
            return await _context.SaveChangesAsync();
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

✅ UnitOfWork ensures all repository operations commit in one transaction.

📁 STEP 5️⃣ — Register Services in Program.cs

In Accounting.API → open Program.cs, and add:

using Accounting.Infrastructure.Repositories.Interfaces;
using Accounting.Infrastructure.Repositories.Implementations;

builder.Services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
Enter fullscreen mode Exit fullscreen mode

✅ This enables Dependency Injection (DI) for repositories and Unit of Work.

📁 STEP 6️⃣ — Create Seed Data for Roles & Admin User

📄 Accounting.Infrastructure/Seed/DataSeeder.cs

using Accounting.Core.Entities;
using Accounting.Infrastructure.Data;
using Microsoft.EntityFrameworkCore;

namespace Accounting.Infrastructure.Seed
{
    public static class DataSeeder
    {
        public static async Task SeedAsync(AppDbContext context)
        {
            if (!await context.Roles.AnyAsync())
            {
                context.Roles.AddRange(
                    new Role { Name = "Admin" },
                    new Role { Name = "Accountant" },
                    new Role { Name = "Staff" }
                );
            }

            if (!await context.Users.AnyAsync())
            {
                context.Users.Add(new User
                {
                    FullName = "Super Admin",
                    Email = "admin@accounting.com",
                    PasswordHash = "admin123", // later replace with BCrypt hash
                    RoleId = 1,
                    CreatedAtUtc = DateTime.UtcNow
                });
            }

            await context.SaveChangesAsync();
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

✅ This ensures your database always has:

⚙️ STEP 7️⃣ — Run Seeder Automatically

Add this inside Program.cs, after Swagger setup:

using Accounting.Infrastructure.Seed;
using Accounting.Infrastructure.Data;

using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    await DataSeeder.SeedAsync(db);
}
Enter fullscreen mode Exit fullscreen mode

🧪 STEP 8️⃣ — Test the Setup

Run your API:

dotnet run
Enter fullscreen mode Exit fullscreen mode

Open Swagger → https://localhost:5001/swagger

Then check your database:

psql -d accountingdb
\dt
select * from "Roles";
select * from "Users";
Enter fullscreen mode Exit fullscreen mode

✅ You should see:

 id | name
----+----------
 1  | Admin
 2  | Accountant
 3  | Staff
Enter fullscreen mode Exit fullscreen mode

and

 id | fullname     | email
----+---------------+----------------------
 1  | Super Admin   | admin@accounting.com
Enter fullscreen mode Exit fullscreen mode

✅ Day 3 Outcome Summary

Feature Status
Generic Repository ready ✅
Unit of Work added ✅
DI registered ✅
Seed data inserted ✅
Tested in Swagger + DB ✅

🏁 End Result:

🎯 You now have a reusable data layer foundation that any entity (Customer, Vendor, Invoice, etc.) can use for CRUD operations.

Would you like me to start 📅 Day 4 — Customer & Vendor API (CRUD using Repository + UnitOfWork) next?
This will show you how to use your repository to build REST APIs step-by-step.

Top comments (0)