cloudnative-netcore/netcorekit

This system is a comprehensive .NET Core infrastructure kit that provides reusable building blocks for building cloud-native microservices. It offers a standardized approach to implementing Domain-Driven Design, including domain abstractions, repository patterns for SQL and NoSQL databases, and an event bus supporting Kafka and Redis. Additionally, it supplies ASP.NET Core middleware for authentication, error handling, and API documentation, alongside gRPC and SignalR templates for real-time communication and service-to-service interactions.

34 changes.

This period established the foundational architecture for the NetCoreKit library, introducing core infrastructure modules for ASP.NET Core, Entity Framework Core, and distributed event buses. The team also built out a comprehensive set of sample applications, including gRPC services, SignalR real-time notifications, and Kubernetes deployment scripts to demonstrate the framework's capabilities.

5 changes.

This period focused on establishing foundational architectural patterns, introducing domain-driven design abstractions and gRPC service scaffolding. The work standardized the build system, implemented authentication interceptors, and created templates for rapid application development.

A new static class, AutoMapperProfileExtension, was added to the Mappers folder. It provides extension methods for the AutoMapper Profile class, including MapMySelf, MapTo, and MapToNotification, which simplify the configuration of type mappings and notifications within the application's infrastructure layer.

src/NetCoreKit.Infrastructure/Mappers · high confidence

The sample application now includes a new CreateProject use-case, introducing a MediatR-based request handler and associated payload classes. Users can now create projects via the API, with the handler managing the unit of work and repository interactions to persist new project entities.

samples/TodoApi/v1/UseCases/CreateProject · medium confidence

The BiMonetaryApi sample now includes a Dockerfile and .dockerignore to support containerized builds, configuring the .NET 2.2 runtime and SDK for multi-stage builds. The sample's startup is configured to use MongoDB via NetCoreKit.RestTemplate.MongoDb, and it connects to an external gRPC service (ExchangeService) for RPC communication. Configuration files (appsettings.json) define API versions, feature toggles (Mongo, OpenApi, AuthN, ResponseCompression), and logging settings, while Program.cs sets up the ASP.NET Core web host with console and debug logging.

samples/BiMonetaryApi · high confidence

A new sample project for the ExchangeService is introduced, providing a complete, runnable gRPC service implementation. The update includes a Dockerfile for containerization, a .dockerignore file, and configuration files (appsettings.json, hostsettings.json) to support local and containerized deployment. The service is configured to listen on localhost:5000 in development, exposing the BiMonetaryApi.Rpc.ExchangeService and health check endpoints.

samples/ExchangeService · high confidence

The library now includes a new \DispatchedEventBus\ implementation for the Kafka message broker, enabling asynchronous event publishing and subscription via the \Confluent.Kafka\ client. This change introduces Protobuf serialization for message contracts, allowing services to publish and subscribe to Kafka topics using the \AddKafkaEventBus\ extension method. The implementation supports automatic MediatR notification dispatching for consumed events, providing a scalable, distributed eventing mechanism alongside existing in-memory and Redis bus options.

src/NetCoreKit.Infrastructure.Bus.Kafka · high confidence

Users can now persist and query domain entities using MongoDB. The \NetCoreKit.Infrastructure.Mongo\ package introduces a full repository pattern implementation, including \Repository\, \UnitOfWorkAsync\, and \IMongoQueryRepository\ interfaces, along with extension methods for querying and a service collection extension (\AddMongoDb\) to register the necessary dependencies.

src/NetCoreKit.Infrastructure.Mongo · high confidence

The MySQL database provider for Entity Framework Core has been implemented, allowing users to configure and connect to MySQL databases. This includes a new \DbOptions\ configuration class, a \DbConnStringFactory\ to build connection strings from configuration, and a \DbContextOptionsBuilderFactory\ that configures MySQL-specific options such as server version, migrations assembly, and retry policies. The \ServiceCollectionExtensions\ registers these components via \AddEfCoreMySqlDb\, replacing default database connection string and options builder implementations with MySQL-specific ones.

src/NetCoreKit.Infrastructure.EfCore.MySql · high confidence

The OpenApi infrastructure module now provides automatic Swagger documentation for ASP.NET Core APIs. It introduces operation filters that automatically add 401/403 responses and OAuth2 security requirements for endpoints marked with \[Authorize\]. It also includes filters to handle default parameter values and exclude properties marked with \[SwaggerExclude\] from the generated schema. The setup is configured via the 'Features:OpenApi' configuration section and conditionally enables security definitions when the 'AuthN' feature is active.

src/NetCoreKit.Infrastructure.AspNetCore.OpenApi · high confidence

The NetCoreKit infrastructure now includes a Redis-backed event bus. This adds a new \DispatchedEventBus\ implementation that publishes and subscribes to messages via Redis channels, using protobuf payloads. The change also introduces \RedisStore\ for managing Redis connections and a \ServiceCollectionExtensions.AddRedisBus\ method to register the bus and its dependencies in the DI container, configurable via the \Features:Redis\ configuration section.

src/NetCoreKit.Infrastructure.Bus.Redis · high confidence

The SqlServer module now includes a new DbConnStringFactory that constructs connection strings by combining configuration values with environment variables for Kubernetes deployments, and a DbContextOptionsBuilderFactory that configures SQL Server-specific options including retry logic and sensitive data logging. These components are registered via a new AddEfCoreSqlServerDb extension method, which also wires up the DbOptions configuration section.

src/NetCoreKit.Infrastructure.EfCore.SqlServer · high confidence

A new sample project, SignalRNotifier, has been added to demonstrate real-time notifications using ASP.NET Core's SignalR. The sample configures a .NET Core 2.2 host with MediatR, AutoMapper, and a Redis-based message bus, while also including configuration for Kafka. It exposes a ProjectHub for SignalR communication and supports both development and production environments via Docker and appsettings files.

samples/SignalRNotifier · high confidence

The WebNotifier sample project is introduced, providing a complete Blazor WebAssembly application that connects to a SignalR hub to display real-time project and task notifications. The sample includes the necessary C\# components and Razor pages to render the notification feed, alongside configuration files for development and production environments. To facilitate deployment, the change adds a multi-stage Dockerfile that builds the Blazor app and serves it via Nginx, along with Kubernetes deployment and service manifests for containerized orchestration.

samples/WebNotifier · high confidence

New PowerShell and shell scripts are introduced in the samples deployment directory to automate the build and Kubernetes deployment processes. The scripts handle building Docker images for the TodoApi, SignalRNotifier, and WebNotifier services, as well as applying and deleting Kubernetes manifests for these components.

_samples/\deploys/scripts · high confidence

New template projects are introduced to provide pre-configured scaffolding for building .NET Core applications. For gRPC services, the \NetCoreKit.GrpcTemplate\ templates (EfCore, MongoDb, Standard) add \HostBuilderExtensions\ that configure default settings, dependency injection, and feature toggles. For REST APIs, the \NetCoreKit.RestTemplate\ templates (EfCore, MongoDb, Standard) add \AppBuilderExtensions\ and \ServiceCollectionExtensions\ that configure middleware, authentication, Swagger/OpenAPI, and other standard ASP.NET Core infrastructure. These templates streamline the initial setup for new projects.

templates · high confidence

Added the BiMonetaryApi v1 sample, which includes the gRPC service definitions and generated C\# code for the ExchangeService (including TokenRequest, TokenResponse, and PingResponse messages). The sample also introduces REST controllers (PingController and TickerController) that interact with the gRPC service to provide API endpoints for ping and ticker data.

samples/BiMonetaryApi/v1 · high confidence

The ExchangeService v1 sample now includes a complete gRPC service implementation. This adds the generated protobuf classes for the BiMonetary API, the server-side implementation that returns mock cryptocurrency token data, and a health check endpoint to monitor service status.

samples/ExchangeService/v1 · high confidence

The sample project now includes the implementation for retrieving and updating tasks. The GetTasks use case allows fetching a project with its associated tasks, while the UpdateTask use case enables modifying task details such as title, order, and completion status. These additions provide a complete example of clean architecture patterns, including request/response models and handlers for these specific operations.

samples/TodoApi/v1/UseCases/UpdateTask · high confidence

The sample application now includes a new background service that bridges event-driven messaging with real-time web sockets. This is achieved by introducing domain event classes (ProjectCreated, TaskCreated) and a HostedService that subscribes to an event bus. The service listens for specific messages (ProjectCreatedMsg, TaskCreatedMsg) and pushes them to all connected SignalR clients via a ProjectHub, enabling live updates for project and task creation events.

samples/SignalRNotifier/Services · high confidence

Introduced a new TodoApi sample application that includes domain models (Project, Task), DTOs, and a gRPC contract layer (project.proto). The sample integrates with Kafka and Redis for event bus/pub-sub capabilities, and includes Kubernetes deployment manifests (Deployment, Service, Job) and a Dockerfile for containerized deployment.

samples/TodoApi · high confidence

The sample applications for the Notifier and SignalRNotifier now include the auto-generated C\# classes for the \project.proto\ file. These classes, including \ProjectCreatedMsg\ and \TaskCreatedMsg\, provide the data structures required for the gRPC and SignalR-based notification services to serialize and deserialize messages.

samples/Notifier/Rpc, samples/SignalRNotifier/Rpc · high confidence

Added build and code-generation scripts for the BiMonetaryApi and ExchangeService samples. The new scripts automate the Docker image build process and the generation of C\# client code from the bimonetary.proto file using gRPC tools, enabling local development and containerized deployment of these gRPC services.

_samples/BiMonetaryApi/App\_Build, samples/ExchangeService/App\Build · high confidence

The sample project now includes shell scripts to build the application (build.sh, start.sh), generate gRPC C\# code from proto files (gen.sh), and build a Docker image (build\_image.sh). Additionally, Kubernetes manifests are provided to deploy the service, including a Deployment, Service (port 32502), and a Secret for Redis credentials, enabling the sample to be deployed to a Kubernetes cluster.

_samples/SignalRNotifier/App\Build · medium confidence

The GrpcHost infrastructure now includes an AuthNInterceptor that validates JWT tokens from the 'authorization' header against an Identity Provider configuration, enforcing role-based access control via a new CheckPolicyAttribute. Additionally, HostBuilderExtensions provide a standardized setup for configuration, dependency injection, and logging for gRPC services.

src/NetCoreKit.Infrastructure.GrpcHost · medium confidence

The sample Todo API now includes implementations for adding, clearing, and deleting tasks. The AddTask use case allows users to create new tasks within a project, while ClearTasks removes all tasks from a project, and DeleteTask removes a specific task. These new endpoints are implemented as request handlers that interact with the project repository to update the state of tasks.

samples/TodoApi/v1/UseCases/AddTask, samples/TodoApi/v1/UseCases/ClearTasks, samples/TodoApi/v1/UseCases/DeleteTask · high confidence

The \NetCoreKit.Infrastructure.AspNetCore.All\ package now includes a suite of ASP.NET Core infrastructure components. This includes an \AppBuilderExtensions\ for centralized exception handling that returns structured \ProblemDetails\ responses, and a \ServiceCollectionExtensions\ that registers services for AutoMapper, MediatR, REST clients, caching, API versioning, JWT authentication, CORS, header forwarding, and MiniProfiler. Additionally, new controllers are provided: \DbMigrationController\ for executing database migrations, \ErrorController\ for error pages, \HomeController\ for Swagger redirection, and \SysInfoController\ to expose runtime and environment details. The MVC builder is also configured to load full assemblies and set the compatibility version to 2.2.

src/NetCoreKit.Infrastructure.AspNetCore.All · high confidence

The \NetCoreKit.Infrastructure.EfCore\ library introduces several new extension methods to streamline database operations. \WebHostExtensions\ adds \MigrateDbContext\ and \RegisterDbContext\ to automatically apply pending EF Core migrations and execute seed data during application startup. \DbContextExtensions\ provides an \AllMigrationsApplied\ helper to check migration status. \RepositoryExtensions\ and \RepositoryWithTypeExtensions\ add generic query methods (\GetByIdAsync\, \FindOneAsync\, \ListAsync\, \QueryAsync\, \FindAllAsync\) that support eager loading, read-only tracking, and pagination. \UnitOfWorkExtensions\ adds helpers for executing raw SQL commands and managing command timeouts.

src/NetCoreKit.Infrastructure.EfCore/Extensions · high confidence

The repository is initialized with a complete .NET Core solution structure, including a \netcorekit.sln\ file defining the project hierarchy. Build automation is introduced via a Cake-based \build.cake\ script and \build.ps1\ bootstrapper, supported by an \appveyor.yml\ CI configuration. Development standards are enforced through an \.editorconfig\ file and a \.dockerignore\ file. Additionally, a \global.json\ file pins the .NET SDK version to 2.2.100.

(repo-wide) · high confidence

The NetCoreKit.Infrastructure.Bus module now provides a new DomainEventDispatcher that wraps MediatR to publish domain events as INotification messages. A NotificationEnvelope and MessageEnvelope are added to wrap domain events and Protobuf messages respectively, supporting inter-communication via brokers like Redis or Kafka. The IDispatchedEventBus interface and ServiceCollectionExtensions for DI registration are also introduced.

src/NetCoreKit.Infrastructure.Bus · high confidence

The \NetCoreKit.Infrastructure.EfCore\ library now provides a foundational \AppDbContext\ that automatically registers entity types and dispatches domain events on save. This change introduces the core database context, along with supporting interfaces (\ICustomModelBuilder\, \IDbConnStringFactory\, \IExtendDbContextOptionsBuilder\) and data seeding abstractions (\ISeedData\, \SeedDataBase\) to standardize database initialization and data population.

src/NetCoreKit.Infrastructure.EfCore/Db · high confidence

The \NetCoreKit.Infrastructure.EfCore\ package now provides a complete data access layer built on Entity Framework Core. This includes a \UnitOfWork\ implementation for managing database transactions and a \QueryRepositoryFactory\ that supplies typed repository instances for querying entities. The infrastructure also registers these services via \ServiceCollectionExtensions\, supporting both standard database contexts and in-memory databases for testing or lightweight scenarios.

src/NetCoreKit.Infrastructure.EfCore · high confidence

Adds new base controllers for CRUD operations, a centralized error-handling middleware, and HATEOAS link generation utilities. The update also introduces an \AuthAttribute\ for JWT-based authorization, configuration extensions for host and authentication settings, and validation result types to standardize API error responses.

src/NetCoreKit.Infrastructure.AspNetCore · high confidence

A new feature toggle mechanism has been added to the infrastructure layer, allowing applications to enable or disable features via configuration. This includes a new \IFeature\ interface, a \Feature\ class that reads feature states from the \IConfiguration\ source, and extension methods to register the toggle service in the dependency injection container.

src/NetCoreKit.Infrastructure/Features · high confidence

The library now provides a \UnitOfWorkBehavior\ that automatically wraps MediatR request handlers in a database transaction, ensuring that changes are committed or rolled back as a single unit. This is enabled by default when calling \AddCleanArch\ on the service collection. The change also introduces base classes (\RequestHandlerBase\ and \TxRequestHandlerBase\) and interfaces (\IEventHandler\, \ITxEventHandler\) to simplify the implementation of command handlers, with the transactional variant automatically managing the unit of work lifecycle.

src/NetCoreKit.Infrastructure.AspNetCore.CleanArch · high confidence

The NetCoreKit.Domain package now includes core building blocks for domain-driven design: base classes and interfaces for Entities, Aggregate Roots, and Value Objects, alongside support for Domain Events and an in-memory event dispatcher. It also adds a generic Criterion class for handling pagination, sorting, and filtering, as well as specialized exception types (DomainException, ValidationException, etc.) and repository/Unit of Work interfaces to standardize data access patterns.

src/NetCoreKit.Domain · high confidence

The NetCoreKit.Infrastructure module introduces new foundational utilities to support application setup and data handling. A new ConfigurationExtensions class provides methods to load assemblies based on patterns defined in appsettings.json, alongside a ConfigurationHelper to manage configuration sources. Additionally, an OrderByExtensions class enables dynamic property-based sorting for Entity Framework queries, and a new IExternalSystem interface defines a standard for connecting to external systems.

src/NetCoreKit.Infrastructure · medium confidence

A new shell script, gen.sh, has been added to the App\_Build directory to automate the generation of C\# code from the project's .proto files. The script configures the gRPC tools version 1.17.1 to compile the project's protocol buffer definitions into the Rpc output directory.

_samples/Notifier/App\Build · high confidence

The build system now centralizes common properties and package metadata. A new 'common.props' file suppresses the CS1591 missing XML comment warning, while 'packages.props' defines shared assembly metadata (including author, repository, and license information) and enables strong-name signing via a key file. Additionally, the C\# language version is explicitly set to 7.3.

build · high confidence

Added new tests for the generic repository pattern in the EF Core infrastructure layer. The changes include a new test class, RepositoryTest, which verifies that commands and queries can be executed against both Guid and integer primary key types using an in-memory database. Additionally, an appsettings.json configuration file was added to support the test environment.

src/NetCoreKit.Infrastructure.EfCore.Tests · high confidence

Introduced .csproj project files for the core NetCoreKit libraries (Domain, Infrastructure, AspNetCore, EfCore, Mongo, Bus, GrpcHost) and their respective templates (Rest, Grpc, Standard) as well as sample applications (BiMonetaryApi, ExchangeService, Notifier, SignalRNotifier, TodoApi, WebNotifier). These files define dependencies on packages such as AutoMapper, MediatR, Grpc, Entity Framework Core, and various Microsoft.Extensions libraries, establishing the build structure for the cloud-native .NET Core kit.

(dependencies) · high confidence

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

• CAI 46 → 45 (-1.5)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 66 → 66 (-0.8)
• Architecture 89 → 89 (+0.0)
• Maturity 66 → 66 (+0.0)
• Readiness 37 → 35 (-2.0)
• Security 48 → 46 (-2.9)
• Domain Modelling 69 → 72 (+2.5)
• Event-Driven 100 → 100 (+0.0)
• Performance 47 → 47 (+0.0)

• Bounded contexts not declared
• Build did not complete in the analyzer
• Duplicated block (40 lines × 3) (templates/NetCoreKit.RestTemplate.EfCore/AppBuilderExtensions.cs)
• High CVE: MessagePack 1.7.3.4
• High CVE: MessagePack 1.7.3.4
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.2.0
• High CVE: Microsoft.NETCore.App 2.2.0
• High CVE: System.Net.Security 4.0.0
• High CVE: System.Net.Security 4.0.0
• LLM evaluation failed
• LLM evaluation failed
• Medium CVE: IdentityServer4 2.3.2
• Medium CVE: IdentityServer4 2.3.2
• Medium CVE: MessagePack 1.7.3.4
• Medium CVE: MessagePack 1.7.3.4
• Medium CVE: MessagePack 1.7.3.4
• …and 20 more

• CommentedOutCode (src/NetCoreKit.Infrastructure.AspNetCore/ControllerBase.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (105 lines × 3) (templates/NetCoreKit.RestTemplate.EfCore/AppBuilderExtensions.cs)
• Duplicated block (13 lines × 2) (templates/NetCoreKit.RestTemplate.EfCore/ServiceCollectionExtensions.cs)
• Duplicated block (29–31 lines × 2) (src/NetCoreKit.Infrastructure.EfCore/Extensions/RepositoryExtensions.cs)
• Duplicated block (56 lines × 2) (templates/NetCoreKit.RestTemplate.EfCore/ServiceCollectionExtensions.cs)
• Duplicated block (8–10 lines × 3) (samples/TodoApi/v1/UseCases/ClearTasks/RequestHandler.cs)
• End-of-life runtime: .NET netcoreapp2.1
• End-of-life runtime: .NET netcoreapp2.2
• High CVE: MessagePack 1.7.3.4
• High CVE: Microsoft.NETCore.App 2.1.0
• High CVE: Microsoft.NETCore.App 2.2.0
• High CVE: System.Net.Security 4.0.0
• High secret: WD-SECRET-0001 (build/netcorekit.snk)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Inconsistent spelling of 'Volume' in property names. 'Volumn24HUsd' uses a non-standard spelling ('Volumn' instead of 'Volume'), while 'TotalSupply' and 'AvailableSupply' correctly use 'Supply' for volume-related metrics. Additionally, 'Volumn24HUsd' mixes a misspelled noun with a currency code, whereas 'AvailableSupply' is a clean noun phrase.
• Leaked secret: hardcoded-credential (samples/SignalRNotifier/App_Build/k8s/signalrnotifier-secrets.yaml)
• Leaked secret: hardcoded-credential (samples/TodoApi/App_Build/k8s/todolist-secrets.yaml)
• …and 39 more

• Unchanged — 18 HTTP endpoints

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

cloudnative-netcore/netcorekit 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.