<blockquote>
The Domain layer defines what exists. The Application layer defines what’s possible. The Infrastructure layer makes it actually work.
</blockquote>
<hr>
<h2>Day 5 of building SGAcademy in public</h2>
Yesterday I built the Application layer — services, DTOs, AutoMapper profiles. All clean. All abstract. No database anywhere in sight.
Today that changes.
The Infrastructure layer is where the contracts finally get implemented. <code>IStudentRepository</code> gets a real class. <code>DbContext</code> gets configured. Entity Framework Core starts talking to SQL Server.
This is where clean architecture earns its cost.
<hr>
<h2>What lives in the Infrastructure layer</h2>
Four things:
<ul>
<li>EF Core DbContext — the single entry point to the database</li>
<li>Repository implementations — concrete classes that implement domain contracts</li>
<li>EF Configurations — <code>IEntityTypeConfiguration&lt;T&gt;</code> files that map entities to tables</li>
<li>Interceptors — <code>SaveChangesInterceptor</code> hooks that auto-stamp audit and academic year fields</li>
</ul>
The Infrastructure layer depends on the Domain layer. It knows about Entity Framework. The Application layer does not.
<hr>
<h2>The DbContext</h2>
One <code>DbContext</code> for the whole system. It extends <code>IdentityDbContext</code> to plug in <a href="http://ASP.NET" target="_blank" rel="noopener nofollow">ASP.NET</a> Identity, registers all <code>DbSet</code>s, and wires in both interceptors.
<pre><code class="language-csharp">public class ApplicationDbContext : IdentityDbContext&lt;ApplicationUser, ApplicationRole, Guid&gt;
{
 public DbSet&lt;Student&gt; Students =&gt; Set&lt;Student&gt;();
 public DbSet&lt;Staff&gt; Staff =&gt; Set&lt;Staff&gt;();
 // ... all entities

 protected override void OnModelCreating(ModelBuilder builder)
 {
 base.OnModelCreating(builder);
 builder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
 }
}
</code></pre>
<code>ApplyConfigurationsFromAssembly</code> picks up every <code>IEntityTypeConfiguration&lt;T&gt;</code> automatically. No manual registration needed.
<hr>
<h2>EF Configurations: one file per entity</h2>
No fluent API in <code>OnModelCreating</code> — that becomes unmanageable fast. Every entity gets its own configuration file.
<pre><code class="language-csharp">public class StudentConfiguration : IEntityTypeConfiguration&lt;Student&gt;
{
 public void Configure(EntityTypeBuilder&lt;Student&gt; builder)
 {
 builder.Property(s =&gt; s.FullName).IsRequired().HasMaxLength(150);
 builder.Property(s =&gt; s.RegistrationNumber).IsRequired().HasMaxLength(20);
 builder.HasIndex(s =&gt; s.RegistrationNumber).IsUnique();
 builder.HasMany(s =&gt; s.Enrollments)
 .WithOne(e =&gt; e.Student)
 .OnDelete(DeleteBehavior.Restrict);
 }
}
</code></pre>
One file. One entity. Scales cleanly as the schema grows.
<hr>
<h2>The Repository pattern</h2>
Every entity has an interface in Domain and a concrete implementation in Infrastructure.
<code>RepositoryBase&lt;T&gt;</code> handles shared CRUD so you never repeat it:
<pre><code class="language-csharp">public abstract class RepositoryBase&lt;T&gt; : IRepositoryBase&lt;T&gt; where T : class
{
 protected ApplicationDbContext Context;

 public IQueryable&lt;T&gt; FindByCondition(Expression&lt;Func&lt;T, bool&gt;&gt; expr, bool trackChanges) =&gt;
 trackChanges ? Context.Set&lt;T&gt;().Where(expr)
 : Context.Set&lt;T&gt;().Where(expr).AsNoTracking();

 public void Create(T entity) =&gt; Context.Set&lt;T&gt;().Add(entity);
 public void Delete(T entity) =&gt; Context.Set&lt;T&gt;().Remove(entity);
}
</code></pre>
Concrete repositories extend the base and only add specialised queries:
<pre><code class="language-csharp">public class StudentRepository : RepositoryBase&lt;Student&gt;, IStudentRepository
{
 public async Task&lt;Student?&gt; GetByIdAsync(Guid id, bool trackChanges) =&gt;
 await FindByCondition(s =&gt; s.Id == id, trackChanges).FirstOrDefaultAsync();
}
</code></pre>
<hr>
<h2>IRepositoryWrapper: one dependency to rule them all</h2>
Instead of injecting five repositories into every service, SGAcademy uses a wrapper:
<pre><code class="language-csharp">public class RepositoryWrapper : IRepositoryWrapper
{
 private IStudentRepository? _student;
 public IStudentRepository Student =&gt; _student ??= new StudentRepository(_context);

 // ... same pattern for Staff, Class, Enrollment, Attendance

 public async Task SaveAsync() =&gt; await _context.SaveChangesAsync();
}
</code></pre>
One <code>SaveAsync()</code> call. One unit of work. Services don’t care how many repositories they touched — they just call <code>SaveAsync()</code> at the end.
<hr>
<h2>Interceptors: automatic stamping</h2>
Two interceptors run on every <code>SaveChanges</code>. You never call them manually — EF triggers them automatically.
AuditableEntitySaveChangesInterceptor stamps <code>CreatedAt</code>, <code>UpdatedAt</code>, <code>CreatedBy</code>, <code>UpdatedBy</code> on every entity that extends <code>AuditableEntity</code>:
<pre><code class="language-csharp">public class AuditableEntitySaveChangesInterceptor : SaveChangesInterceptor
{
 private readonly ICurrentUserService _currentUser;

 public AuditableEntitySaveChangesInterceptor(ICurrentUserService currentUser)
 =&gt; _currentUser = currentUser;

 public override InterceptionResult&lt;int&gt; SavingChanges(
 DbContextEventData eventData, InterceptionResult&lt;int&gt; result)
 {
 UpdateAuditFields(eventData.Context);
 return base.SavingChanges(eventData, result);
 }

 private void UpdateAuditFields(DbContext? context)
 {
 if (context is null) return;

 foreach (var entry in context.ChangeTracker.Entries&lt;AuditableEntity&gt;())
 {
 if (entry.State == EntityState.Added)
 {
 entry.Entity.CreatedAt = DateTime.UtcNow;
 entry.Entity.CreatedBy = _currentUser.UserId;
 }
 if (entry.State is EntityState.Added or EntityState.Modified)
 {
 entry.Entity.UpdatedAt = DateTime.UtcNow;
 entry.Entity.UpdatedBy = _currentUser.UserId;
 }
 }
 }
}
</code></pre>
AcademicYearSaveChangesInterceptor stamps <code>AcademicYearId</code> on every entity that implements <code>IAcademicYearEntity</code>:
<pre><code class="language-csharp">public class AcademicYearSaveChangesInterceptor : SaveChangesInterceptor
{
 private readonly ICurrentAcademicYearService _academicYear;

 public AcademicYearSaveChangesInterceptor(ICurrentAcademicYearService academicYear)
 =&gt; _academicYear = academicYear;

 public override InterceptionResult&lt;int&gt; SavingChanges(
 DbContextEventData eventData, InterceptionResult&lt;int&gt; result)
 {
 if (eventData.Context is null) return base.SavingChanges(eventData, result);

 foreach (var entry in eventData.Context.ChangeTracker.Entries&lt;IAcademicYearEntity&gt;())
 {
 if (entry.State == EntityState.Added)
 entry.Entity.AcademicYearId = _academicYear.CurrentId;
 }

 return base.SavingChanges(eventData, result);
 }
}
</code></pre>
Add the base class or interface to your entity. Get the stamping for free. No extra code anywhere else.
<hr>
<h2>Registering everything</h2>
One extension method in <code>ServiceExtensions.cs</code>, called once from <code>Program.cs</code>:
<pre><code class="language-csharp">services.AddDbContext&lt;ApplicationDbContext&gt;(options =&gt;
 options.UseSqlServer(config.GetConnectionString(&quot;DefaultConnection&quot;)));

services.AddScoped&lt;IRepositoryWrapper, RepositoryWrapper&gt;();
services.AddScoped&lt;AuditableEntitySaveChangesInterceptor&gt;();
services.AddScoped&lt;AcademicYearSaveChangesInterceptor&gt;();
</code></pre>
Done.
<hr>
<h2>The mistake I see everywhere</h2>
Putting EF queries directly in services.
<pre><code class="language-csharp">// Wrong — your service now knows about DbContext
var students = await _context.Students
 .Where(s =&gt; s.Status == StudentStatus.Active)
 .ToListAsync();
</code></pre>
Now your Application layer has an EF dependency. You can’t swap the database without touching business logic.
Put it in the repository. The service stays clean. Infrastructure stays contained.
<hr>
<h2>What I shipped today</h2>
<ul>
<li><code>ApplicationDbContext</code> with Identity integration and interceptor wiring</li>
<li>EF configurations for all five core entities</li>
<li><code>RepositoryBase&lt;T&gt;</code> with generic CRUD + no-tracking support</li>
<li>Concrete repositories for Student, Staff, Class, Enrollment, Attendance</li>
<li><code>RepositoryWrapper</code> as the unit of work</li>
<li>Both <code>SaveChanges</code> interceptors auto-stamping audit and academic year fields</li>
<li>Everything wired into DI via <code>ServiceExtensions</code></li>
</ul>
First migration created. Database schema generated. SQL Server has tables.
The backend now has all four layers: Domain → Application → Infrastructure → API (next).
<hr>
<h2>One principle to take away</h2>
The Infrastructure layer’s only job is to implement contracts the domain defined.
Business logic in a repository? Wrong layer. EF queries in a service? Wrong layer.
Every layer has one job. Let it do exactly that job.
<hr>
<h2>Tomorrow</h2>
Day 6: The API layer — controllers, middleware, global exception handling, and how the whole stack finally connects end to end.
<hr>
Learn | Build | Ship — BuildWithRafique <code>&lt;R/&gt;</code>
#buildinpublic #dotnet #cleanarchitecture #devtips #learntocode #webdev #sgacademy

Ready to become a .NET ninja? Get your C# fix right here! Whether you’re just starting out or you’re already deep in the code jungle, we’ve got every version of .NET under the sun—9, 8, 6, 5, Core 3.1, and even the OG Framework.

.Net Community

A practical walkthrough of building the Infrastructure layer in a .NET clean architecture project called SGAcademy. Covers setting up EF Core DbContext with ASP.NET Identity, per-entity IEntityTypeConfiguration files, a generic RepositoryBase<T> with no-tracking support, a RepositoryWrapper acting as a unit of work, and two SaveChangesInterceptors that auto-stamp audit fields and academic year IDs. Emphasizes keeping EF queries out of services and business logic out of repositories, with all components wired via a single DI extension method.

The Infrastructure layer is where clean theory meets real databases. Here's how I built it in SGAcademy.