Add missing clearing of pooled arrays

[hendriklhf]

Add missing clearing of pooled arrays

I found several places where arrays rented from pools are not cleared before returning. Any objects in the pools' arrays cannot be collected by the GC. This might keep objects in the returned arrays longer or, in the worst case, forever alive.

• If the amount of elements written to the array is known, the array is sliced so that only the written portion is cleared, avoiding unnecessary work.
• If it's a generic array, the array is only cleared if T is a reference type or contains references.
• There's one case where the file is also compiled for .NET Framework. RuntimeHelpers.IsReferenceOrContainsReferences<T>() is not available there, so typeof(T).IsPrimitive is checked instead.

[Copilot]

Pull Request Overview

This PR addresses memory leaks by adding proper clearing of pooled arrays before returning them to array pools. When arrays containing references are returned to pools without clearing, the referenced objects cannot be garbage collected, potentially causing memory leaks.

Key changes:

• Adds conditional clearing logic that only clears arrays when they contain reference types or references
• Uses RuntimeHelpers.IsReferenceOrContainsReferences<T>() on .NET and falls back to typeof(T).IsPrimitive check for .NET Framework
• Optimizes clearing by only clearing the used portion of arrays when the count is known

Reviewed Changes

Copilot reviewed 8 out of 8 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/SignalR/common/Shared/JsonUtils.cs	Adds clearing logic with .NET Framework compatibility for generic array pool wrapper
src/Shared/ValueStringBuilder/ValueListBuilder.cs	Clears used portion of arrays in Dispose and Grow methods
src/Mvc/Mvc.NewtonsoftJson/src/JsonArrayPool.cs	Adds clearing for JSON array pool implementation
src/Middleware/OutputCaching/src/RecyclableArrayBufferWriter.cs	Clears arrays in Dispose and resize operations
src/Middleware/OutputCaching/src/OutputCacheEntryFormatter.cs	Adds explicit clearing for string array when tags exist
src/Components/Endpoints/src/FormMapping/PrefixResolver.cs	Clears FormKey array before returning to pool
src/Components/Endpoints/src/FormMapping/Converters/CollectionAdapters/ArrayPoolBufferAdapter.cs	Clears arrays in buffer operations and result conversion
src/Components/Components/src/NavigationManager.cs	Clears function delegate array after use

[JamesNK]

ArrayPool has a return method with an option for clearing arrays. Why not use it instead of clearing before returning?

https://learn.microsoft.com/en-us/dotnet/api/system.buffers.arraypool-1.return?view=net-9.0

[gfoidl]

The array pool method would clear the whole array, regardless of how many items are actually non-zero thus potentially more work than needed.
On overload that specifies the length to clear is what you aim for?

With the approach here just the elements are cleared, that are used.

But instead doing this on every use, maybe create a helper function for this like the one linked above?
If .NET exposes the API public, then it's easy to switch over w/o the need to touch lots of places over the code base.

[hendriklhf]

Yes, that's why. You generally don't want or need to clear the whole array. 🙂

[hendriklhf]

Added the Return(T[], int) extension as used in dotnet/runtime 👍

[dotnet-policy-service]

Looks like this PR hasn't been active for some time and the codebase could have been changed in the meantime.
To make sure no conflicting changes have occurred, please rerun validation before merging. You can do this by leaving an /azp run comment here (requires commit rights), or by simply closing and reopening.

[JamesNK]

This is repeated many times.

What do you think of adding an extra helper method to ArrayPoolExtensions.

ArrayPool<T>.Shared.ReturnAndClearReferences(tmp, count);

In the helper method have a comment that references are cleared from the pool so they can be GCed.

[hendriklhf]

Yes, that totally makes sense 👍

[JamesNK]

@BrennanConroy Could you take a look? Double check this is ok.

[BrennanConroy]

What's the point of this overload? Shouldn't we just always use the ReturnAndClearReferences one?

[JamesNK]

It's for cases were it's known that T is a reference type.

Do you think ReturnAndClearReferences should be used everywhere? I assume RuntimeHelpers.IsReferenceOrContainsReferences<T>() check is optimized away by JIT so they end up being the same anyway.