aspnetrun/run-aspnetcore

This system is a .NET-based web application designed for managing a product and category catalog. It implements a layered architecture featuring a domain model for products and categories, supported by a generic repository pattern and specification-based querying. The application exposes CRUD operations through Razor Pages and is backed by Entity Framework Core for data persistence.

Introduced a new generic logging interface, IAppLogger\<T\>, which provides methods for logging information and warning messages. Additionally, a new abstract base class, ValueObject, was added to the core layer, providing standard equality and hash code implementations for value objects.

src/AspnetRun.Core/Interfaces · high confidence

The web project now includes full CRUD (Create, Read, Update, Delete) capabilities for Products and listing pages for Categories. This is enabled by new Razor Pages (e.g., Product/Create, Product/Edit, Product/Delete, Product/Details, Category/Index) and corresponding Page Models that utilize new service interfaces (IProductPageService, ICategoryPageService) and their implementations. The application also introduces a new IndexPageHealthCheck to verify the health of the home page, and adds email sending extensions for account confirmation and password reset flows.

src/AspnetRun.Web · high confidence

The repository now includes a complete Visual Studio solution file (AspnetRun.sln) that defines the layered architecture, organizing projects into 'src' (Core, Application, Infrastructure, Web) and 'test' (Core, Application, Infrastructure, Web) folders. The README.md has been significantly expanded to document the Clean Architecture/NLayer design, including setup instructions, database migration steps, and links to related repositories and an e-book.

(repo-wide) · high confidence

Added the database context, initial migration, and seed data for the Product and Category entities, along with a generic repository pattern implementation to support data access operations.

src/AspnetRun.Infrastructure · high confidence

Adds a new Specification pattern implementation to the core layer, introducing a base \BaseSpecification\ class and \ISpecification\ interface to encapsulate query criteria, include relationships, and paging logic. Concrete specifications for \Product\ and \Category\ entities are added, allowing for more flexible and reusable data access queries.

src/AspnetRun.Core/Specifications · high confidence

Added a new abstract base class EntityBase and its corresponding interface IEntityBase to the core entities layer. This provides a standardized way to manage entity identity and equality, ensuring that all entities inheriting from this base will have consistent behavior for identity checks and hash code generation.

src/AspnetRun.Core/Entities · high confidence

The application now uses a generic base repository interface (IRepository) alongside specific interfaces for Category and Product. This change introduces a standardized data access layer, allowing for consistent querying and entity management across the core domain models.

src/AspnetRun.Core/Repositories · high confidence

A new AspnetRunSettings class has been introduced in the core configuration layer, providing a dedicated container for application settings, specifically including a ConnectionString property.

src/AspnetRun.Core/Configuration · medium confidence

A new CoreException class has been introduced in the AspnetRun.Core.Exceptions namespace to serve as a base exception type for the application. This allows the application to handle and distinguish core-level errors from standard .NET exceptions, providing a consistent way to surface business messages and inner exceptions.

src/AspnetRun.Core/Exceptions · high confidence

The core domain model now includes base and specific entity classes for managing products and categories. A new abstract Entity base class was added to standardize entity behavior, while Category and Product classes were introduced to represent catalog items, each featuring a static Create factory method for instantiation.

AspnetRun.Core · medium confidence

The application layer has been refactored to introduce explicit service interfaces (ICategoryService, IProductService) and corresponding implementations (CategoryService, ProductService) that utilize a centralized ObjectMapper for mapping domain entities to DTOs. This change replaces the previous TrackingBehavior and ad-hoc mapping logic with a structured approach using new model classes (ProductModel, CategoryModel, BaseModel) and a custom ApplicationException for error handling, providing a cleaner separation of concerns and more robust service contracts for product and category operations.

src/AspnetRun.Application · medium confidence

Added ProductBuilder test helper; Added integration tests for the web application; Added test builders for Category and Product entities; Added unit tests for Product and Category entities; Added unit tests for ProductService; Added unit tests for ProductWithCategorySpecification; Added unit tests for the Product repository.

All project files in the solution have been updated to target .NET 5.0. Key dependencies have been upgraded, including AutoMapper to version 10.1.1 and 8.1.0, and Microsoft.EntityFrameworkCore packages to version 5.0.0. Test projects have also been updated to use .NET 5.0 and include updated versions of xUnit, Moq, and Microsoft.NET.Test.Sdk.

(dependencies) · high confidence

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

• CAI 40 → 39 (-0.2)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 59 → 56 (-3.3)
• Architecture 82 → 82 (+0.1)
• Maturity 47 → 47 (+0.0)
• Readiness 31 → 31 (+0.0)
• Security 37 → 37 (-0.0)
• Accessibility 62 → 63 (+0.4)

• Bounded contexts not declared
• Change coupling: Index.cshtml.cs ↔ IndexPageService.cs (src/AspnetRun.Web/Pages/Index.cshtml.cs)
• Medium CVE: Microsoft.Data.SqlClient 2.0.1
• No exposed public API
• Test runner surfaced no tests
• The repository list entry for 'run-aspnetcore' (Clean Architecture with DDD best practices) appears before Getting Started, Prerequisites, and Installing, which are standard prerequisites/usage sections that follow the repositories list in most learning-path docs. (README.md)
• While both are 'CategoryId', the context differs (Model vs ViewModel). However, looking deeper, there is also 'AspnetRun.Core.Entities.Category.CategoryName' vs 'AspnetRun.Application.Models.CategoryModel.CategoryName'.
• redundant comment (src/AspnetRun.Infrastructure/Repository/ProductRepository.cs)
• single-maintainer — knowledge-concentration (bus factor) risk

• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (src/AspnetRun.Application/Models/ProductModel.cs)
• Duplicated block (20 lines × 2) (src/AspnetRun.Web/Pages/Product/Delete.cshtml.cs)
• Duplicated block (5 lines × 2) (src/AspnetRun.Web/Services/CategoryPageService.cs)
• Duplicated block (8 lines × 3) (src/AspnetRun.Application/Models/ProductModel.cs)
• End-of-life runtime: .NET net5.0
• Inconsistent casing for boolean property 'isPagingEnabled'. While the property name itself is consistent across the interface and implementation, the use of camelCase ('isPagingEnabled') for a public property violates standard .NET naming conventions which dictate PascalCase for properties (e.g., 'IsPagingEnabled'). This is a style inconsistency within the codebase's own public API surface.
• Inconsistent casing for the 'ReorderLevel' concept. The entity property uses PascalCase 'ReorderLevel', while the test builder property uses 'ReOrderLevel' (capital O). This suggests a typo or inconsistency in the test helper naming convention.
• Test builder properties are prefixed with 'Test' (e.g., 'TestProductName', 'TestCategoryName'). This is redundant and non-standard. Builder methods/properties typically set the value directly (e.g., 'ProductName') or use a more descriptive prefix if necessary, but 'Test' adds no semantic value and clutters the API.
• Test builder properties use numeric suffixes (ProductName1, ProductName2, ProductName3) instead of descriptive names. This makes the test code difficult to read and maintain, as the purpose of each specific product name is not immediately clear from the name alone.
• WriteOnlyPrivateField (src/AspnetRun.Application/Services/CategoryService.cs)
• WriteOnlyPrivateField (test/AspnetRun.Core.Tests/Entities/CategoryTests.cs)
• WriteOnlyPrivateField (test/AspnetRun.Core.Tests/Entities/CategoryTests.cs)
• WriteOnlyPrivateField (test/AspnetRun.Core.Tests/Entities/CategoryTests.cs)
• WriteOnlyPrivateField (test/AspnetRun.Infrastructure.Tests/Builders/CategoryBuilder.cs)
• redundant comment (src/AspnetRun.Web/Startup.cs)
• redundant comment (src/AspnetRun.Web/Startup.cs)

• Unchanged — 2 containers · 1 contexts · 0 edges

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

aspnetrun/run-aspnetcore 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.