[Bug]: Ambiguity between ReactiveUI.Primitives and System.Reactive extension methods

[MartinFayRAX]

Prerequisites

• I have searched open and closed issues for duplicates.
• I am using the latest stable release.

Describe the bug 🐞

Recreating this because I think there really might be an issue. Because ObservableExtensions is in System this clash will be triggered by "normal" use of global usings for System and ReactiveUI.Primitives.

I'm working on adoption of ReactiveUI 24, and have turned up this error, I think due to referencing both ReactiveUI 24 and DynamicData (which is pulling in System.Reactive):

The call is ambiguous between the following methods or properties: 'ReactiveUI.Primitives.SubscribeExtensions.extension<System.Exception>(System.IObservable<System.Exception>).Subscribe(System.Action<System.Exception>)' and 'System.ObservableExtensions.Subscribe(System.IObservable, System.Action)'

I can work around this by explicitly calling SubscribeExtensions.Subscribe(), however any thoughts on how best at deal with this?

Steps to reproduce

Code along the lines of:
this.SaveCommand.ThrownExceptions.Subscribe(e => activity.AddItem(e.ToString()));

With:
Both ReactiveUI 24 and System.Reactive referenced
Both SubscribeExtensions and ObservableExtensions are in scope

Reproduction repository

No response

Expected behavior

No ambiguity.

Screenshots 🖼️

No response

IDE

Visual Studio 2026

.NET version

.NET 10

Target framework(s)

net10.0

Operating system

Windows

OS version

No response

Device

No response

ReactiveUI version

21.1.0

Additional information ℹ️

ReactiveUI.Primitives 7.1.1

[SlyCedix]

Experiencing the same thing. Trying to use DynamicData so I'm including in ReactiveUI.Routing but DynamicData includes System.Reactive which breaksing the ReactiveUI.Primitives ecosystem.

I've been trying to find a way to "hide" System.Reactive from references but I'm not finding anything I can use.

Edit: The resolution for extension methods prioritizes namespace local extensions first. Because of this, creating an extension class which calls the methods directly seems to work.

public static class DisambiguationExtensions
{

    /// <inheritdoc cref="SubscribeExtensions.Subscribe{T}(IObservable{T})"/>
    public static IDisposable Subscribe<T>(this IObservable<T> source)
        where T : notnull
        => SubscribeExtensions.Subscribe(source);

    /// <inheritdoc cref="SubscribeExtensions.Subscribe{T}(IObservable{T}, Action{T})"/>
    public static IDisposable Subscribe<T>(this IObservable<T> source, Action<T> action)
        where T : notnull
        => SubscribeExtensions.Subscribe(source, action);

    /// <inheritdoc cref="SubscribeExtensions.Subscribe{T}(IObservable{T}, Action{T}, Action{Exception})"/>
    public static IDisposable Subscribe<T>(this IObservable<T> source, Action<T> onNext, Action<Exception> onError)
        where T : notnull
        => SubscribeExtensions.Subscribe(source, onNext, onError);

    /// <inheritdoc cref="SubscribeExtensions.Subscribe{T}(IObservable{T}, Action{T}, Action)"/>
    public static IDisposable Subscribe<T>(this IObservable<T> source, Action<T> onNext, Action onCompleted)
        where T : notnull
        => SubscribeExtensions.Subscribe(source, onNext, onCompleted);

    /// <inheritdoc cref="SubscribeExtensions.Subscribe{T}(IObservable{T}, Action{T}, Action{Exception}, Action)"/>
    public static IDisposable Subscribe<T>(
            this IObservable<T> source,
            Action<T>           onNext,
            Action<Exception>   onError,
            Action              onCompleted)
            where T : notnull
        => SubscribeExtensions.Subscribe(
                source,
                onNext,
                onError,
                onCompleted);
}

Unfortunately, this seems to only work when directly inside the exact same namespace, so if you use multiple namespaces you need to implement this for each one.

[SlyCedix]

Found an alternative method.

If you format your file as follows:

using System;

namespace Your.Namespace {
    using ReactiveUI.Primitives;

    // ...
}

The usings in the innermost namespace block will be prioritized, so you'll automatically use ReactiveUI.Primitives. It's a bit clunky but less so than having to directly call every subscribe, imo.

This should definitely be fixed, but I'm not sure how one would go about doing so without completely renaming "Subscribe" and other conflicting methods. It's already been done with ISequencer and Signal. ReactiveUI can't control what other packages do dependency wise, and if System.Reactive ends up included then things break.

I do rely on DynamicData pretty heavily so I may just have to switch to the ReactiveUI.Reactive. A ReactiveUI.DynamicData package would be welcome with the backend swapped out for the ReactiveUI.Primitives as its the only reason I have System.Reactive at all. No idea how much of an undertaking that would be, I might take a look at it.

[MartinFayRAX]

Thank you for the namespace workaround SlyCedix, this is fairly tolerable.

I agree on DynamicData!

FYI ReactiveUI.Primitives-backed versions of ReactiveMarbles.ObservableEvents.SourceGenerator (reactivemarbles/ObservableEvents#268) and ReactiveUI.SourceGenerators (reactiveui/ReactiveUI.SourceGenerators#469) are already on the way.