dotnet/reactive
57.5
Adequate · 12 November 2026
229.4k
lines of production code
C#
primary language
6
measurements over time
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.