dotnet/reactive · error · ArgumentNullException

Value cannot be null. (Parameter 'source6')

Error message

Value cannot be null. (Parameter 'source6')

What it means

The 7-source Zip overload throws ArgumentNullException('source6') when the 6th source observable is null. Validation runs synchronously at operator construction, so nothing is subscribed and the exception surfaces immediately at the Zip call site.

Solutions

1. Pass a valid IAsyncObservable for source6, or AsyncObservable.Empty<T6>() if absence is expected.
2. Validate all seven sources with a guard loop before composing.
3. Use a lower-arity overload when fewer than seven streams are involved.

Example fix

// before
var zip7 = AsyncObservable.Zip(s1, s2, s3, s4, s5, GetSixth(), s7);
// after
var sixth = GetSixth() ?? AsyncObservable.Empty<T6>();
var zip7 = AsyncObservable.Zip(s1, s2, s3, s4, s5, sixth, s7);

if (source6 == null) throw new InvalidOperationException("source6 must be non-null");

bool IsValidZipInput<T>(IAsyncObservable<T> s) => s is not null;

try
{
    var zipped = AsyncObservable.Zip(s1, s2, s3, s4, s5, s6, s7);
}
catch (ArgumentNullException ex) when (ex.ParamName == "source6")
{
    logger.LogError(ex, "6th zip source was null");
}

When it happens

Trigger: Calling AsyncObservable.Zip(source1, source2, source3, source4, source5, null, source7) with a null sixth IAsyncObservable argument.

Common situations: A configuration-driven pipeline where the sixth source's factory failed and returned null; DI wiring where an optional dependency was not registered; test code passing null as a placeholder for unused streams.

Related errors

• Value cannot be null. (Parameter 'source4')
• Value cannot be null. (Parameter 'source5')
• Value cannot be null. (Parameter 'source7')
• Value cannot be null. (Parameter 'selector')
• Value cannot be null. (Parameter 'source1')

AI-assisted analysis of dotnet/reactive@94b5d5ab91 (2026-09-15). Data as JSON: /api/errors/4272febe0735c11c. Report an issue: GitHub.

Appendix: source

Thrown at AsyncRx.NET/System.Reactive.Async/Linq/Operators/Zip.Generated.cs:504

                return d;
            });
        }

        public static IAsyncObservable<TResult> Zip<T1, T2, T3, T4, T5, T6, T7, TResult>(this IAsyncObservable<T1> source1, IAsyncObservable<T2> source2, IAsyncObservable<T3> source3, IAsyncObservable<T4> source4, IAsyncObservable<T5> source5, IAsyncObservable<T6> source6, IAsyncObservable<T7> source7, Func<T1, T2, T3, T4, T5, T6, T7, TResult> selector)
        {
            if (source1 == null)
                throw new ArgumentNullException(nameof(source1));
            if (source2 == null)
                throw new ArgumentNullException(nameof(source2));
            if (source3 == null)
                throw new ArgumentNullException(nameof(source3));
            if (source4 == null)
                throw new ArgumentNullException(nameof(source4));
            if (source5 == null)
                throw new ArgumentNullException(nameof(source5));
            if (source6 == null)
                throw new ArgumentNullException(nameof(source6));
            if (source7 == null)
                throw new ArgumentNullException(nameof(source7));
            if (selector == null)
                throw new ArgumentNullException(nameof(selector));

            return Create<TResult>(async observer =>
            {
                var d = new CompositeAsyncDisposable();

                var (observer1, observer2, observer3, observer4, observer5, observer6, observer7) = AsyncObserver.Zip(observer, selector);

                var sub1 = source1.SubscribeSafeAsync(observer1).AsTask().ContinueWith(disposable => d.AddAsync(disposable.Result).AsTask()).Unwrap();
                var sub2 = source2.SubscribeSafeAsync(observer2).AsTask().ContinueWith(disposable => d.AddAsync(disposable.Result).AsTask()).Unwrap();
                var sub3 = source3.SubscribeSafeAsync(observer3).AsTask().ContinueWith(disposable => d.AddAsync(disposable.Result).AsTask()).Unwrap();
                var sub4 = source4.SubscribeSafeAsync(observer4).AsTask().ContinueWith(disposable => d.AddAsync(disposable.Result).AsTask()).Unwrap();
                var sub5 = source5.SubscribeSafeAsync(observer5).AsTask().ContinueWith(disposable => d.AddAsync(disposable.Result).AsTask()).Unwrap();
                var sub6 = source6.SubscribeSafeAsync(observer6).AsTask().ContinueWith(disposable => d.AddAsync(disposable.Result).AsTask()).Unwrap();
                var sub7 = source7.SubscribeSafeAsync(observer7).AsTask().ContinueWith(disposable => d.AddAsync(disposable.Result).AsTask()).Unwrap();

View on GitHub (pinned to 94b5d5ab91)