netcorepal/netcorepal-cloud-framework

This system is a .NET framework library that provides infrastructure for building distributed, event-driven applications. It offers comprehensive support for domain modeling, command handling, and distributed transactions via CAP, with integrations for multiple database backends and message brokers. Additionally, it includes tooling for code analysis, architecture visualization, and distributed tracing, alongside utilities for JWT management and service discovery.

28 changes.

This period focused on modernizing the project's build infrastructure to support .NET 8, 9, and 10, alongside a massive expansion of the test suite. The team added comprehensive unit and integration tests for domain abstractions, service discovery, distributed transactions, and web application components, while also cleaning up build artifacts and removing obsolete sample code.

48 changes.

This period focused on expanding the framework's distributed transaction support via CAP integrations for multiple databases, including MongoDB, KingbaseES, and Dameng. It also introduced comprehensive observability features, such as OpenTelemetry and SkyWalking tracing, alongside code flow analysis and architecture visualization tools.

The library now provides an integration with the CAP messaging framework to handle distributed transactions and integration events. This includes a new \CapTransactionUnitOfWork\ that coordinates database and message broker transactions, a \CapIntegrationEventPublisher\ for sending events via CAP, and supporting classes like \NetCorePalCapTransaction\ and \NetCorePalCapDbTransaction\ to bridge EF Core and CAP transaction scopes. Additionally, an \EnvCapSubscribe\ attribute allows environment-based message grouping, and extension methods in \IntegrationEventServicesBuilderExtensions\ simplify the registration of CAP-based services and event handlers.

src/NetCorePal.Extensions.DistributedTransactions.CAP · high confidence

The docker directory now includes a complete Docker Compose setup for local development, defining services for OpenObserve, OpenTelemetry Collector, RabbitMQ, MySQL, PostgreSQL, GaussDB, KingbaseES, DMDB, Redis, and Nacos, along with their respective configuration files and environment variables.

docker · high confidence

A new Entity Framework Core integration is introduced, providing a \DbContextJwtSettingStore\ that persists JWT secret key settings to a database via a \JwtSettingData\ entity. The \JwtBuilderExtensions\ class adds an \AddEntityFrameworkCoreStore\<TDbContext\>\ method to register this store as a singleton, allowing applications to store and retrieve JWT configuration directly from an EF Core \DbContext\.

src/NetCorePal.Extensions.Jwt.EntityFrameworkCore · high confidence

The Hangfire extension library now provides built-in support for using the ASP.NET Core dependency injection container to activate Hangfire jobs. This is enabled by calling the new \UseHangfireContainerJobActivator\ extension method on the application builder, which configures Hangfire to resolve job instances from the service provider, ensuring proper lifecycle management and dependency injection for all scheduled jobs.

src/NetCorePal.Extensions.Hangfire · high confidence

The framework now supports KingbaseES and MongoDB for CAP (Common Application Platform) distributed transaction storage. For KingbaseES, new entity type configurations (CapLock, PublishedMessage, ReceivedMessage) and an interface (IKingbaseESCapDataStorage) are introduced to map database schemas. The AppDbContextBaseCapDataStorageSourceGenerator has been updated to recognize and generate storage implementations for KingbaseES and MongoDB, allowing developers using these databases to automatically generate the necessary CAP storage classes and handlers.

src/NetCorePal.Extensions.DistributedTransactions.CAP.SourceGenerators · high confidence

New entity type configurations for CAP (Centralized Application Platform) distributed transactions in MongoDB are added, specifically for CapLock, PublishedMessage, and ReceivedMessage entities. Each configuration maps the entity to its respective MongoDB collection and defines the primary key mapping to the '\_id' field, ensuring proper persistence of transactional messages and lock states in MongoDB.

src/NetCorePal.Extensions.DistributedTransactions.CAP.MongoDB/EntityTypeConfigurations · high confidence

Users can now use MongoDB as a persistence store for CAP (Common Application Platform) distributed transactions. This includes a new \MongoDBNetCorePalDataStorage\ implementation that works around EF Core provider limitations by using an optimized Attach/Update/Remove approach instead of bulk operations. The change also adds a monitoring API for querying message states and statistics, and registers the necessary services via \UseMongoDBNetCorePalStorage\ extension method.

src/NetCorePal.Extensions.DistributedTransactions.CAP.GaussDB, src/NetCorePal.Extensions.DistributedTransactions.CAP.MongoDB · high confidence

The src/NetCorePal.OpenTelemetry.Diagnostics package now provides OpenTelemetry tracing support for NetCorePal domain, integration, and command events. A new DiagnosticListener class maps these events to OpenTelemetry Activity objects, capturing details such as event IDs, names, and serialized event data. The DiagnosticSourceSubscriber manages subscriptions to diagnostic sources, and the NetCorePalInstrumentation class ties them together. Users can enable this tracing by calling TracerProviderBuilderExtensions.AddNetCorePalInstrumentation() on their TracerProviderBuilder, which registers the necessary sources and instrumentation for automatic telemetry collection.

src/NetCorePal.OpenTelemetry.Diagnostics · high confidence

The library now supports storing and retrieving JWT secret key settings in a Redis cache. A new \RedisJwtSettingStore\ implementation of \IJwtSettingStore\ has been added, which serializes settings to JSON and stores them under the key \netcorepal:jwtsettings\. Users can enable this backend by calling \builder.AddRedisStore()\ on their \IJwtBuilder\ instance, which registers the store as a singleton and replaces the default \IJwtSettingStore\ service in the DI container.

src/NetCorePal.Extensions.Jwt.StackExchangeRedis · high confidence

The library now supports SQLite as a storage backend for CAP (Common Application Platform) distributed transactions. New entity type configurations define the schema for lock, published message, and received message tables, and an interface ISqliteCapDataStorage is introduced to enable this persistence provider.

src/NetCorePal.Extensions.DistributedTransactions.CAP.Sqlite · high confidence

Introduces new components to support ShardingCore-based database and tenant sharding. This includes a source generator (\AppDbContextShardingCoreSourceGenerator\) that automatically generates sharding context wrappers for DbContexts implementing \IShardingCore\. It also adds MediatR pipeline behaviors (\ShardingCoreCommandBehavior\ and \TenantShardingCommandBehavior\) to route commands to the correct database shard based on tenant context. Additionally, it provides configuration extensions (\ShardingCoreConfigBuilderExtensions\, \MediatRServiceConfigurationExtensions\) and routing implementations (\NetCorePalVirtualDataSourceRoute\, \NetCorePalTenantVirtualDataSourceRoute\) to manage data source selection and sharding keys.

src/NetCorePal.Extensions.ShardingCore · high confidence

Users can now enable automatic distributed tracing for NetCorePal commands, domain events, integration events, and Redis distributed locks via the SkyWalking APM agent. The new \AddNetCorePal\ extension registers diagnostic processors that create spans for command and event handlers (including error states) and Redis lock acquisition/release operations. Configuration is available through \NetCorePalTracingOptions\, which allows enabling the serialization of command, domain, and integration event data into span logs.

src/NetCorePal.SkyApm.Diagnostics · high confidence

The NetCorePal.Extensions.DistributedLocks.Abstractions package now includes an in-memory implementation of the IDistributedLock interface, suitable for testing and single-process scenarios. This adds the InMemoryDistributedLock class and its associated ILockSynchronizationHandler interface, along with a ServiceCollectionExtensions method to register the in-memory lock as a singleton dependency.

src/NetCorePal.Extensions.DistributedLocks.Abstractions · high confidence

The library now supports multi-environment service discovery, allowing users to route requests to different service instances based on the current environment (e.g., gray-scale or canary deployments). This is achieved through a new \AddMultiEnvMicrosoftServiceDiscovery\ extension that registers a \MultiEnvServiceDiscoveryHttpMessageHandler\. This handler intercepts HTTP requests, resolves the target service name for the current environment using a configurable \EnvServiceNameFunc\ (defaulting to appending the environment name to the host), and updates the request URI before forwarding it. This enables seamless integration with Microsoft's Service Discovery while adding environment-aware routing capabilities.

src/NetCorePal.Extensions.MicrosoftServiceDiscovery · medium confidence

New Entity Framework Core configuration classes (CapLockConfiguration, PublishedMessageConfiguration, ReceivedMessageConfiguration) were added to define how the CapLock, PublishedMessage, and ReceivedMessage entities map to the database. These configurations specify table names, primary keys, property constraints, and indexes, ensuring the application correctly persists and retrieves CAP (Cloud Application Platform) transactional messages and locks in the database.

src/NetCorePal.Extensions.DistributedTransactions.CAP.DMDB · high confidence

Added a new set of C\# attributes in the NetCorePal.Extensions.CodeAnalysis.Attributes namespace to support code analysis and metadata extraction. These include CommandHandlerEntityMethodMetadataAttribute, CommandHandlerMetadataAttribute, CommandMetadataAttribute, CommandSenderMethodMetadataAttribute, ControllerMethodMetadataAttribute, DomainEventHandlerMetadataAttribute, DomainEventMetadataAttribute, EndpointMetadataAttribute, EntityMetadataAttribute, EntityMethodMetadataAttribute, IntegrationEventConverterMetadataAttribute, and IntegrationEventHandlerMetadataAttribute, along with a base MetadataAttribute class. These attributes are used to annotate assemblies and types to expose information about commands, events, entities, and handlers for static analysis or tooling purposes.

src/NetCorePal.Extensions.CodeAnalysis/Attributes · high confidence

The \NetCorePal.Extensions.Domain.Abstractions\ library introduces core domain modeling primitives. This includes the \Entity\ and \Entity\<TKey\>\ base classes for managing identity and domain events, as well as an \Enumeration\ base class with value-based equality and parsing utilities. Soft-delete functionality is introduced via the \Deleted\ and \DeletedTime\ types, while \UpdateTime\ provides timestamp tracking with comparison operators. Additionally, the library provides \EntityIdTypeConverter\ and a suite of \JsonConverter\ implementations to handle serialization of strongly-typed IDs, enumerations, and versioning types.

src/NetCorePal.Extensions.Domain.Abstractions · high confidence

The library now provides a complete EF Core integration layer, introducing \AppDbContextBase\ and \AppIdentityDbContextBase\ as base classes for application and identity contexts, along with \ITransactionUnitOfWork\ and \CommandUnitOfWorkBehavior\ to manage database transactions around MediatR commands. This change adds automatic domain event dispatching, soft-delete and concurrency token configuration, and optional UTC conversion for \DateTimeOffset\ properties to ensure compatibility with PostgreSQL/Npgsql. Additionally, new value generators for GUIDs and DI extensions for repository scanning are included.

src/NetCorePal.Extensions.Repository.EntityFrameworkCore · high confidence

Added a new persistence implementation for the CAP (Cloud-Asynchronous-Processing) library, including entity models (PublishedMessage, ReceivedMessage, CapLock), a data storage class (NetCorePalDataStorage) that supports transactional message handling and sharding by data source, and a monitoring API (NetCorePalMonitoringApi) for querying message statistics and logs. The implementation integrates with the existing NetCorePal framework to provide a robust, transaction-safe message queue backend.

src/NetCorePal.Extensions.DistributedTransactions.CAP/Persistence · high confidence

The library now supports automatic, background rotation of RSA signing keys. A new \JwtHostedService\ periodically checks key expiration and triggers rotation via \IJwtKeyRotationService\, which manages active keys and cleans up expired ones. The default behavior is disabled (\AutomaticRotationEnabled=false\); when enabled, keys rotate every hour by default. To support this, the codebase introduces a pluggable \IJwtSettingStore\ abstraction with built-in implementations: \InMemoryJwtSettingStore\ for testing, \FileJwtSettingStore\ for file-based persistence, and \DataProtectionJwtSettingStore\ which wraps another store to encrypt private keys using ASP.NET Core Data Protection. The \JwtProvider\ has been updated to sign tokens using the earliest active key, and the \JwtOptions\ configuration class exposes settings for key lifetime, rotation intervals, and retention periods.

src/NetCorePal.Extensions.Jwt · high confidence

The \NetCorePal.Extensions.CodeAnalysis\ library now provides a complete code flow analysis engine that inspects assemblies to identify controllers, commands, aggregates, events, and their relationships. This data is exposed via a new \CodeFlowAnalysisHelper\ and \CodeFlowAnalysisResult\ model. The library also introduces a \VisualizationHtmlBuilder\ that generates an interactive HTML dashboard featuring Mermaid diagrams, statistics, and historical trend charts, alongside a \VisualizationMarkdownBuilder\ for generating structured Markdown reports. A static HTML template is included as an embedded resource to support the interactive visualization.

src/NetCorePal.Extensions.CodeAnalysis · high confidence

Added a context propagation system (NetCorePal.Context) that allows passing request-scoped data (such as environment and tenant identifiers) across different layers, with specific implementations for ASP.NET Core and CAP. Introduced a command locking mechanism (CommandLockBehavior) to prevent concurrent execution of commands using distributed locks. Added a KnownExceptionHandleMiddleware to standardize error responses and a delegating handler to propagate known exceptions from HTTP clients.

(repo-wide) · high confidence

The \NetCorePal.Extensions.Dto\ package now provides foundational data transfer objects and query extensions. This includes \IPageRequest\ and \PageRequest\ for pagination parameters, \PagedData\<T\>\ for paginated results (with an \Empty\ static property), and \ResponseData\<T\>\ for standard API responses. Additionally, \IQueryableExtensions\ adds \WhereIf\, \OrderByIf\, and \ThenByIf\ methods for conditional query building, while \PageQueryableExtensions\ provides a \ToPagedData\ method that accepts an \IPageRequest\ to simplify pagination logic.

src/NetCorePal.Extensions.Dto · high confidence

Added new static classes in the \NetCorePal.Extensions.CodeAnalysis.MermaidVisualizers\ namespace to generate Mermaid flowcharts for code analysis results. \ArchitectureOverviewMermaidVisualizer\ generates a global architecture overview showing relationships between controllers, endpoints, commands, aggregates, and events. \ProcessingFlowMermaidVisualizer\ generates individual flowcharts for each independent processing chain (e.g., Controller -\> Command -\> Aggregate). \AggregateRelationMermaidVisualizer\ generates diagrams for aggregate relationships, correctly handling upstream and downstream dependencies. A helper class \MermaidVisualizerHelper\ provides utilities for sanitizing class names, escaping text, and mapping relationship types to labels.

src/NetCorePal.Extensions.CodeAnalysis/MermaidVisualizers · high confidence

The \NetCorePal.Extensions.CodeAnalysis.SourceGenerators\ library introduces a suite of new incremental source generators that automatically produce metadata about the application's command handling and domain event processing. Specifically, the diff adds generators for \CommandHandler\, \CommandSender\, \Controller\, \Endpoint\, \DomainEventHandler\, \DomainEvent\, \IntegrationEventHandler\, \Entity\, and \EntityMethod\ metadata. These generators scan the codebase to identify command handlers, controllers, endpoints, and entity classes, then generate corresponding \\[assembly: ...\]\ attributes (e.g., \CommandHandlerMetadataAttribute\, \EntityMetadataAttribute\) to expose structural information about the application's architecture at runtime.

src/NetCorePal.Extensions.CodeAnalysis.SourceGenerators · high confidence

The database-specific CAP extension methods (UseMySql, UsePostgreSql, UseSqlServer) and their associated transaction factories and classes are now marked as obsolete. Users should migrate to the generic UseNetCorePalStorage and NetCorePalCapTransaction/NetCorePalCapTransactionFactory instead. The deprecated methods will throw an InvalidOperationException if called after the new storage is registered, with messages guiding users to the new API.

src/NetCorePal.Extensions.DistributedTransactions.CAP.MySql, src/NetCorePal.Extensions.DistributedTransactions.CAP.PostgreSql, src/NetCorePal.Extensions.DistributedTransactions.CAP.SqlServer · high confidence

The code analysis tool now supports generating architecture visualizations in Markdown format, in addition to the existing HTML output. The tool also introduces a snapshot history feature that tracks architectural changes over time, similar to EF Core migrations. Users can now create snapshots of their project architecture, which are saved as C\# code files, and view historical comparisons. The tool also includes improved test project detection and dependency collection logic.

src/NetCorePal.Extensions.CodeAnalysis.Tools · high confidence

The code flow analysis snapshot mechanism has been refactored to use a new \CodeFlowAnalysisSnapshot\ abstract base class that stores \MetadataAttribute\ arrays, enabling the generation of C\# snapshot classes that preserve metadata. A helper class (\CodeFlowAnalysisSnapshotHelper\) now creates and generates these snapshots, while a new \SnapshotComparer\ allows users to compare two snapshots to identify added, removed, or unchanged nodes and relationships.

src/NetCorePal.Extensions.CodeAnalysis/Snapshots · medium confidence

The ABC.HelloWorld sample application, which previously provided a basic ASP.NET Core Web API template with Swagger support, has been removed from the samples directory. This includes all source files, configuration files, and build artifacts associated with that specific sample.

samples · high confidence

The repository has been reorganized with a new solution file format (.slnx) and updated build configuration files (Directory.Build.props, global.json) to support .NET 10. A new .runsettings file configures xUnit to run test assemblies sequentially (MaxParallelThreads=1) to control parallelism, and a localinstall.sh script is added to facilitate local installation of the code analysis tool. Additionally, .gitattributes and .dockerignore files are introduced to manage line endings and Docker build artifacts.

(repo-wide) · high confidence

The AppDbContextBaseSourceGenerator has been updated to traverse the entire inheritance chain when identifying DbContext base classes, ensuring that derived types are correctly recognized. This fix resolves issues where the generator failed to process DbContexts that inherit from a custom base class rather than directly from the expected base. Additionally, the generator now supports abstract classes and includes value converters for all strongly-typed IDs found in the current project and referenced assemblies.

src/NetCorePal.Extensions.Repository.EntityFrameworkCore.SourceGenerators · medium confidence

Add test infrastructure for Entity Framework Core; Add unit tests for CAP distributed transaction support with GaussDB; Added MongoDB integration tests for CAP distributed transactions; Added NetCorePal.Web test application with distributed tracing and JWT support; Added design-time DbContext factories and initial database migrations for ShardingCore unit tests; Added domain model test fixtures for Order, OrderItem, and various ID types; Added entity configuration tests for the web application; Added integration event handlers for order lifecycle; Added mock integration event handlers for unit tests; Added query handlers and test fixtures for order retrieval; Added repository test scaffolding for DeliverRecord and Order; Added test classes for advanced command and event handling scenarios; Added test console application scaffolding; Added test controllers for API endpoints; Added test coverage for application commands; Added test domain event models for order lifecycle; Added test for OrderCreatedDomainEventHandler; Added test for OrderCreatedIntegrationEventConverter; Added test stubs for Admin and Employee classes; Added unit and integration tests for CAP transaction handling with MySQL and PostgreSQL; Added unit and integration tests for Dameng (DMDB) database support; Added unit and integration tests for SQL Server CAP transaction handling; Added unit and integration tests for SQLite-based CAP storage; Added unit tests for Consul-based Snowflake ID generation; Added unit tests for EF Core repository and identity contexts; Added unit tests for JWT key rotation and setting store implementations; Added unit tests for K8s service discovery provider; Added unit tests for KingbaseES database support; Added unit tests for Mermaid visualizers; Added unit tests for code analysis tools; Added unit tests for code flow analysis and visualization builders; Added unit tests for command lock behavior and JSON converters; Added unit tests for conditional query extensions; Added unit tests for domain abstraction types; Added unit tests for integration event handling and service registration; Added unit tests for multi-environment service discovery and catalog API client; Added unit tests for multi-environment service discovery and integration event filtering; Added unit tests for service discovery abstractions; Added unit tests for source generators; Added unit tests for the mapper extension; Added unit tests for the web application; Cleaned up build artifacts for the unit test project; Internal visibility granted to unit test projects.

The project has been restructured to support .NET 8.0, 9.0, and 10.0 simultaneously. A new \Directory.Packages.props\ file introduces centralized package version management, defining specific versions for libraries such as Entity Framework Core, CAP, and various database providers (PostgreSQL, MySQL, SQL Server, MongoDB, GaussDB, KingbaseES, DMDB) for each target framework. This change ensures that all components within the solution use consistent, framework-specific versions of dependencies, simplifying maintenance and enabling compatibility across the three .NET versions.

(dependencies) · high confidence

Generated build artifacts for the ABC.AspNetCore.Gateway project have been removed from the repository. This includes the .NET 6.0 dependency resolution files (project.assets.json, NuGet spec files), assembly information files, and intermediate compilation outputs. These are typically generated during the build process and should not be committed to version control.

src/ABC.AspNetCore.Gateway · high confidence

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

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

• Code Health 80 → 75 (-5.0)
• Architecture 82 → 82 (-0.5)
• Maturity 73 → 73 (+0.2)
• Readiness 42 → 39 (-2.8)
• Security 56 → 61 (+5.7)
• Domain Modelling 100 → 99 (-1.4)
• Event-Driven 100 → 100 (+0.0)
• Accessibility 33 → 34 (+1.2)
• Performance 57 → 57 (+0.0)

• BarePragmaDisable (src/NetCorePal.Extensions.Hangfire/ContainerJobActivator.cs)
• Bounded contexts not declared
• Change coupling: AppIdentityDbContextBase.cs ↔ AppIdentityUserContextBase.cs (src/NetCorePal.Extensions.Repository.EntityFrameworkCore.Identity/AppIdentityDbContextBase.cs)
• Change coupling: EntityIdCodeGenerators.cs ↔ MermaidDomainCodeGenerators.cs (src/NetCorePal.Extensions.Domain.SourceGenerators/EntityIdCodeGenerators.cs)
• Duplicated block (11 lines × 2) (src/NetCorePal.Extensions.CodeAnalysis/CodeFlowAnalysisHelper.cs)
• Duplicated block (11 lines × 3) (src/NetCorePal.Extensions.Repository.EntityFrameworkCore.Identity/AppIdentityDbContextBase.cs)
• Duplicated block (11 lines × 4) (src/NetCorePal.Extensions.ShardingCore.SourceGenerators/AppDbContextShardingCoreSourceGenerator.cs)
• Duplicated block (12 lines × 2) (src/NetCorePal.Extensions.DistributedTransactions.CAP/Persistence/NetCorePalDataStorage.cs)
• Duplicated block (13 lines × 2) (src/NetCorePal.Extensions.CodeAnalysis.Tools/Program.cs)
• Duplicated block (13 lines × 2) (src/NetCorePal.Extensions.CodeAnalysis/VisualizationMarkdownBuilder.cs)
• Duplicated block (13 lines × 2) (src/NetCorePal.Extensions.DistributedTransactions.CAP.MongoDB/MongoDBNetCorePalDataStorage.cs)
• Duplicated block (13 lines × 2) (src/NetCorePal.Extensions.DistributedTransactions.CAP.MongoDB/MongoDBNetCorePalMonitoringApi.cs)
• Duplicated block (13 lines × 2) (src/NetCorePal.Extensions.DistributedTransactions.CAP.PostgreSql/EntityTypeConfigurations/PublishedMessageConfiguration.cs)
• Duplicated block (13 lines × 2) (src/NetCorePal.Extensions.DistributedTransactions.CAP.SourceGenerators/CapIntegrationConvertDomainEventHandlerSourceGenerator.cs)
• Duplicated block (13 lines × 2) (src/NetCorePal.Extensions.Repository.EntityFrameworkCore.Identity/AppIdentityDbContextBase.cs)
• Duplicated block (13 lines × 3) (src/NetCorePal.Extensions.ShardingCore.SourceGenerators/AppDbContextShardingCoreSourceGenerator.cs)
• Duplicated block (13 lines × 5) (src/NetCorePal.Extensions.DistributedTransactions.CAP.DMDB/EntityTypeConfigurations/PublishedMessageConfiguration.cs)
• Duplicated block (15 lines × 3) (src/NetCorePal.Extensions.ShardingCore.SourceGenerators/AppDbContextShardingCoreSourceGenerator.cs)
• Duplicated block (17 lines × 2) (src/NetCorePal.Extensions.DistributedTransactions.CAP.MongoDB/MongoDBNetCorePalDataStorage.cs)
• Duplicated block (17 lines × 2) (src/NetCorePal.Extensions.DistributedTransactions.CAP.MongoDB/MongoDBNetCorePalDataStorage.cs)
• …and 72 more

• Assertions commented out: Init_Should_Fail_When_Consul_Server_Fail (test/NetCorePal.Extensions.Snowflake.Redis.UnitTests/RedisWorkerIdGeneratorTests.cs)
• CommentedOutCode (src/NetCorePal.Extensions.DistributedTransactions.CAP.SourceGenerators/AppDbContextBaseCapDataStorageSourceGenerator.cs)
• CommentedOutCode (src/NetCorePal.Extensions.ServiceDiscovery.K8s/K8SServiceDiscoveryProvider.cs)
• CommentedOutCode (test/NetCorePal.Web.UnitTests/MyWebApplicationFactory.cs)
• CommentedOutCode (test/NetCorePal.Web/Program.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no project overview (README.md)
• Documentation: written for insiders (docs/content/zh/getting-started/project-structure.md)
• Duplicated block (10 lines × 2) (src/NetCorePal.Extensions.CodeAnalysis.SourceGenerators/EntityMetadataGenerator.cs)
• Duplicated block (10 lines × 3) (src/NetCorePal.Extensions.CodeAnalysis.Tools/Program.cs)
• Duplicated block (10 lines × 4) (src/NetCorePal.Extensions.DistributedTransactions.CAP.DMDB/EntityTypeConfigurations/ReceivedMessageConfiguration.cs)
• Duplicated block (10–11 lines × 2) (src/NetCorePal.Extensions.DistributedTransactions.CAP.MongoDB/EntityTypeConfigurations/PublishedMessageConfiguration.cs)
• Duplicated block (11 lines × 2) (src/NetCorePal.Extensions.CodeAnalysis.Tools/Program.cs)
• Duplicated block (11 lines × 2) (src/NetCorePal.Extensions.CodeAnalysis/CodeFlowAnalysisHelper.cs)
• Duplicated block (11 lines × 2) (src/NetCorePal.Extensions.ShardingCore/NetCorePalVirtualDataSourceRoute.cs)
• Duplicated block (11 lines × 2) (src/NetCorePal.Extensions.Snowflake.Consul/ConsulWorkerIdGenerator.cs)
• Duplicated block (11 lines × 6) (src/NetCorePal.Extensions.DistributedTransactions.CAP.DMDB/EntityTypeConfigurations/PublishedMessageConfiguration.cs)
• Duplicated block (11–15 lines × 3) (src/NetCorePal.Extensions.CodeAnalysis.SourceGenerators/ControllerMethodMetadataGenerator.cs)
• Duplicated block (11–16 lines × 2) (src/NetCorePal.Extensions.CodeAnalysis.Tools/Program.cs)
• …and 158 more

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

netcorepal/netcorepal-cloud-framework 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.