DisposableOwnership

    public struct DisposableOwner<T> : IDisposable where T : IDisposable
    {
        private T _owned;
        private bool _isReleased;

        public DisposableOwner(T owned) => (_owned, _isReleased) = (owned, false);

        public T Release()
        {
            if (_isReleased)
            {
                throw new InvalidOperationException("The ownership has been already released");
            }
            this._isReleased = true;
            return _owned;
        }

        public void Dispose()
        {
            if (_isReleased == false)
            {
                _owned.Dispose();
            }
        }
    }
    public struct AsyncDisposableOwner<T> : IAsyncDisposable where T : IAsyncDisposable
    {
        private T _owned;
        private bool _isReleased;

        public AsyncDisposableOwner(T owned) => (_owned, _isReleased) = (owned, false);

        public T Release()
        {
            if (_isReleased)
            {
                throw new InvalidOperationException("The ownership has been already released");
            }
            this._isReleased = true;
            return _owned;
        }

        public async ValueTask DisposeAsync()
        {
            if (_isReleased == false)
            {
                await _owned.DisposeAsync();
            }
        }
    }

    public static class DisposableOwnerExtensions
    {
        public static DisposableOwner<T> TakeOwnership<T>(this T disposable) where T : IDisposable => new DisposableOwner<T>(disposable);
        public static AsyncDisposableOwner<T> TakeOwnershipAsync<T>(this T disposable) where T : IAsyncDisposable => new AsyncDisposableOwner<T>(disposable);
    }