Skip to content
CAI
Software that uses CAICheck a score

ardalis/CleanArchitecture

60.6

Adequate · 11 November 2026

6.2k

lines of production code

C#

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Added .NET Aspire orchestration and service defaults

The template now includes an Aspire host project that orchestrates the application stack, automatically launching a persistent SQL Server container and a Papercut SMTP container for email testing during development. The web application connects to these services via Aspire's resource references, with the database connection string injected automatically. A shared Service Defaults project provides standardized configuration for service discovery, HTTP resilience, OpenTelemetry observability (metrics and tracing), and health checks, ensuring consistent operational behavior across services.

src/Clean.Architecture.AspireHost, src/Clean.Architecture.ServiceDefaults · high confidence

Added CQRS query services for listing contributors, projects, and incomplete items

The sample application now includes concrete implementations for listing contributors, projects, and incomplete to-do items using the CQRS pattern. This location provides both real data-access services (using Entity Framework Core with raw SQL for performance) and fake/in-memory implementations for testing or development. Users can now query for paginated contributor lists, shallow project lists, and incomplete to-do items associated with a specific project.

sample/src/NimblePros.SampleToDo.Infrastructure/Data/Queries · high confidence

Added CQRS use cases for managing Contributors

This location introduces the command and query handlers for the Contributor domain, implementing the CQRS pattern. Users can now create, update, and delete contributors via dedicated commands, and retrieve individual or paginated lists of contributors via queries. The implementation includes a DTO for data transfer, support for caching on list and get operations, and a service interface for listing contributors that delegates to infrastructure.

sample/src/NimblePros.SampleToDo.UseCases/Contributors · high confidence

Added contributor deletion and email sending interfaces

New interfaces have been introduced to support specific domain operations: IDeleteContributorService defines a method for deleting contributors and firing associated domain events, while IEmailSender provides a contract for sending asynchronous emails with standard parameters.

src/Clean.Architecture.Core/Interfaces · high confidence

Added contributor deletion and to-do item search services

The sample application now includes two new core services to support user workflows. DeleteContributorService enables the removal of contributors, handling repository deletion and publishing a domain event via the mediator. ToDoItemSearchService provides capabilities to retrieve incomplete to-do items within a project, supporting both full-list searches by keyword and fetching the next single incomplete item.

sample/src/NimblePros.SampleToDo.Core/Services · high confidence

Added contributor update capability

Users can now update an existing contributor's name. This change introduces the UpdateContributorCommand and its handler, which validates the contributor's existence, updates the name, and returns the updated contributor details including their phone number.

src/Clean.Architecture.UseCases/Contributors/Update · high confidence

Added event handlers for logging and email notifications

The sample application now includes specific handlers for project aggregate events. A new logging handler records when contributors are assigned to items, and another logs when new items are added to a project. Additionally, an email notification handler has been added to send an email when a to-do item is completed, demonstrating integration with an email sender service.

sample/src/NimblePros.SampleToDo.Core/ProjectAggregate/Handlers · high confidence

Clean Architecture template upgraded to .NET 10 with new solution structure and test improvements

The Clean Architecture template now targets .NET 10 (SDK 10.0.100), introducing a new slnx solution file that organizes the Core, UseCases, Infrastructure, and Web projects, along with optional Aspire support. The template includes a new Minimal Clean Architecture variant for single-project scenarios. Test execution has been enhanced with parallelization settings via .runsettings and a migration of functional tests to use Testcontainers with SQL Server 2022 for more realistic integration testing. The project also adopts central package management and transitive pinning for dependency consistency.

(repo-wide) · high confidence

Configures Entity Framework mappings for Contributor with Value Object support

The infrastructure layer now includes explicit Entity Framework Core configuration for the Contributor entity. This change introduces a new ContributorConfiguration class that defines how the Contributor maps to the database, including primary key generation, name length constraints, and the handling of the PhoneNumber owned type. It also integrates Vogen value objects (ContributorId and ContributorName) by registering custom EF Core converters, ensuring these value types are correctly persisted and retrieved from the database.

src/Clean.Architecture.Infrastructure/Data/Config · high confidence

Contributor aggregate with value objects and domain events

The Contributor aggregate in the core sample application has been implemented with strict domain modeling practices. ContributorName and ContributorId are now typed value objects (using Vogen) that enforce validation rules, such as preventing empty names and ensuring positive IDs. The Contributor entity exposes an UpdateName method that validates the new name and raises a ContributorNameUpdatedEvent, while a ContributorDeletedEvent is also defined to track deletions. This change ensures data integrity at the domain level and provides clear event signals for downstream processing.

Clean.Architecture.Core, sample/src/NimblePros.SampleToDo.Core/ContributorAggregate · high confidence

Email notifications for contributor lifecycle events

The system now sends email notifications when a contributor is deleted or when their name is updated. These changes are implemented via new domain event handlers (ContributorDeletedHandler and ContributorNameUpdatedEmailNotificationHandler) that utilize the IEmailSender interface to dispatch alerts upon the corresponding ContributorDeletedEvent and ContributorNameUpdatedEvent occurrences.

src/Clean.Architecture.Core/ContributorAggregate/Handlers · high confidence

Implement Contributor creation and retrieval use cases with FastEndpoints

This change introduces the use-case layer for managing contributors, replacing the previous MediatR-based approach with FastEndpoints command and query handlers. It adds the CreateContributorCommand and its handler, which allows creating a new contributor with an optional phone number, and the GetContributorQuery and its handler, which retrieves contributor details by ID. The implementation leverages primary constructors for dependency injection and uses the IRepository/IReadRepository abstractions to persist and fetch data.

src/Clean.Architecture.UseCases/Contributors/Create · high confidence

Implemented contributor deletion use case

Added the command and handler for deleting a contributor. The DeleteContributorCommand uses a primary constructor to pass the ContributorId, and the handler delegates the deletion logic to the underlying IDeleteContributorService, keeping domain event handling within the domain model as per the project's architectural preference.

src/Clean.Architecture.UseCases/Contributors/Delete · high confidence

Implemented real and fake contributor listing query services

Added two new implementations of the IListContributorsQueryService interface in the infrastructure layer. The real ListContributorsQueryService executes a raw SQL query to fetch paged contributor data (including phone number components) from the database, while the FakeListContributorsQueryService provides a deterministic in-memory mock for testing or development purposes.

src/Clean.Architecture.Infrastructure/Data/Queries · high confidence

Initial Minimal Clean Architecture template scaffolding

The MinimalClean location now includes the foundational configuration files for a new single-project Vertical Slice Architecture template. This includes an .editorconfig enforcing .NET coding conventions, a .gitignore for Visual Studio and build artifacts, a .runsettings file enabling parallel xUnit test execution, and a global.json pinning the SDK to version 10.0.100. Additionally, a Directory.Build.props file sets the target framework to net10.0 with nullable and implicit usings enabled, and a nuget.config is added to manage package sources and restore behavior.

MinimalClean · high confidence

Introduce .NET Aspire host and cart/checkout domain features

The application now includes a .NET Aspire host (AppHost) that orchestrates the web service alongside SQL Server and Papercut SMTP containers for local development, while the web project implements a new cart and checkout capability. This feature adds endpoints to add items to a cart, retrieve cart details, and process checkout (creating an order and a guest user record), supported by a clean architecture structure using Mediator, Vogen value objects, and FastEndpoints.

MinimalClean/src · high confidence

Introduction of Use Cases project structure and shared types

The Use Cases layer now includes foundational infrastructure for application services, such as a PagedResult record for handling paginated data, an ICacheable interface for caching strategies, and constants for pagination limits. Global usings have been added to streamline dependencies on Ardalis.Result, Mediator, and the SharedKernel, while a README clarifies the project's role in the Clean Architecture pattern.

sample/src/NimblePros.SampleToDo.UseCases · high confidence

New EF Core data layer with automatic domain event dispatching

The sample application now includes a new Entity Framework Core infrastructure layer in the Data folder, featuring an AppDbContext that maps ToDoItem, Project, and Contributor entities, and a generic EfRepository for data access. A key behavioral addition is the EventDispatchInterceptor, which automatically detects and dispatches domain events for any tracked entities implementing IHasDomainEvents immediately after a successful database save, ensuring domain logic is triggered without manual intervention in the application code.

sample/src/NimblePros.SampleToDo.Infrastructure/Data · high confidence

New use-case handlers for Project CRUD and ToDo operations

The Projects use-case layer now includes handlers and commands for creating, updating, and deleting projects, as well as adding and marking ToDo items as complete. It also provides query handlers to retrieve a project with all its items, list projects shallowly, and list incomplete items for a specific project, along with the necessary DTOs and query services to support these operations.

sample/src/NimblePros.SampleToDo.UseCases/Projects · high confidence

Sample app now includes Aspire hosting, caching/logging behaviors, and localization

The sample application has been updated to include an Aspire host (NimblePros.SampleToDo.AspireHost) that orchestrates the web app alongside a Papercut SMTP container for email debugging. The web project now features CachingBehavior and LoggingBehavior pipeline behaviors for request handling, along with JSON-based localization support for error messages. Additionally, the app includes a SeedData component to populate initial test data and an api.http file for easy API testing.

sample/src/NimblePros.SampleToDo.Web · high confidence

Behavioural changes

Added DeleteContributorService with correct ID handling

A new DeleteContributorService has been introduced to demonstrate domain service patterns and domain event publishing. The service correctly accepts a ContributorId type for deletion, addressing a previous issue where raw integers were incorrectly passed to the repository's GetByIdAsync method.

src/Clean.Architecture.Core/Services · high confidence

Added event handlers for contributor deletion and name updates

The application now includes specific handlers for contributor-related domain events. When a contributor is deleted, the system automatically removes their association from all projects they were involved in, ensuring data consistency across the project items. Additionally, when a contributor's name is updated, the system logs the change for audit and visibility purposes.

sample/src/NimblePros.SampleToDo.Core/ContributorAggregate/Handlers · high confidence

Centralized application startup configuration via dedicated config classes

The application's startup logic in Program.cs has been refactored into a set of dedicated configuration classes within the Configurations folder to improve modularity and maintainability. LoggerConfigs.cs introduces Serilog as the primary logging provider alongside OpenTelemetry. MediatorConfig.cs registers the Mediator source generator with scoped lifetime and logging pipeline behaviors. MiddlewareConfig.cs consolidates the middleware pipeline, including FastEndpoints, Swagger/Scalar API documentation, HTTPS redirection, and conditional database migration and seeding logic for development environments. OptionConfigs.cs handles mail server and cookie policy settings, along with a service listing diagnostic endpoint in development. ServiceConfigs.cs wires up infrastructure services, the mediator, and selects the appropriate email sender implementation (MimeKit for production, local test server for development) based on the environment.

src/Clean.Architecture.Web/Configurations · high confidence

Centralized configuration and service registration for the sample web app

The sample application now uses a dedicated configuration folder to organize startup logic, introducing a global exception handler that returns structured JSON error details (showing the exception message in development only), configuring Serilog for logging, registering MediatR with scoped lifetime and pipeline behaviors for logging and caching, and setting up HTTP client integration with the Metronome observability middleware. Service and middleware pipelines are now explicitly wired through new configuration classes, ensuring consistent setup of options, database seeding, and diagnostic endpoints like the service list view in development.

sample/src/NimblePros.SampleToDo.Web/Configurations · high confidence

Centralized infrastructure service registration with environment-specific configurations

The sample application now uses a centralized \InfrastructureServiceExtensions\ class to register infrastructure dependencies, replacing previous scattered registration logic. This extension method configures services based on the runtime environment: Development and Production modes register the SQLite database context with the Metronome tracking interceptor and the \MimeKitEmailSender\, while Testing mode substitutes these with fake implementations for isolation. Additionally, EF Core repositories are registered generically, and specific CQRS query services (ListContributors, ListIncompleteItems, ListProjectsShallow) are wired up according to the active environment.

sample/src/NimblePros.SampleToDo.Infrastructure · high confidence

Contributors API endpoints migrated to FastEndpoints with typed results

The Contributors module in the sample web application has been refactored to use the FastEndpoints library, replacing the previous implementation with a set of dedicated endpoint classes (Create, GetById, List, Update, Delete). This change introduces structured request/response models, integrated FluentValidation for input validation, and standardized HTTP result handling via new ResultExtensions that map domain results to typed HTTP responses (e.g., Created, NotFound, ValidationProblem). The List endpoint now supports GitHub-style pagination with Link headers, and all endpoints include Swagger documentation metadata for improved API discoverability.

sample/src/NimblePros.SampleToDo.Web/Contributors · high confidence

Contributors API endpoints now use MediatR for command/query dispatch

The Contributor endpoints (Create, GetById, List, Update, Delete) have been updated to dispatch commands and queries via MediatR's IMediator interface. This change ensures that request handling is routed through the application's internal command/query pipeline, maintaining consistency with the use-case layer and enabling centralized handling of cross-cutting concerns like validation and logging for these operations.

src/Clean.Architecture.Web/Contributors · high confidence

Database schema updated for .NET 10 and SQL Server identity columns

The application's database migrations have been updated to support .NET 10 and improve SQL Server compatibility. A new migration configures the Contributors table to use SQL Server IDENTITY columns for auto-generated primary keys, replacing the previous approach and ensuring correct identity behavior on SQL Server (SQLite remains unaffected). Additionally, column types for the Contributors table and its embedded PhoneNumber value object have been standardized to SQL Server types (e.g., nvarchar, int) to align with the .NET 10 Entity Framework Core provider, while maintaining backward compatibility with SQLite's dynamic typing.

src/Clean.Architecture.Infrastructure/Data/Migrations · high confidence

EF Core 7 migration with primary constructors and domain event dispatching

The data layer has been updated to target .NET 7, utilizing C\# 12 primary constructors for cleaner dependency injection in AppDbContext, EfRepository, and the new EventDispatchInterceptor. A key behavioral change is the introduction of the EventDispatchInterceptor, which automatically dispatches domain events after successful database saves, ensuring domain logic is triggered consistently. Additionally, the database seeding logic in SeedData has been refactored to use async SQL inserts for improved performance and reliability when populating initial test data.

src/Clean.Architecture.Infrastructure/Data · high confidence

Email infrastructure refactored to use MimeKit with configuration support

The email sending capability in the sample application has been updated to use the MimeKit library for actual email delivery, replacing the previous SmtpClient-based implementation which is now marked as obsolete. A new MailserverConfiguration class allows hostname and port settings to be configured, and a FakeEmailSender is provided for development and testing scenarios that log messages instead of sending real emails.

sample/src/NimblePros.SampleToDo.Infrastructure/Email · high confidence

Email sending infrastructure refactored with async SMTP and configuration

The email sending capability has been updated to use an asynchronous SMTP connection via MimeKit (ConnectAsync/SendAsync/DisconnectAsync) instead of synchronous calls, improving responsiveness. A new MailserverConfiguration class now externalizes SMTP host and port settings, and a FakeEmailSender implementation is provided for testing purposes without sending real emails.

src/Clean.Architecture.Infrastructure/Email · high confidence

Entity configurations updated to use Vogen value objects

The sample application's Entity Framework Core configurations for Contributor, Project, and ToDoItem entities have been updated to integrate Vogen value objects. The new configuration files apply \HasVogenConversion()\ to primary keys and string properties, ensuring that value types like \ContributorId\, \ProjectName\, and \ToDoItemTitle\ are correctly persisted and retrieved. A dedicated converter class registers these Vogen types for seamless database interaction.

sample/src/NimblePros.SampleToDo.Infrastructure/Data/Config · high confidence

Introduce ContributorDto with PhoneNumber field

A new ContributorDto record has been added to the Contributors use cases, exposing the Contributor's Id, Name, and PhoneNumber. This change introduces the PhoneNumber field to the data transfer object, aligning with updates to nullability consistency for contributor phone numbers.

src/Clean.Architecture.UseCases/Contributors · high confidence

Introduce Global Usings and shared Use Case primitives

The Core and Use Cases projects now use GlobalUsings files to automatically import common namespaces (such as Ardalis libraries and Mediator), reducing boilerplate in source files. Additionally, the Use Cases project introduces a PagedResult record for standardized pagination responses and a Constants class defining default and maximum page sizes, providing reusable building blocks for application services.

src/Clean.Architecture.Core, src/Clean.Architecture.UseCases · high confidence

Migrate to .NET 10, Vanilla DI, and localized validation

The sample application has been updated to target .NET 10 and replaced the Autofac dependency injection container with the built-in Microsoft.Extensions.DependencyInjection, registering core services via a new CoreServiceExtensions class. Validation error messages have been migrated from raw text to strongly-typed, localized strings using a new static Localization context that exposes IStringLocalizer to domain code. Additionally, GlobalUsings have been introduced to simplify namespace imports across the core project.

sample/src/NimblePros.SampleToDo.Core · high confidence

Migrate to FastEndpoints and .NET Minimal Hosting

The web layer has been refactored to use the FastEndpoints library instead of the previous MediatR-based approach, introducing a new minimal hosting model in Program.cs with global usings and Serilog console logging. This change includes new extension methods for mapping domain Results to HTTP responses, configuration for Swagger documentation, and support for Aspire service defaults and health checks.

src/Clean.Architecture.Web · high confidence

Migrate to native DI and introduce automatic database provider selection

The infrastructure layer now uses Microsoft.Extensions.DependencyInjection instead of Autofac for service registration. It introduces a new \AddInfrastructureServices\ extension method that automatically selects the database provider: it prefers SQL Server (via Aspire or explicit configuration) on Windows or when forced, and falls back to SQLite otherwise. Additionally, an \EventDispatchInterceptor\ is registered to handle domain events during save changes, and global usings are consolidated for cleaner code.

src/Clean.Architecture.Infrastructure · high confidence

Project and ToDo Item domain models now use Vogen value objects with localized validation

The Project and ToDo Item aggregates in the core sample application have been refactored to use Vogen value objects for identifiers (ProjectId, ToDoItemId) and string fields (ProjectName, ToDoItemTitle, ToDoItemDescription). This change introduces strongly-typed, localized validation rules for these fields, replacing previous raw text validation with error messages that can be localized via a static localizer with English fallbacks. Additionally, the domain now includes specific domain events (NewItemAddedEvent, ToDoItemCompletedEvent, ContributorAddedToItemEvent) and interfaces (IDeleteContributorService, IToDoItemSearchService) to support these behaviors.

sample/src/NimblePros.SampleToDo.Core/ProjectAggregate · high confidence

Projects API endpoints refactored to use FastEndpoints conventions

The Projects API endpoints have been rewritten to follow the FastEndpoints library conventions, replacing the previous implementation with a structured set of dedicated classes for requests, responses, validators, and endpoint logic. This change introduces explicit validation rules (e.g., name length constraints, required fields) and standardized HTTP response codes (201, 204, 404, 400) across Create, Read, Update, and Delete operations. The List endpoint now includes GitHub-style pagination with Link headers, and the GetById endpoint returns detailed project information including associated todo items. All endpoints are now grouped under the 'Projects' tag for better API documentation and discoverability.

sample/src/NimblePros.SampleToDo.Web/Projects · high confidence

Refactor contributors list to use FastEndpoints instead of MediatR

The contributors list use case has been migrated from the MediatR library to the FastEndpoints framework. This change introduces a dedicated \IListContributorsQueryService\ interface for data fetching and replaces the previous MediatR handler with a new \ListContributorsHandler\ that implements \IQueryHandler\. The query logic is now encapsulated in a \ListContributorsQuery\ record, aligning the application layer with the new command bus architecture.

src/Clean.Architecture.UseCases/Contributors/List · high confidence

Sample app upgraded to .NET 10 with new solution structure and coding standards

The sample application has been upgraded to target .NET 10.0, as defined in the new Directory.Build.props. A new .slnx solution file now organizes the project structure, explicitly including the UseCases project alongside Core, Infrastructure, Web, and AspireHost components. Additionally, the sample now enforces consistent coding standards via a new .editorconfig and optimizes test execution performance through a .runsettings file that utilizes all available CPU cores.

sample · high confidence

Updated Bootstrap to v5.1.0

The static assets in the wwwroot/lib/bootstrap directory have been updated to Bootstrap v5.1.0. This upgrade brings the latest grid system, CSS utilities, and layout components to the application, ensuring consistent styling and responsive behavior across different screen sizes.

sample/src/NimblePros.SampleToDo.Web/wwwroot · high confidence

Test coverage

Added ContributorByIdSpec specification; Added functional test infrastructure for the Sample ToDo app; Added functional tests for Contributor API endpoints; Added functional tests for Contributor CRUD operations; Added functional tests for Projects endpoints; Added integration tests for EF Core repository operations; Added integration tests for the Entity Framework repository layer; Added placeholder integration test for Aspire; Added test coverage for ContributorByIdSpec; Added unit tests for Contributor aggregate and search services; Added unit tests for Contributor aggregate and search services; Added unit tests for Contributor use-case handlers; Added unit tests for sample application core aggregates and services; Added unit tests for the CreateContributor handler; Refactored functional test infrastructure with SQL Server 2025 support; Updated test infrastructure and configuration.

Dependencies

Upgrade to .NET 10 and Centralized Package Management

The solution has been upgraded to target .NET 10, with all project files now referencing version 10.0.x of the Microsoft.AspNetCore and EntityFrameworkCore packages. Central Package Management has been introduced via Directory.Packages.props files to standardize dependency versions across the solution. Key library updates include FastEndpoints 8.2.0, xunit v3, and Serilog.AspNetCore 10.0.0, while the architecture now includes dedicated Aspire host and service defaults projects for improved local development and observability.

(dependencies) · high confidence

Housekeeping

Added placeholder for static assets directory

A .gitkeep file was added to the wwwroot directory to ensure the folder is tracked by version control. This allows the application to store and serve static files (such as CSS, JavaScript, or images) in the future without the directory being ignored by Git.

src/Clean.Architecture.Web/wwwroot · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 62 → 61 (-1.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 76 → 76 (+0.0)
  • Architecture 82 → 64 (-18.3)
  • Maturity 69 → 80 (+10.7)
  • Readiness 53 → 55 (+2.1)
  • Security 73 → 73 (+0.0)
  • Performance 66 → 60 (-6.3)

Resolved (49)

  • Documentation: no project overview (docs/content/minimal-clean-architecture.md)
  • Duplicated block (14 lines × 3) (MinimalClean/src/MinimalClean.Architecture.Web/Infrastructure/Email/MimeKitEmailSender.cs)
  • Duplicated block (5 lines × 2) (sample/src/NimblePros.SampleToDo.Core/ContributorAggregate/ContributorName.cs)
  • Outdated: AspNetCore.Localizer.Json
  • Outdated: Aspire.Hosting.AppHost
  • Outdated: Aspire.Hosting.SqlServer
  • Outdated: FluentValidation
  • Outdated: FluentValidation.DependencyInjectionExtensions
  • Outdated: MailKit
  • Outdated: MessagePack
  • Outdated: Microsoft.AspNetCore.Mvc.NewtonsoftJson
  • Outdated: Microsoft.AspNetCore.Mvc.Testing
  • Outdated: Microsoft.EntityFrameworkCore.Design
  • Outdated: Microsoft.EntityFrameworkCore.InMemory
  • Outdated: Microsoft.EntityFrameworkCore.Relational
  • Outdated: Microsoft.EntityFrameworkCore.SqlServer
  • Outdated: Microsoft.EntityFrameworkCore.Sqlite
  • Outdated: Microsoft.EntityFrameworkCore.Tools
  • Outdated: Microsoft.Extensions.Configuration
  • Outdated: Microsoft.Extensions.Http.Resilience
  • …and 29 more

New (25)

  • Documentation: no map of the repository's parts (README.md)
  • Duplicated block (14 lines × 3) (MinimalClean/src/MinimalClean.Architecture.Web/Infrastructure/Email/MimeKitEmailSender.cs)
  • Duplicated block (6 lines × 3) (MinimalClean/src/MinimalClean.Architecture.AspireHost/AppHost.cs)
  • Edited copy of a member (11 corresponding lines) (sample/src/NimblePros.SampleToDo.Infrastructure/Data/Queries/FakeListContributorsQueryService.cs)
  • Edited copy of a member (26 corresponding lines) (sample/src/NimblePros.SampleToDo.Web/Contributors/GetById.cs)
  • Edited copy of a member (28 corresponding lines) (sample/src/NimblePros.SampleToDo.Web/Contributors/Update.cs)
  • Low coverage: src/Clean.Architecture.Core/ContributorAggregate/Handlers/ContributorDeletedHandler.cs (src/Clean.Architecture.Core/ContributorAggregate/Handlers/ContributorDeletedHandler.cs)
  • Low coverage: src/Clean.Architecture.Core/ContributorAggregate/Handlers/ContributorNameUpdatedEmailNotificationHandler.cs (src/Clean.Architecture.Core/ContributorAggregate/Handlers/ContributorNameUpdatedEmailNotificationHandler.cs)
  • Low coverage: src/Clean.Architecture.Infrastructure/Data/Queries/FakeListContributorsQueryService.cs (src/Clean.Architecture.Infrastructure/Data/Queries/FakeListContributorsQueryService.cs)
  • Low coverage: src/Clean.Architecture.Infrastructure/Email/FakeEmailSender.cs (src/Clean.Architecture.Infrastructure/Email/FakeEmailSender.cs)
  • Low coverage: src/Clean.Architecture.Infrastructure/Email/MimeKitEmailSender.cs (src/Clean.Architecture.Infrastructure/Email/MimeKitEmailSender.cs)
  • Low coverage: src/Clean.Architecture.UseCases/Contributors/Update/UpdateContributorHandler.cs (src/Clean.Architecture.UseCases/Contributors/Update/UpdateContributorHandler.cs)
  • Low coverage: src/Clean.Architecture.Web/Configurations/MiddlewareConfig.cs (src/Clean.Architecture.Web/Configurations/MiddlewareConfig.cs)
  • Low coverage: src/Clean.Architecture.Web/Configurations/OptionConfigs.cs (src/Clean.Architecture.Web/Configurations/OptionConfigs.cs)
  • Low coverage: src/Clean.Architecture.Web/Contributors/Delete.DeleteContributorValidator.cs (src/Clean.Architecture.Web/Contributors/Delete.DeleteContributorValidator.cs)
  • Low coverage: src/Clean.Architecture.Web/Contributors/Update.UpdateContributorValidator.cs (src/Clean.Architecture.Web/Contributors/Update.UpdateContributorValidator.cs)
  • Low coverage: src/Clean.Architecture.Web/Extensions/ResultExtensions.cs (src/Clean.Architecture.Web/Extensions/ResultExtensions.cs)
  • No test project references MinimalClean.Architecture.AspireHost (MinimalClean/src/MinimalClean.Architecture.AspireHost/MinimalClean.Architecture.AspireHost.csproj)
  • No test project references MinimalClean.Architecture.ServiceDefaults (MinimalClean/src/MinimalClean.Architecture.ServiceDefaults/MinimalClean.Architecture.ServiceDefaults.csproj)
  • No test project references MinimalClean.Architecture.Web (MinimalClean/src/MinimalClean.Architecture.Web/MinimalClean.Architecture.Web.csproj)
  • …and 5 more

Changes since last survey

  • 13 commits — 10 feature/other, 3 fixes

By area

  • (root) — 4 commits
  • .github/workflows — 2 commits
  • sample/Directory.Packages.props — 2 commits
  • (repo) — 1 commit
  • .github/dependabot.yml — 1 commit
  • sample/src — 1 commit
  • tests/Clean.Architecture.FunctionalTests — 1 commit
  • tests/Clean.Architecture.UnitTests — 1 commit

Notable commits

  • fix: Ignore personal VS Code settings and C# Dev Kit cache; fix launch path
  • fix: fix: resolve transitive dependency advisories
  • fix: fix: update Testcontainers for SSH.NET advisory
  • change: Bump NSubstitute from 5.3.0 to 6.2.0 (#1142)
  • change: Bump the all-other-non-major group with 13 updates (#1145)
  • change: Bump the all-other-non-major group with 14 updates (#1141)
  • change: Group Dependabot non-major NuGet updates (#1093)
  • change: Make SQLite fallback reliable when Docker is unavailable (#1073)
  • change: Merge pull request #1099 from dajiaohuang/docs/update-dotnet-version-readme
  • change: Replace xUnit assertions with Shouldly. (#1064)
  • change: Update value object validation based on https://github.com/ardalis/CleanArchitecture/discussions/1053 and suppress aspire warnings
  • change: Upgrade all solutions to .NET 11 and latest NuGet packages (#1173)
  • change: docs: correct main branch .NET version

Architecture

  • Unchanged — 5 containers · 3 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

ardalis/CleanArchitecture was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 11 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 45d02144f07cd27d60375e6a040d1d6e997dc4f0 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.29+preprod-106b68c3c303.