dotnet/reactive · error · ArgumentNullException

Value cannot be null. (Parameter 'source7')

Error message

Value cannot be null. (Parameter 'source7')

What it means

The 7-source Zip overload throws ArgumentNullException('source7') when the 7th (last) source observable is null. All sources must be non-null because the operator zips corresponding elements from each sequence.

Solutions

1. Provide a non-null IAsyncObservable for source7 or substitute AsyncObservable.Empty<T7>().
2. Drop to a 6-source Zip overload if the last stream is not needed.
3. Assert non-nullness of all sources in a helper that wraps Zip construction.

Example fix

// before
var result = AsyncObservable.Zip(a, b, c, d, e, f, lastStream);
// after
var result = lastStream == null
    ? AsyncObservable.Zip(a, b, c, d, e, f)
    : AsyncObservable.Zip(a, b, c, d, e, f, lastStream);

if (source7 == null) throw new InvalidOperationException("source7 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 == "source7")
{
    logger.LogError(ex, "7th zip source was null");
}

When it happens

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

Common situations: Trailing optional argument mistakenly left null instead of using a shorter overload; the last stream comes from a method whose null return wasn't handled; migrating code where an eighth overload arity changed and the final slot became null.

Related errors

• Value cannot be null. (Parameter 'source4')
• Value cannot be null. (Parameter 'source5')
• Value cannot be null. (Parameter 'source6')
• 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/66c49351fce65d7d. Report an issue: GitHub.

Appendix: source

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

            });
        }

        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();

                await Task.WhenAll(sub1, sub2, sub3, sub4, sub5, sub6, sub7).ConfigureAwait(false);

View on GitHub (pinned to 94b5d5ab91)