Skip to content
CAI
Software that uses CAICheck a score

dotnet/reactive

57.5

Adequate · 12 November 2026

229.4k

lines of production code

C#

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Added ApiCompare tool to validate LINQ Async API parity

A new command-line tool has been added to the Ix.NET source tree to automatically compare the public API surface of the synchronous System.Linq.Enumerable against the asynchronous System.Linq.AsyncEnumerable. The tool verifies that async operators are a superset of their sync counterparts, ensuring that no sync overloads are missing in the async implementation and flagging any excess or mismatched signatures. It includes built-in exclusions for specific methods like ForEachAsync and ToHashSet, and handles type substitutions between sync and async interfaces to accurately detect missing or extra API members.

Ix.NET/Source/ApiCompare · high confidence

Added Ix benchmarking project

A new \Benchmarks.System.Interactive\ subproject has been added to measure the performance of System.Interactive LINQ operators. It includes benchmarks for \Buffer\, \Defer\, \IgnoreElements\, \Retry\, and (on non-.NET 6+) \Min\/\Max\ variants, providing a baseline for future optimization efforts.

Ix.NET/Source/Benchmarks.System.Interactive · high confidence

Added performance benchmarking suite for FastEnumerable interfaces

A new program has been added to the FasterLinq project to benchmark and compare the performance of standard LINQ interfaces against the optimized FastEnumerable and AsyncFastEnumerable interfaces. This tool allows users to measure execution times for synchronous and asynchronous query operations, highlighting the performance differences between the standard implementations and the faster alternatives.

Ix.NET/Source/FasterLinq · high confidence

Import updated 'Introduction to Rx' documentation

The 'Introduction to Rx' book content has been imported into the repository, providing a comprehensive guide for users on reactive programming concepts, key types like \IObservable\<T\>\, and creating observable sequences. This documentation aligns with the \System.Reactive\ version 6.1 release and includes updates for new features such as the \TakeUntil(CancellationToken)\ overload, the \DisposeWith\ extension method, and the \ResetExceptionDispatchState\ operator.

Rx.NET · high confidence

Initial AsyncRx.NET Playground with sample implementations

The AsyncRx.NET/Playground project has been initialized with a Program.cs file containing a suite of commented-out sample methods. These samples demonstrate various asynchronous reactive patterns, including operators like Buffer (time-based hopping and sliding), Delay, GroupBy, Merge, and Range, as well as subject usage with ReplayAsyncSubject. This provides a local environment for developers to uncomment and test specific AsyncObservable behaviors. Also in this area: 1 commit (0 fixes) modifying AsyncRx.NET; Establish AsyncRx.NET build infrastructure and project structure; Introduce Async Reactive Extensions (AsyncRx.NET) for async-first observables; Initial AsyncRx.NET project structure and build configuration; Added API comparison tool to identify missing AsyncObservable methods.

AsyncRx.NET · medium confidence · unverified

Internal Task extension utilities and fair Merge implementation

The library introduces an internal \TaskExt\ class containing static helpers like \Never\ and \True\, and implements a new \WhenAny\ method for \ValueTask\ arrays. This implementation, guarded by the \USE\_FAIR\_AND\_CHEAPER\_MERGE\ flag, provides a fair and efficient mechanism for awaiting the completion of any task in a collection, which supports the concurrent \Merge\ operator. These changes are internal to the \System.Threading.Tasks\ namespace within the async interactive library and do not expose new public APIs.

Ix.NET/Source/System.Interactive.Async · high confidence

New Playground demo application and deprecation facade for System.Linq.Async

A new Playground console application has been added to the project, providing an interactive menu of demo methods that showcase LINQ operations on IEnumerable, IQueryable, and their async counterparts (IAsyncEnumerable/IAsyncQueryable) using both standard LINQ and Interactive Extensions. The application uses reflection to discover and invoke methods marked with a new internal DemoAttribute. Additionally, a deprecation facade is now enabled in the System.Linq.Async runtime assembly via a new assembly attribute, signaling the deprecation of the async enumerable types in favor of newer .NET standards.

Ix.NET/Source/Playground · high confidence

Removals

Removal of Interactive Extensions (Ix) source code and build infrastructure

The Interactive Extensions library and its associated build configuration have been removed from the repository. This change deletes the \Ix\ solution file, MSBuild targets (\Common.targets\, \Import.targets\), and test settings, along with the entire \System.Interactive.Async\ source code directory containing the async LINQ operators (such as \Aggregate\, \Count\, \Catch\, and \ToAsyncEnumerable\). Users will no longer have access to the \System.Interactive.Async\ package or its async enumeration capabilities through this codebase.

Ix · high confidence

Architecture

Build infrastructure and solution structure overhaul

The Ix.NET/Source location has been restructured to modernize the build pipeline and project organization. A new solution file (Ix.NET.sln) and a dedicated solution filter (System.Linq.Async.slnf) define the project hierarchy, separating library, test, and reference projects into logical groups. Build configuration is now centralized in Directory.Build.props and Directory.Build.targets, enabling global settings such as nullable reference types, embedded debug symbols, and source link. The project has adopted Nerdbank.GitVersioning (version 3.8.118) for automated versioning and Microsoft.SourceLink.GitHub (version 1.1.1) for source indexing. Additionally, an .editorconfig file enforces naming conventions for internal and protected fields, and a T4 template (AsyncQueryableGenerator.t4) is introduced to generate async overloads for LINQ methods.

Ix.NET/Source · high confidence

Behavioural changes

Added assembly metadata for System.Linq.Async.Queryable

The System.Linq.Async.Queryable assembly now includes explicit metadata configuration via a new AssemblyInfo.cs file. This sets the neutral resources language to en-US, disables COM visibility, and declares the assembly as CLS-compliant, ensuring consistent runtime behavior and interoperability characteristics for consumers of the library.

Ix.NET/Source/System.Linq.Async.Queryable/Properties · high confidence

Added runtime directives to support AOT compilation

The System.Interactive and System.Interactive.Async libraries now include .rd.xml files that configure the runtime linker to preserve all types for dynamic reflection. This change ensures that the libraries function correctly in environments using Ahead-of-Time (AOT) compilation or aggressive trimming, where reflection-based code might otherwise be stripped.

Ix.NET/Source/System.Interactive.Async/Properties, Ix.NET/Source/System.Interactive/Properties · high confidence

Async LINQ operators migrated to System.Linq.AsyncEnumerable with deprecation of legacy System.Linq.Async

The standard LINQ operators (such as Aggregate, All, Any, Append, Prepend, Cast, and Average) in the System.Linq.Async library have been rewritten to align with the new System.Linq.AsyncEnumerable API. For users, this means that legacy methods like AggregateAwaitAsync or AllAwaitAsync are now obsolete and will direct you to use the new AggregateAsync or AllAsync overloads instead. The new implementations utilize async iterators and ValueTask for better performance and ergonomics, while maintaining backward compatibility through conditional compilation flags like INCLUDE\_SYSTEM\_LINQ\_ASYNCENUMERABLE\_DUPLICATES for existing codebases.

Ix.NET/Source/System.Linq.Async/System/Linq/Operators · high confidence

AsyncQueryable API adopts ValueTask and deep cancellation support

The AsyncQueryable queryable operators have been updated to return ValueTask instead of Task, improving performance and ergonomics for async LINQ queries. The API surface now includes deep cancellation support, allowing cancellation tokens to be passed into accumulator and selector expressions (e.g., AggregateAwaitWithCancellationAsync). Additionally, the query provider's ExecuteAsync method and enumerator now support cancellation, and nullable reference types have been enabled across the generated and core queryable files.

Ix.NET/Source/System.Linq.Async.Queryable/System · high confidence

AsyncQueryableEx surface updated with ValueTask-based aggregates and nullable support

The AsyncQueryableEx API surface has been regenerated to improve ergonomics and type safety. Aggregate operators such as AverageAsync now return ValueTask instead of Task, allowing for more efficient asynchronous execution when used in query expressions. The generated code also enables nullable reference types and allows null values for comparer parameters, while caching reflection information to improve performance.

Ix.NET/Source/System.Interactive.Async.Providers/System · high confidence

Internal refactoring of async enumeration helpers

This change introduces internal helper classes within the System.Threading.Tasks namespace to support async enumeration operations. Specifically, it adds AsyncEnumerableExt to manage configured async enumerators with cancellation and context capture, and TaskExt to provide a pre-completed TaskCompletionSource\<bool\> instance. These are internal implementation details intended to optimize the underlying async machinery rather than expose new public capabilities.

Ix.NET/Source/System.Linq.Async/System/Threading · high confidence

Migration of LINQ operators to System.Interactive.Async and introduction of Amb operator

The \System.Interactive.Async\ package now hosts a comprehensive set of LINQ operators (including \Amb\, \Buffer\, \Catch\, \Concat\, and \AverageAsync\ with async selectors) that were previously defined in the deprecated \System.Linq.Async\ package. This change ensures these features remain available after removing the \System.Linq.Async\ dependency, while also introducing the \Amb\ operator to propagate the first-reacting async-enumerable sequence and adding support for async selectors in aggregation operators like \AverageAsync\.

Ix.NET/Source/System.Interactive.Async/System · high confidence

Migration of System.Interactive.Async internals to System.Linq.Async

The core implementation files from System.Interactive.Async (such as AsyncEnumerableHelpers, Disposables, and partitioning logic) have been moved into the System.Linq.Async namespace. This change includes updating the license headers from Apache 2.0 to MIT, renaming internal interfaces like IIListProvider to IAsyncIListProvider, and modernizing the codebase to use C\# 8.0 features (e.g., ValueTask, using declarations, and pattern matching).

Ix.NET/Source/System.Linq.Async/System/Linq · high confidence

QueryableEx refactored with MinByWithTies and MaxByWithTies support

The QueryableEx API has been restructured to support new MinByWithTies and MaxByWithTies methods that return a list of elements sharing the minimum or maximum key value, addressing a previous limitation where MinBy/MaxBy returned only a single element. This change includes splitting the QueryableEx class into separate files (QueryableEx.cs and QueryableEx.Generated.cs), removing legacy CRIPPLED\_REFLECTION conditional compilation blocks in favor of standard reflection, and updating the license from Apache 2.0 to MIT. The implementation now uses a QueryProviderShim to redirect expression calls, ensuring consistent behavior across different .NET platforms.

Ix.NET/Source/System.Interactive.Providers/System · high confidence

Refactored source generator to support .NET 10 API migration and deprecation facades

The System.Linq.Async.SourceGenerator has been split into multiple focused files to support the migration to .NET 10's System.Linq.AsyncEnumerable. It now generates async overloads for methods marked with \[GenerateAsyncOverload\] and creates a new AsyncEnumerableDeprecated facade class. This facade ensures binary backward compatibility by duplicating obsolete extension methods, allowing existing code to continue compiling with deprecation warnings while the library moves away from the AsyncEnumerable type name to avoid conflicts with the new .NET 10 runtime types.

Ix.NET/Source/System.Linq.Async.SourceGenerator · high confidence

Restructure LINQ operators and introduce MinByWithTies/MaxByWithTies

The LINQ operator implementations in System.Interactive have been reorganized into the System/Linq/Operators directory, with many files renamed and modernized (e.g., adopting primary constructors and null-forgiving operators). A new MinByWithTies and MaxByWithTies API is added to return all elements sharing the minimum or maximum key, addressing behavior changes in .NET 6+ where standard MinBy/MaxBy return single values. The original MinBy/MaxBy methods are now obsolete and delegate to these new methods. Additionally, Distinct and DistinctUntilChanged have been split into separate files, and various operators (Buffer, Catch, Concat, Do, etc.) have been refactored for consistency and modern C\# features.

Ix.NET/Source/System.Interactive/System/Linq/Operators · high confidence

Restructures System.Linq namespace with new async interfaces and refactored yielder

The System.Interactive library has reorganized its internal structure within the System.Linq namespace, introducing new interfaces IAwaitable and IAwaiter to support asynchronous enumeration patterns, alongside IBuffer and IRefCountList for managing shared enumerable views. The existing Yielder implementation has been refactored to implement these new interfaces, simplifying its code structure and removing unused members like Reset and explicit GetAwaiter wrappers. Additionally, the license header for these files has been updated from Apache 2.0 to MIT.

Ix.NET/Source/System.Interactive/System/Linq · high confidence

Updated API approval snapshots for System.Interactive and System.Interactive.Async

The API approval test files for System.Interactive and System.Interactive.Async have been updated to reflect the current public surface area. The synchronous EnumerableEx API now includes new MaxByWithTies and MinByWithTies methods, while the original MaxBy and MinBy methods are marked obsolete with messages directing users to the new methods for behavior consistent with .NET 6 and later. The asynchronous AsyncEnumerableEx API has been expanded with numerous new overloads for AverageAsync, SumAsync, MaxByAsync, MinByAsync, and MaxByWithTiesAsync/MinByWithTiesAsync that support async selectors and cancellation tokens. Additionally, several Distinct overloads in the async API are now marked obsolete, recommending the use of DistinctBy instead.

Ix.NET/Source/Tests.System.Interactive.ApiApprovals · high confidence

Updated assembly metadata and added runtime directives for .NET Native

The library's assembly metadata has been updated to reflect the .NET Foundation copyright and MIT license, with ComVisible set to false. Additionally, a new runtime directives (.rd.xml) file has been added to enable dynamic reflection for the assembly, which is necessary for .NET Native compilation scenarios.

Ix.NET/Source/System.Interactive.Async.Providers/Properties · high confidence

Updated assembly metadata and added runtime directives for AOT compatibility

The System.Interactive.Providers assembly now includes explicit metadata attributes for neutral language and COM visibility, and introduces a runtime directives (.rd.xml) file. This configuration enables dynamic reflection for the entire assembly, which is necessary to support Ahead-of-Time (AOT) compilation scenarios where the linker might otherwise strip required types.

Ix.NET/Source/System.Interactive.Providers/Properties · high confidence

Updated assembly metadata and license header

The assembly metadata for System.Linq.Async has been updated to include a standard .NET Foundation license header specifying the MIT License. Additionally, the assembly is now explicitly marked as CLS-compliant and ComVisible is set to false, ensuring stricter compliance and better interoperability for consumers of the library.

Ix.NET/Source/System.Linq.Async/Properties · high confidence

Test coverage

Added Rx Gauntlet test suite for dependency and deployment scenarios; Added base test class for AsyncEnumerableEx tests; Added empty placeholder files for Rx-PlatformServices test package targets; Added integration test projects for multiple target frameworks; Added test coverage for AsyncQueryable operations; Added test infrastructure for ValueTask support; Added tests for AsyncQueryableEx operators with ValueTask support; Added tests for async disposal and refactored test infrastructure; Added tests for async enumerable naming conventions and optimization behaviors; Added unit tests for AsyncEnumerableEx operators; Added unit tests for LINQ operators; Expanded test coverage for System.Linq.Async operators; Test infrastructure reorganization and configuration.

Dependencies

Upgrade to .NET 10 and align dependencies with System.Linq.AsyncEnumerable

The project now targets .NET 10.0 alongside .NET 8.0 and .NET 9.0, with specific build configurations to handle the built-in \System.Linq.AsyncEnumerable\ in .NET 10. To support this, \System.Linq.AsyncEnumerable\ is explicitly referenced as version 10.0.6 for non-.NET 10 targets, and test projects have been updated to use xUnit 2.9.3, xUnit runner 3.1.5, and Microsoft.NET.Test.Sdk 18.0.0. Additionally, \System.Reactive\ is updated to version 6.0.0 in the Async library, and \BenchmarkDotNet\ is upgraded to 0.15.4 for performance testing.

(dependencies) · 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 55 → 57 (+2.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 59 → 63 (+4.0)
  • Architecture 99 → 70 (-28.6)
  • Maturity 61 → 79 (+17.4)
  • Readiness 45 → 45 (-0.0)
  • Security 70 → 81 (+11.6)
  • Performance 81 → 75 (-6.1)

Resolved (234)

  • ADR not followed: Migration of core IAsyncEnumerable<T> LINQ to runtime libraries (Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md)
  • AsyncObserver.Buffer (cyclomatic 17) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Buffer.cs)
  • Concentrated knowledge decay
  • Coverage not measured — no coverage collector is wired up
  • Duplicated block (11 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/SkipUntil.cs)
  • Duplicated block (12 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/TakeLast.cs)
  • Duplicated block (12 lines × 3) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Catch.cs)
  • Duplicated block (15 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Catch.cs)
  • Duplicated block (15 lines × 3) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Catch.cs)
  • Duplicated block (16 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Last.cs)
  • Duplicated block (16 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/While.cs)
  • Duplicated block (17 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/GroupByUntil.cs)
  • Duplicated block (19 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/DoWhile.cs)
  • Duplicated block (19 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Join.cs)
  • Duplicated block (19 lines × 2) (AsyncRx.NET/System.Reactive.Async/Subjects/AsyncAsyncSubject.cs)
  • Duplicated block (20 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Using.cs)
  • Duplicated block (21 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Single.cs)
  • Duplicated block (21 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/SkipUntil.cs)
  • Duplicated block (21 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Using.cs)
  • Duplicated block (24 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Concat.cs)
  • …and 214 more

New (485)

  • ADR declares no status (Rx.NET/Documentation/adr/0009-nbgv-usage.md)
  • ArgumentChecks.Check (cognitive 42) (AsyncRx.NET/Tests.System.Reactive.Shared/Harness/ArgumentChecks.cs)
  • ArgumentChecks.Check (cyclomatic 16) (AsyncRx.NET/Tests.System.Reactive.Shared/Harness/ArgumentChecks.cs)
  • AsyncObservable.RefCount (cognitive 19) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/RefCount.cs)
  • AsyncObservable.RefCount (cognitive 23) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/RefCount.cs)
  • AsyncObservable.RefCount (cyclomatic 19) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/RefCount.cs)
  • AsyncObserver.CombineLatest (cognitive 18) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/CombineLatest.cs)
  • AsyncObserver.DelayCore (cognitive 40) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Delay.cs)
  • AsyncObserver.DelayCore (cyclomatic 25) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/Delay.cs)
  • AsyncObserver.GroupJoin (cyclomatic 16) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/GroupJoin.cs)
  • AsyncObserver.ObserveOn (cognitive 23) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/ObserveOn.cs)
  • AsyncObserver.ObserveOn (cyclomatic 20) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/ObserveOn.cs)
  • AsyncObserver.SelectMany (cognitive 17) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/SelectMany.cs)
  • BarePragmaDisable (AsyncRx.NET/Tests.System.Reactive.Shared/Scenarios/FromEventPattern_VarianceCheck.cs)
  • DescriptionBridge.ToReal (cognitive 28) (AsyncRx.NET/Tests.System.Reactive.Shared/Harness/DescriptionBridge.cs)
  • DescriptionBridge.ToReal (cyclomatic 30) (AsyncRx.NET/Tests.System.Reactive.Shared/Harness/DescriptionBridge.cs)
  • Documentation: no build, run or usage example (Rx.NET/tools/HomoIcon/README.md)
  • Dummies.TryCreate (cognitive 34) (AsyncRx.NET/Tests.System.Reactive.Shared/Harness/Dummies.cs)
  • Dummies.TryCreate (cyclomatic 31) (AsyncRx.NET/Tests.System.Reactive.Shared/Harness/Dummies.cs)
  • Duplicated block (12 lines × 2) (AsyncRx.NET/System.Reactive.Async/Linq/Operators/CombineLatest.cs)
  • …and 465 more

Changes since last survey

  • 1 commits — 1 feature/other, 0 fixes

By area

  • AsyncRx.NET/Tests.System.Reactive.Shared — 1 commit

Notable commits

  • change: Shared Rx/AsyncRx test suite (#2342)

Architecture

  • Unchanged — 6 containers · 0 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

dotnet/reactive 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 12 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 d257d1b58fe3f0ec194ed9f6235fa5a0da180bf0 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — 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.42+preprod-6bc2a431cb25.