using System;

using System.Collections.Generic;

using System.Collections;

using System.Linq;

using System.Buffers;

using System.Threading;

using System.Text.Json;

​

using Microsoft.AspNetCore.Mvc;

​

using NUnit.Framework;

​

#nullable enable

​

//https://stackoverflow.com/questions/78250438/how-to-return-array-to-arraypool-when-it-was-rented-by-inner-function

​

public sealed class RentedArrayWrapper<T> : IList<T>, IDisposable

{

    T [] array;

    readonly ArrayPool<T>? pool;

    readonly int count;

​

    public static RentedArrayWrapper<T> Create(ArrayPool<T> pool, int count) =>  new RentedArrayWrapper<T>(pool.Rent(count), pool, count);

​

    RentedArrayWrapper(T [] array, ArrayPool<T>? pool,int count)

    {

        if (count < 0 || count > array.Length)

            throw new ArgumentException("count < 0 || count > array.Length");

        this.array = array ?? throw new ArgumentNullException(nameof(array));

        this.pool = pool;

        this.count = count;

    }

​

    public T [] Array => array ?? throw new ObjectDisposedException(GetType().Name);

    public Memory<T> Memory => Array.AsMemory().Slice(0, count);

​

    public T this[int index]

    {

        get

        {

            if (index < 0 || index >= count)

                throw new ArgumentOutOfRangeException();

            return Array[index];

        }

        set

        {

            if (index < 0 || index >= count)

                throw new ArgumentOutOfRangeException();

            Array[index] = value;

        }

    }

​

    public IEnumerable<T> EnumerateAndDispose() 

    {

        IEnumerable<T> EnumerateAndDisposeInner()

        {

            try

            {

                foreach (var item in this)

                    yield return item;

            }

            finally

            {

                Dispose();

            }

        }

        CheckDisposed();

        return EnumerateAndDisposeInner();

    }

    public IEnumerator<T> GetEnumerator() 

    {

        IEnumerator<T> GetEnumeratorInner()

        {

            CheckDisposed();

            for (int i = 0; i < count; i++)

                yield return this[i];

        }

        CheckDisposed();

        return GetEnumeratorInner();

    }

​

    public int IndexOf(T item) => System.Array.IndexOf<T>(Array, item, 0, count);

    public bool Contains(T item) => IndexOf(item) >= 0;

    public void CopyTo(T[] array, int arrayIndex) => Memory.CopyTo(array.AsMemory().Slice(arrayIndex));

    public int Count => count;

    void IList<T>.Insert(int index, T item) => throw new NotImplementedException();

    void IList<T>.RemoveAt(int index) => throw new NotImplementedException();

    void ICollection<T>.Add(T item) => throw new NotImplementedException();

    void ICollection<T>.Clear() => throw new NotImplementedException();

    bool ICollection<T>.Remove(T item) => throw new NotImplementedException();

    bool ICollection<T>.IsReadOnly => true; // Indicates items cannot be added or removed

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

​

    public void Dispose()

    {

        Dispose(true);

        GC.SuppressFinalize(this);

    }

​

    void CheckDisposed() 

    {

        if (this.array == null)

            throw new ObjectDisposedException(GetType().Name);

    }

​

    void Dispose(bool disposing)

    {

        if (disposing)

            if (Interlocked.Exchange(ref this.array, null!) is {} array)

                pool?.Return(array);

    }

}

​

public static partial class ArrayPoolExtensions

{

    public static RentedArrayWrapper<T> RentWrapper<T>(this ArrayPool<T> pool, int count) => RentedArrayWrapper<T>.Create(pool, count);

}

​

//=============================

​

public class DummyController : ControllerBase

{

    readonly ArrayPool<int> _defaultArrayPool = ArrayPool<int>.Shared;

​

    public IActionResult ParentFunction()

    {

        using var wrapper = InnerFunction(1000);

        // Take() uses deferred execution so we must materialize the rented array into a final non-disposable result so that 

        // ObObjectResult.ExecuteResultAsync(ActionContext context) does not attempt to serialize the rented array after it has been returned.

        return Ok(wrapper.Take(1000).ToArray()); 

    }

​

    public RentedArrayWrapper<int> InnerFunction(int count)

    {

        var wrapper = _defaultArrayPool.RentWrapper(count);

        // make operation on wrapper.Array

        return wrapper;

    }

}

​

public class Program

{

    public static void Main()

    {

        var controller = new DummyController();

        var result = controller.ParentFunction();

        var value = ((OkObjectResult)result).Value;

        Console.WriteLine(JsonSerializer.Serialize(value));

        //Assert.Throws<ObjectDisposedException>(() => JsonSerializer.Serialize(((OkObjectResult)result).Value));

    }

}