Pooling of Streams in Marten.AspNetCore.QueryableExtensions

[gfoidl]

For each request a new MemoryStream is created, thus also the backing byte[]-buffer used by MS and if it needs to be resized another buffer with copying over the old contents, and so on.

As response header values can't be set once the body has started, any kind of temporary stream needs to be used -- as it's done now.
But instead of creating a MS every time there should be some kind of pooling, e.g. via Microsoft.IO.RecyclableMemoryStream.

Is this in general something to look into, and is it OK to rely on that package?
Otherwise there could be some inbox-solution for pooled streams based on ArrayPool, etc.

I didn't run any benchmarks so far, just saw this when reading the code.

_{I can create a PR if needed.}.

[cocowalla]

I use that package in several projects, it's been rock solid. If for some reason it wasn't fit for Marten, it would be trivial to build something on top of Microsoft.Extensions.ObjectPool instead.

[gfoidl]

With MemoryStream and the ObjectPool one has to be cautious about LOH and all other "troubles" pooling brings with it.
So the easiest would be to use recycleable MS linked above IMO.

[gfoidl]

Also where possible one could omit to set the ContentLength, e.g.:

marten/src/Marten.AspNetCore/QueryableExtensions.cs

Lines 49 to 61 in b77d553

	public static async Task WriteArray<T>(this IQueryable<T> queryable, HttpContext context,
	string contentType = "application/json")
	{
	var stream = new MemoryStream();
	await queryable.StreamJsonArray(stream, context.RequestAborted).ConfigureAwait(false);
	context.Response.StatusCode = 200;
	context.Response.ContentLength = stream.Length;
	context.Response.ContentType = contentType;
	stream.Position = 0;
	await stream.CopyToAsync(context.Response.Body).ConfigureAwait(false);
	}

ASP.NET Core will produce a "chunked" response then, and afaik every client can handle that.
The advantage is that StreamJsonArray could write to the response-stream directly, thus avoiding the need of the MemoryStream (even when pooled) and the copying of MS to response.