Dispose IAsyncEnumerable enumerators inline during property-based JSON serialization

[Copilot]

Description

DisposeAsync() was never invoked for property-based IAsyncEnumerable<T> during async JSON serialization. Enumerators were queued into a CompletedAsyncDisposables list and only disposed after the entire object finished serializing — meaning sibling IAsyncEnumerable<T> properties would start enumeration before prior enumerators were disposed. This caused resource leaks, most visibly with EF Core where PostgreSQL connections remained open.

// Second property's enumeration starts before first's enumerator is disposedawaitJsonSerializer.SerializeAsync(stream,new{A=dbContext.Products.Where(p =>p.Id%2==0).AsAsyncEnumerable(),B=dbContext.Products.Where(p =>p.Id%2!=0).AsAsyncEnumerable(),// fails: connection still open from A});

Changes

• IAsyncEnumerableOfTConverter.OnWriteResume: Call DisposeAsync() inline when enumeration completes. If the resulting ValueTask is pending, store it as PendingTask and yield to the root serialization loop — mirroring how MoveNextAsync() pending tasks are already handled. Refactored to use a switch over the new AsyncEnumeratorState enum for clearer state transitions.
• WriteStackFrame: Replace AsyncEnumeratorIsPendingCompletion and AsyncEnumeratorIsPendingDisposal boolean fields with a single AsyncEnumeratorState enum field. Rename AsyncDisposable to AsyncEnumerator (typed as object?) to better reflect that it always stores an IAsyncEnumerator<T> instance, used for enumerator retrieval between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.
• AsyncEnumeratorState: New enum with values None, Enumerating, PendingMoveNext, and PendingDisposal to track the async enumerator's lifecycle within a stack frame.
• WriteStack: Remove CompletedAsyncDisposables field, AddCompletedAsyncDisposable(), and DisposeCompletedAsyncDisposables() — no longer needed. Update DisposePendingDisposablesOnExceptionAsync to pattern-match AsyncEnumerator on IAsyncDisposable for exception cleanup.
• JsonTypeInfoOfT.WriteHelpers.cs: Remove deferred CompletedAsyncDisposables disposal from the root serialization loop finally block.
• Build compatibility fix: Replace UnreachableException usage in IAsyncEnumerableOfTConverter with InvalidOperationException("Invalid async enumerator state.") to avoid build breaks on target frameworks where UnreachableException is unavailable.
• Build break follow-up fix: Replace _ = disposeTask.Result with disposeTask.GetAwaiter().GetResult() in the synchronous disposal path, since non-generic ValueTask has no Result property.
• Tests: Add tests covering prompt disposal ordering of sibling properties, nested async enumerables, empty enumerables, truly async disposal paths, and DisposeAsync exception propagation.
• Test synchronization hardening: Update disposal-ordering tests to use explicit state-based synchronization callbacks between enumerators (instead of timing/order assertions on event list writes), reducing flakiness risk.
• Pending-then-faulted disposal coverage: Extend ThrowingDisposeAsyncEnumerable tests to also cover the async fault path (await Task.Yield(); throw ...) so the PendingDisposal suspend/resume exception propagation path is validated.

[eiriktsarpalis]

@copilot do we need to get rid of

[Copilot]

@copilot do we need to get rid of

If this is about CompletedAsyncDisposables — yes, it was already removed in the initial commit (287f2c5). If about AsyncDisposable — see my reply on the other thread; it's still needed for enumerator storage between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.

[Copilot]

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 1 comment.

[Copilot]

Description

DisposeAsync() was never invoked for property-based IAsyncEnumerable<T> during async JSON serialization. Enumerators were queued into a CompletedAsyncDisposables list and only disposed after the entire object finished serializing — meaning sibling IAsyncEnumerable<T> properties would start enumeration before prior enumerators were disposed. This caused resource leaks, most visibly with EF Core where PostgreSQL connections remained open.

// Second property's enumeration starts before first's enumerator is disposedawaitJsonSerializer.SerializeAsync(stream,new{A=dbContext.Products.Where(p =>p.Id%2==0).AsAsyncEnumerable(),B=dbContext.Products.Where(p =>p.Id%2!=0).AsAsyncEnumerable(),// fails: connection still open from A});

Changes

• IAsyncEnumerableOfTConverter.OnWriteResume: Call DisposeAsync() inline when enumeration completes. If the resulting ValueTask is pending, store it as PendingTask and yield to the root serialization loop — mirroring how MoveNextAsync() pending tasks are already handled. Refactored to use a switch over the new AsyncEnumeratorState enum for clearer state transitions.
• WriteStackFrame: Replace AsyncEnumeratorIsPendingCompletion and AsyncEnumeratorIsPendingDisposal boolean fields with a single AsyncEnumeratorState enum field. Rename AsyncDisposable to AsyncEnumerator (typed as object?) to better reflect that it always stores an IAsyncEnumerator<T> instance, used for enumerator retrieval between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.
• AsyncEnumeratorState: New enum with values None, Enumerating, PendingMoveNext, and PendingDisposal to track the async enumerator's lifecycle within a stack frame.
• WriteStack: Remove CompletedAsyncDisposables field, AddCompletedAsyncDisposable(), and DisposeCompletedAsyncDisposables() — no longer needed. Update DisposePendingDisposablesOnExceptionAsync to pattern-match AsyncEnumerator on IAsyncDisposable for exception cleanup.
• JsonTypeInfoOfT.WriteHelpers.cs: Remove deferred CompletedAsyncDisposables disposal from the root serialization loop finally block.
• Build compatibility fix: Replace UnreachableException usage in IAsyncEnumerableOfTConverter with InvalidOperationException("Invalid async enumerator state.") to avoid build breaks on target frameworks where UnreachableException is unavailable.
• Build break follow-up fix: Replace _ = disposeTask.Result with disposeTask.GetAwaiter().GetResult() in the synchronous disposal path, since non-generic ValueTask has no Result property.
• Tests: Add tests covering prompt disposal ordering of sibling properties, nested async enumerables, empty enumerables, truly async disposal paths, and DisposeAsync exception propagation.
• Test synchronization hardening: Update disposal-ordering tests to use explicit state-based synchronization callbacks between enumerators (instead of timing/order assertions on event list writes), reducing flakiness risk.
• Pending-then-faulted disposal coverage: Extend ThrowingDisposeAsyncEnumerable tests to also cover the async fault path (await Task.Yield(); throw ...) so the PendingDisposal suspend/resume exception propagation path is validated.

[eiriktsarpalis]

@copilot do we need to get rid of

[Copilot]

@copilot do we need to get rid of

If this is about CompletedAsyncDisposables — yes, it was already removed in the initial commit (287f2c5). If about AsyncDisposable — see my reply on the other thread; it's still needed for enumerator storage between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.

[Copilot]

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 1 comment.

[Copilot]

Description

DisposeAsync() was never invoked for property-based IAsyncEnumerable<T> during async JSON serialization. Enumerators were queued into a CompletedAsyncDisposables list and only disposed after the entire object finished serializing — meaning sibling IAsyncEnumerable<T> properties would start enumeration before prior enumerators were disposed. This caused resource leaks, most visibly with EF Core where PostgreSQL connections remained open.

// Second property's enumeration starts before first's enumerator is disposedawaitJsonSerializer.SerializeAsync(stream,new{A=dbContext.Products.Where(p =>p.Id%2==0).AsAsyncEnumerable(),B=dbContext.Products.Where(p =>p.Id%2!=0).AsAsyncEnumerable(),// fails: connection still open from A});

Changes

• IAsyncEnumerableOfTConverter.OnWriteResume: Call DisposeAsync() inline when enumeration completes. If the resulting ValueTask is pending, store it as PendingTask and yield to the root serialization loop — mirroring how MoveNextAsync() pending tasks are already handled. Refactored to use a switch over the new AsyncEnumeratorState enum for clearer state transitions.
• WriteStackFrame: Replace AsyncEnumeratorIsPendingCompletion and AsyncEnumeratorIsPendingDisposal boolean fields with a single AsyncEnumeratorState enum field. Rename AsyncDisposable to AsyncEnumerator (typed as object?) to better reflect that it always stores an IAsyncEnumerator<T> instance, used for enumerator retrieval between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.
• AsyncEnumeratorState: New enum with values None, Enumerating, PendingMoveNext, and PendingDisposal to track the async enumerator's lifecycle within a stack frame.
• WriteStack: Remove CompletedAsyncDisposables field, AddCompletedAsyncDisposable(), and DisposeCompletedAsyncDisposables() — no longer needed. Update DisposePendingDisposablesOnExceptionAsync to pattern-match AsyncEnumerator on IAsyncDisposable for exception cleanup.
• JsonTypeInfoOfT.WriteHelpers.cs: Remove deferred CompletedAsyncDisposables disposal from the root serialization loop finally block.
• Build compatibility fix: Replace UnreachableException usage in IAsyncEnumerableOfTConverter with InvalidOperationException("Invalid async enumerator state.") to avoid build breaks on target frameworks where UnreachableException is unavailable.
• Build break follow-up fix: Replace _ = disposeTask.Result with disposeTask.GetAwaiter().GetResult() in the synchronous disposal path, since non-generic ValueTask has no Result property.
• Tests: Add tests covering prompt disposal ordering of sibling properties, nested async enumerables, empty enumerables, truly async disposal paths, and DisposeAsync exception propagation.
• Test synchronization hardening: Update disposal-ordering tests to use explicit state-based synchronization callbacks between enumerators (instead of timing/order assertions on event list writes), reducing flakiness risk.
• Pending-then-faulted disposal coverage: Extend ThrowingDisposeAsyncEnumerable tests to also cover the async fault path (await Task.Yield(); throw ...) so the PendingDisposal suspend/resume exception propagation path is validated.

[eiriktsarpalis]

@copilot do we need to get rid of

[Copilot]

@copilot do we need to get rid of

If this is about CompletedAsyncDisposables — yes, it was already removed in the initial commit (287f2c5). If about AsyncDisposable — see my reply on the other thread; it's still needed for enumerator storage between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.

[Copilot]

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 1 comment.

[Copilot]

Description

DisposeAsync() was never invoked for property-based IAsyncEnumerable<T> during async JSON serialization. Enumerators were queued into a CompletedAsyncDisposables list and only disposed after the entire object finished serializing — meaning sibling IAsyncEnumerable<T> properties would start enumeration before prior enumerators were disposed. This caused resource leaks, most visibly with EF Core where PostgreSQL connections remained open.

// Second property's enumeration starts before first's enumerator is disposedawaitJsonSerializer.SerializeAsync(stream,new{A=dbContext.Products.Where(p =>p.Id%2==0).AsAsyncEnumerable(),B=dbContext.Products.Where(p =>p.Id%2!=0).AsAsyncEnumerable(),// fails: connection still open from A});

Changes

• IAsyncEnumerableOfTConverter.OnWriteResume: Call DisposeAsync() inline when enumeration completes. If the resulting ValueTask is pending, store it as PendingTask and yield to the root serialization loop — mirroring how MoveNextAsync() pending tasks are already handled. Refactored to use a switch over the new AsyncEnumeratorState enum for clearer state transitions.
• WriteStackFrame: Replace AsyncEnumeratorIsPendingCompletion and AsyncEnumeratorIsPendingDisposal boolean fields with a single AsyncEnumeratorState enum field. Rename AsyncDisposable to AsyncEnumerator (typed as object?) to better reflect that it always stores an IAsyncEnumerator<T> instance, used for enumerator retrieval between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.
• AsyncEnumeratorState: New enum with values None, Enumerating, PendingMoveNext, and PendingDisposal to track the async enumerator's lifecycle within a stack frame.
• WriteStack: Remove CompletedAsyncDisposables field, AddCompletedAsyncDisposable(), and DisposeCompletedAsyncDisposables() — no longer needed. Update DisposePendingDisposablesOnExceptionAsync to pattern-match AsyncEnumerator on IAsyncDisposable for exception cleanup.
• JsonTypeInfoOfT.WriteHelpers.cs: Remove deferred CompletedAsyncDisposables disposal from the root serialization loop finally block.
• Build compatibility fix: Replace UnreachableException usage in IAsyncEnumerableOfTConverter with InvalidOperationException("Invalid async enumerator state.") to avoid build breaks on target frameworks where UnreachableException is unavailable.
• Build break follow-up fix: Replace _ = disposeTask.Result with disposeTask.GetAwaiter().GetResult() in the synchronous disposal path, since non-generic ValueTask has no Result property.
• Tests: Add tests covering prompt disposal ordering of sibling properties, nested async enumerables, empty enumerables, truly async disposal paths, and DisposeAsync exception propagation.
• Test synchronization hardening: Update disposal-ordering tests to use explicit state-based synchronization callbacks between enumerators (instead of timing/order assertions on event list writes), reducing flakiness risk.
• Pending-then-faulted disposal coverage: Extend ThrowingDisposeAsyncEnumerable tests to also cover the async fault path (await Task.Yield(); throw ...) so the PendingDisposal suspend/resume exception propagation path is validated.

[eiriktsarpalis]

@copilot do we need to get rid of

[Copilot]

@copilot do we need to get rid of

If this is about CompletedAsyncDisposables — yes, it was already removed in the initial commit (287f2c5). If about AsyncDisposable — see my reply on the other thread; it's still needed for enumerator storage between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.

[Copilot]

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 1 comment.

[Copilot]

Description

DisposeAsync() was never invoked for property-based IAsyncEnumerable<T> during async JSON serialization. Enumerators were queued into a CompletedAsyncDisposables list and only disposed after the entire object finished serializing — meaning sibling IAsyncEnumerable<T> properties would start enumeration before prior enumerators were disposed. This caused resource leaks, most visibly with EF Core where PostgreSQL connections remained open.

// Second property's enumeration starts before first's enumerator is disposedawaitJsonSerializer.SerializeAsync(stream,new{A=dbContext.Products.Where(p =>p.Id%2==0).AsAsyncEnumerable(),B=dbContext.Products.Where(p =>p.Id%2!=0).AsAsyncEnumerable(),// fails: connection still open from A});

Changes

• IAsyncEnumerableOfTConverter.OnWriteResume: Call DisposeAsync() inline when enumeration completes. If the resulting ValueTask is pending, store it as PendingTask and yield to the root serialization loop — mirroring how MoveNextAsync() pending tasks are already handled. Refactored to use a switch over the new AsyncEnumeratorState enum for clearer state transitions.
• WriteStackFrame: Replace AsyncEnumeratorIsPendingCompletion and AsyncEnumeratorIsPendingDisposal boolean fields with a single AsyncEnumeratorState enum field. Rename AsyncDisposable to AsyncEnumerator (typed as object?) to better reflect that it always stores an IAsyncEnumerator<T> instance, used for enumerator retrieval between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.
• AsyncEnumeratorState: New enum with values None, Enumerating, PendingMoveNext, and PendingDisposal to track the async enumerator's lifecycle within a stack frame.
• WriteStack: Remove CompletedAsyncDisposables field, AddCompletedAsyncDisposable(), and DisposeCompletedAsyncDisposables() — no longer needed. Update DisposePendingDisposablesOnExceptionAsync to pattern-match AsyncEnumerator on IAsyncDisposable for exception cleanup.
• JsonTypeInfoOfT.WriteHelpers.cs: Remove deferred CompletedAsyncDisposables disposal from the root serialization loop finally block.
• Build compatibility fix: Replace UnreachableException usage in IAsyncEnumerableOfTConverter with InvalidOperationException("Invalid async enumerator state.") to avoid build breaks on target frameworks where UnreachableException is unavailable.
• Build break follow-up fix: Replace _ = disposeTask.Result with disposeTask.GetAwaiter().GetResult() in the synchronous disposal path, since non-generic ValueTask has no Result property.
• Tests: Add tests covering prompt disposal ordering of sibling properties, nested async enumerables, empty enumerables, truly async disposal paths, and DisposeAsync exception propagation.
• Test synchronization hardening: Update disposal-ordering tests to use explicit state-based synchronization callbacks between enumerators (instead of timing/order assertions on event list writes), reducing flakiness risk.
• Pending-then-faulted disposal coverage: Extend ThrowingDisposeAsyncEnumerable tests to also cover the async fault path (await Task.Yield(); throw ...) so the PendingDisposal suspend/resume exception propagation path is validated.

[eiriktsarpalis]

@copilot do we need to get rid of

[Copilot]

@copilot do we need to get rid of

If this is about CompletedAsyncDisposables — yes, it was already removed in the initial commit (287f2c5). If about AsyncDisposable — see my reply on the other thread; it's still needed for enumerator storage between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.

[Copilot]

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 1 comment.

[Copilot]

Description

DisposeAsync() was never invoked for property-based IAsyncEnumerable<T> during async JSON serialization. Enumerators were queued into a CompletedAsyncDisposables list and only disposed after the entire object finished serializing — meaning sibling IAsyncEnumerable<T> properties would start enumeration before prior enumerators were disposed. This caused resource leaks, most visibly with EF Core where PostgreSQL connections remained open.

// Second property's enumeration starts before first's enumerator is disposedawaitJsonSerializer.SerializeAsync(stream,new{A=dbContext.Products.Where(p =>p.Id%2==0).AsAsyncEnumerable(),B=dbContext.Products.Where(p =>p.Id%2!=0).AsAsyncEnumerable(),// fails: connection still open from A});

Changes

• IAsyncEnumerableOfTConverter.OnWriteResume: Call DisposeAsync() inline when enumeration completes. If the resulting ValueTask is pending, store it as PendingTask and yield to the root serialization loop — mirroring how MoveNextAsync() pending tasks are already handled. Refactored to use a switch over the new AsyncEnumeratorState enum for clearer state transitions.
• WriteStackFrame: Replace AsyncEnumeratorIsPendingCompletion and AsyncEnumeratorIsPendingDisposal boolean fields with a single AsyncEnumeratorState enum field. Rename AsyncDisposable to AsyncEnumerator (typed as object?) to better reflect that it always stores an IAsyncEnumerator<T> instance, used for enumerator retrieval between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.
• AsyncEnumeratorState: New enum with values None, Enumerating, PendingMoveNext, and PendingDisposal to track the async enumerator's lifecycle within a stack frame.
• WriteStack: Remove CompletedAsyncDisposables field, AddCompletedAsyncDisposable(), and DisposeCompletedAsyncDisposables() — no longer needed. Update DisposePendingDisposablesOnExceptionAsync to pattern-match AsyncEnumerator on IAsyncDisposable for exception cleanup.
• JsonTypeInfoOfT.WriteHelpers.cs: Remove deferred CompletedAsyncDisposables disposal from the root serialization loop finally block.
• Build compatibility fix: Replace UnreachableException usage in IAsyncEnumerableOfTConverter with InvalidOperationException("Invalid async enumerator state.") to avoid build breaks on target frameworks where UnreachableException is unavailable.
• Build break follow-up fix: Replace _ = disposeTask.Result with disposeTask.GetAwaiter().GetResult() in the synchronous disposal path, since non-generic ValueTask has no Result property.
• Tests: Add tests covering prompt disposal ordering of sibling properties, nested async enumerables, empty enumerables, truly async disposal paths, and DisposeAsync exception propagation.
• Test synchronization hardening: Update disposal-ordering tests to use explicit state-based synchronization callbacks between enumerators (instead of timing/order assertions on event list writes), reducing flakiness risk.
• Pending-then-faulted disposal coverage: Extend ThrowingDisposeAsyncEnumerable tests to also cover the async fault path (await Task.Yield(); throw ...) so the PendingDisposal suspend/resume exception propagation path is validated.

[eiriktsarpalis]

@copilot do we need to get rid of

[Copilot]

@copilot do we need to get rid of

If this is about CompletedAsyncDisposables — yes, it was already removed in the initial commit (287f2c5). If about AsyncDisposable — see my reply on the other thread; it's still needed for enumerator storage between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.

[Copilot]

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 1 comment.

[Copilot]

Description

DisposeAsync() was never invoked for property-based IAsyncEnumerable<T> during async JSON serialization. Enumerators were queued into a CompletedAsyncDisposables list and only disposed after the entire object finished serializing — meaning sibling IAsyncEnumerable<T> properties would start enumeration before prior enumerators were disposed. This caused resource leaks, most visibly with EF Core where PostgreSQL connections remained open.

// Second property's enumeration starts before first's enumerator is disposedawaitJsonSerializer.SerializeAsync(stream,new{A=dbContext.Products.Where(p =>p.Id%2==0).AsAsyncEnumerable(),B=dbContext.Products.Where(p =>p.Id%2!=0).AsAsyncEnumerable(),// fails: connection still open from A});

Changes

• IAsyncEnumerableOfTConverter.OnWriteResume: Call DisposeAsync() inline when enumeration completes. If the resulting ValueTask is pending, store it as PendingTask and yield to the root serialization loop — mirroring how MoveNextAsync() pending tasks are already handled. Refactored to use a switch over the new AsyncEnumeratorState enum for clearer state transitions.
• WriteStackFrame: Replace AsyncEnumeratorIsPendingCompletion and AsyncEnumeratorIsPendingDisposal boolean fields with a single AsyncEnumeratorState enum field. Rename AsyncDisposable to AsyncEnumerator (typed as object?) to better reflect that it always stores an IAsyncEnumerator<T> instance, used for enumerator retrieval between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.
• AsyncEnumeratorState: New enum with values None, Enumerating, PendingMoveNext, and PendingDisposal to track the async enumerator's lifecycle within a stack frame.
• WriteStack: Remove CompletedAsyncDisposables field, AddCompletedAsyncDisposable(), and DisposeCompletedAsyncDisposables() — no longer needed. Update DisposePendingDisposablesOnExceptionAsync to pattern-match AsyncEnumerator on IAsyncDisposable for exception cleanup.
• JsonTypeInfoOfT.WriteHelpers.cs: Remove deferred CompletedAsyncDisposables disposal from the root serialization loop finally block.
• Build compatibility fix: Replace UnreachableException usage in IAsyncEnumerableOfTConverter with InvalidOperationException("Invalid async enumerator state.") to avoid build breaks on target frameworks where UnreachableException is unavailable.
• Build break follow-up fix: Replace _ = disposeTask.Result with disposeTask.GetAwaiter().GetResult() in the synchronous disposal path, since non-generic ValueTask has no Result property.
• Tests: Add tests covering prompt disposal ordering of sibling properties, nested async enumerables, empty enumerables, truly async disposal paths, and DisposeAsync exception propagation.
• Test synchronization hardening: Update disposal-ordering tests to use explicit state-based synchronization callbacks between enumerators (instead of timing/order assertions on event list writes), reducing flakiness risk.
• Pending-then-faulted disposal coverage: Extend ThrowingDisposeAsyncEnumerable tests to also cover the async fault path (await Task.Yield(); throw ...) so the PendingDisposal suspend/resume exception propagation path is validated.

[eiriktsarpalis]

@copilot do we need to get rid of

[Copilot]

@copilot do we need to get rid of

If this is about CompletedAsyncDisposables — yes, it was already removed in the initial commit (287f2c5). If about AsyncDisposable — see my reply on the other thread; it's still needed for enumerator storage between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.

[Copilot]

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 1 comment.

[Copilot]

Description

DisposeAsync() was never invoked for property-based IAsyncEnumerable<T> during async JSON serialization. Enumerators were queued into a CompletedAsyncDisposables list and only disposed after the entire object finished serializing — meaning sibling IAsyncEnumerable<T> properties would start enumeration before prior enumerators were disposed. This caused resource leaks, most visibly with EF Core where PostgreSQL connections remained open.

// Second property's enumeration starts before first's enumerator is disposedawaitJsonSerializer.SerializeAsync(stream,new{A=dbContext.Products.Where(p =>p.Id%2==0).AsAsyncEnumerable(),B=dbContext.Products.Where(p =>p.Id%2!=0).AsAsyncEnumerable(),// fails: connection still open from A});

Changes

• IAsyncEnumerableOfTConverter.OnWriteResume: Call DisposeAsync() inline when enumeration completes. If the resulting ValueTask is pending, store it as PendingTask and yield to the root serialization loop — mirroring how MoveNextAsync() pending tasks are already handled. Refactored to use a switch over the new AsyncEnumeratorState enum for clearer state transitions.
• WriteStackFrame: Replace AsyncEnumeratorIsPendingCompletion and AsyncEnumeratorIsPendingDisposal boolean fields with a single AsyncEnumeratorState enum field. Rename AsyncDisposable to AsyncEnumerator (typed as object?) to better reflect that it always stores an IAsyncEnumerator<T> instance, used for enumerator retrieval between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.
• AsyncEnumeratorState: New enum with values None, Enumerating, PendingMoveNext, and PendingDisposal to track the async enumerator's lifecycle within a stack frame.
• WriteStack: Remove CompletedAsyncDisposables field, AddCompletedAsyncDisposable(), and DisposeCompletedAsyncDisposables() — no longer needed. Update DisposePendingDisposablesOnExceptionAsync to pattern-match AsyncEnumerator on IAsyncDisposable for exception cleanup.
• JsonTypeInfoOfT.WriteHelpers.cs: Remove deferred CompletedAsyncDisposables disposal from the root serialization loop finally block.
• Build compatibility fix: Replace UnreachableException usage in IAsyncEnumerableOfTConverter with InvalidOperationException("Invalid async enumerator state.") to avoid build breaks on target frameworks where UnreachableException is unavailable.
• Build break follow-up fix: Replace _ = disposeTask.Result with disposeTask.GetAwaiter().GetResult() in the synchronous disposal path, since non-generic ValueTask has no Result property.
• Tests: Add tests covering prompt disposal ordering of sibling properties, nested async enumerables, empty enumerables, truly async disposal paths, and DisposeAsync exception propagation.
• Test synchronization hardening: Update disposal-ordering tests to use explicit state-based synchronization callbacks between enumerators (instead of timing/order assertions on event list writes), reducing flakiness risk.
• Pending-then-faulted disposal coverage: Extend ThrowingDisposeAsyncEnumerable tests to also cover the async fault path (await Task.Yield(); throw ...) so the PendingDisposal suspend/resume exception propagation path is validated.

[eiriktsarpalis]

@copilot do we need to get rid of

[Copilot]

@copilot do we need to get rid of

If this is about CompletedAsyncDisposables — yes, it was already removed in the initial commit (287f2c5). If about AsyncDisposable — see my reply on the other thread; it's still needed for enumerator storage between re-entries and for exception cleanup in DisposePendingDisposablesOnExceptionAsync.

[Copilot]

Pull request overview

Copilot reviewed 7 out of 7 changed files in this pull request and generated 1 comment.