Project Structure — 8 Projects, the .slnx Format, and What Goes Where

SystemForge/
├── SystemForge.slnx                        ← XML solution format (replaces .sln)
│
├── src/
│   ├── SystemForge.Domain/
│   │   ├── AssemblyReference.cs
│   │   ├── Entities/
│   │   │   └── Patient.cs
│   │   ├── ValueObjects/
│   │   │   └── PatientId.cs
│   │   ├── Events/
│   │   │   └── PatientCreatedDomainEvent.cs
│   │   └── SystemForge.Domain.csproj
│   │
│   ├── SystemForge.Application/
│   │   ├── AssemblyReference.cs
│   │   ├── Patients/
│   │   │   ├── Commands/
│   │   │   │   ├── CreatePatient/
│   │   │   │   │   ├── CreatePatientCommand.cs
│   │   │   │   │   ├── CreatePatientCommandHandler.cs
│   │   │   │   │   └── CreatePatientCommandValidator.cs
│   │   │   └── Queries/
│   │   │       └── GetPatient/
│   │   │           ├── GetPatientQuery.cs
│   │   │           ├── GetPatientQueryHandler.cs
│   │   │           └── PatientResponse.cs
│   │   ├── Abstractions/
│   │   │   ├── IPatientRepository.cs
│   │   │   └── IEmailService.cs
│   │   ├── Common/
│   │   │   └── Result.cs
│   │   └── SystemForge.Application.csproj
│   │
│   ├── SystemForge.Infrastructure/
│   │   ├── AssemblyReference.cs
│   │   ├── Persistence/
│   │   │   ├── AppDbContext.cs
│   │   │   ├── Configurations/
│   │   │   │   └── PatientConfiguration.cs
│   │   │   └── Migrations/
│   │   ├── Repositories/
│   │   │   └── PatientRepository.cs
│   │   ├── Services/
│   │   │   └── EmailService.cs
│   │   ├── Identity/
│   │   │   ├── AppUser.cs
│   │   │   └── TokenService.cs
│   │   └── SystemForge.Infrastructure.csproj
│   │
│   ├── SystemForge.Api/
│   │   ├── Controllers/
│   │   │   └── PatientsController.cs
│   │   ├── Middleware/
│   │   │   └── ExceptionHandlingMiddleware.cs
│   │   ├── Extensions/
│   │   │   ├── ServiceCollectionExtensions.cs
│   │   │   └── WebApplicationExtensions.cs
│   │   ├── Program.cs
│   │   └── SystemForge.Api.csproj
│   │
│   ├── SystemForge.AppHost/
│   │   ├── Program.cs
│   │   └── SystemForge.AppHost.csproj
│   │
│   └── SystemForge.ServiceDefaults/
│       ├── Extensions.cs
│       └── SystemForge.ServiceDefaults.csproj
│
└── tests/
    ├── SystemForge.Architecture.Tests/
    │   ├── LayerDependencyTests.cs
    │   └── SystemForge.Architecture.Tests.csproj
    └── SystemForge.Application.UnitTests/
        ├── Patients/
        │   └── CreatePatientCommandHandlerTests.cs
        └── SystemForge.Application.UnitTests.csproj

<!-- SystemForge.slnx -->
<Solution>
  <Folder Name="/src/">
    <Project Path="src/SystemForge.Domain/SystemForge.Domain.csproj" />
    <Project Path="src/SystemForge.Application/SystemForge.Application.csproj" />
    <Project Path="src/SystemForge.Infrastructure/SystemForge.Infrastructure.csproj" />
    <Project Path="src/SystemForge.Api/SystemForge.Api.csproj" />
    <Project Path="src/SystemForge.AppHost/SystemForge.AppHost.csproj" />
    <Project Path="src/SystemForge.ServiceDefaults/SystemForge.ServiceDefaults.csproj" />
  </Folder>
  <Folder Name="/tests/">
    <Project Path="tests/SystemForge.Architecture.Tests/SystemForge.Architecture.Tests.csproj" />
    <Project Path="tests/SystemForge.Application.UnitTests/SystemForge.Application.UnitTests.csproj" />
  </Folder>
</Solution>

Advantages over .sln:
  ✓ Human-readable XML (no GUID noise)
  ✓ Diff-friendly — merge conflicts are obvious
  ✓ Sorted and consistent — no tool-specific section ordering
  ✓ Supported by Visual Studio 2022 17.10+, Rider, and `dotnet` CLI

// ─── Domain ────────────────────────────────────────────────────────────────
// What goes here: entities, value objects, domain events, domain exceptions
// What does NOT go here: anything with a NuGet dependency

// Domain/Entities/Patient.cs
public sealed class Patient
{
    public PatientId Id { get; private set; }
    public string Name { get; private set; }
    public DateOnly DateOfBirth { get; private set; }

    private readonly List<IDomainEvent> _domainEvents = [];

    private Patient() { }   // EF Core constructor

    public static Patient Create(string name, DateOnly dob)
    {
        var patient = new Patient
        {
            Id   = PatientId.New(),
            Name = name,
            DateOfBirth = dob,
        };
        patient._domainEvents.Add(new PatientCreatedDomainEvent(patient.Id));
        return patient;
    }

    public IReadOnlyList<IDomainEvent> PopDomainEvents()
    {
        var events = _domainEvents.ToList();
        _domainEvents.Clear();
        return events;
    }
}

// ─── Application ───────────────────────────────────────────────────────────
// What goes here: command/query handlers, interfaces (IRepository, IEmailService),
//                 validators, response DTOs, Result<T>
// What does NOT go here: EF Core, SqlConnection, HttpClient, anything I/O

// Application/Abstractions/IPatientRepository.cs
public interface IPatientRepository
{
    Task<Patient?> GetByIdAsync(PatientId id, CancellationToken ct);
    Task AddAsync(Patient patient, CancellationToken ct);
    Task<bool> ExistsByNameAsync(string name, CancellationToken ct);
}

// Application/Patients/Commands/CreatePatient/CreatePatientCommandHandler.cs
public sealed class CreatePatientCommandHandler
{
    private readonly IPatientRepository _patients;

    public CreatePatientCommandHandler(IPatientRepository patients)
        => _patients = patients;

    public async Task<Result<PatientId>> Handle(
        CreatePatientCommand command, CancellationToken ct)
    {
        if (await _patients.ExistsByNameAsync(command.Name, ct))
            return Result.Failure<PatientId>(PatientErrors.NameTaken);

        var patient = Patient.Create(command.Name, command.DateOfBirth);
        await _patients.AddAsync(patient, ct);
        return Result.Success(patient.Id);
    }
}

// ─── Infrastructure ────────────────────────────────────────────────────────
// What goes here: EF Core DbContext, concrete repository implementations,
//                 external API clients, email/SMS, identity, Redis clients
// What does NOT go here: business logic

// Infrastructure/Persistence/PatientRepository.cs
public sealed class PatientRepository : IPatientRepository
{
    private readonly AppDbContext _context;

    public PatientRepository(AppDbContext context) => _context = context;

    public async Task<Patient?> GetByIdAsync(PatientId id, CancellationToken ct)
        => await _context.Patients.FirstOrDefaultAsync(p => p.Id == id, ct);

    public async Task AddAsync(Patient patient, CancellationToken ct)
        => await _context.Patients.AddAsync(patient, ct);

    public async Task<bool> ExistsByNameAsync(string name, CancellationToken ct)
        => await _context.Patients.AnyAsync(p => p.Name == name, ct);
}

// ─── Api ───────────────────────────────────────────────────────────────────
// What goes here: controllers/minimal API endpoints, middleware, DI wiring,
//                 request/response mapping, Program.cs
// What does NOT go here: business logic, direct DB access

// Api/Controllers/PatientsController.cs
[ApiController]
[Route("api/patients")]
public sealed class PatientsController : ControllerBase
{
    private readonly CreatePatientCommandHandler _create;
    private readonly GetPatientQueryHandler _get;

    public PatientsController(
        CreatePatientCommandHandler create,
        GetPatientQueryHandler get)
    {
        _create = create;
        _get    = get;
    }

    [HttpPost]
    public async Task<IActionResult> Create(
        CreatePatientRequest request, CancellationToken ct)
    {
        var command = new CreatePatientCommand(request.Name, request.DateOfBirth);
        var result = await _create.Handle(command, ct);
        return result.Match<IActionResult>(
            id => CreatedAtAction(nameof(Get), new { id }, id),
            err => Problem(err.Description));
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> Get(Guid id, CancellationToken ct)
    {
        var query = new GetPatientQuery(new PatientId(id));
        var result = await _get.Handle(query, ct);
        return result.Match<IActionResult>(Ok, err => NotFound(err.Description));
    }
}

// Domain/AssemblyReference.cs
namespace SystemForge.Domain;

public static class AssemblyReference { }

// Application/AssemblyReference.cs
namespace SystemForge.Application;

public static class AssemblyReference { }

// Architecture.Tests/LayerDependencyTests.cs
var domainAssembly = typeof(Domain.AssemblyReference).Assembly;

// Infrastructure — EF Core migration target
dotnet ef migrations add Init --project src/Infrastructure --startup-project src/Api

<!-- Domain.csproj — minimal, no NuGet packages -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>
</Project>

<!-- Application.csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="FluentValidation" Version="11.*" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\Domain\SystemForge.Domain.csproj" />
  </ItemGroup>
</Project>