C# Pool.AcquirePooledValueAsync方法代码示例

        public async Task CannotBeReturnedToPoolOnceDetachedTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();

            // when
            Action detachingFromPoolAction = () => acquiredPooledItem.DetachFromPool();
            Action returningToPoolAction = () => acquiredPooledItem.ReleaseBackToPool();

            // then
            detachingFromPoolAction.ShouldNotThrow();
            returningToPoolAction.ShouldThrow<InvalidOperationException>();
        }

        public async Task WillNotBeReturnedToPoolAfterPoolDisposalTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();

            // when
            pool.Dispose();

            // then
            acquiredPooledItem.IsDisposed.Should().Be(false);

            Action valueDispose = () => acquiredPooledItem.Dispose();

            valueDispose.ShouldNotThrow<ObjectDisposedException>();
        }

        public async Task CannotBeReturnedToPoolMultipleTimesTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();

            // when
            Action returningToPoolAction = () => acquiredPooledItem.ReleaseBackToPool();

            // then
            // prior to returning poolsize should be down by one
            returningToPoolAction.ShouldNotThrow();

            // however a second (or more) time(s) should not be allowed
            returningToPoolAction.ShouldThrow<InvalidOperationException>();
        }

        public async Task NonEmptyPoolAllowsInstanceAcquisitionTest(int initialInstanceCount)
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), initialInstanceCount);

            // when
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();

            // then
            acquiredPooledItem.Should().NotBeNull();
            pool.AvailableInstancesCount.Should().Be(initialInstanceCount - 1);
        }

        public void PoolCurrentlyEmptyWaitsForNextAvailableReturnedValueOnAcquisitionWhenRequestedTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);

            // when
            Pooled<string> waitingConsumerAcquiredPooledValue = default(Pooled<string>);
            Func<Task> taskArrangement = () =>
            {
                var initialConsumerHasAcquiredValue = false;
                var secondActuallyWaitingForAcquisitionConsumerIsWaiting = false;
                var releaseValueFlagForInitialConsumer = false;

                Func<Task> initialAcquisitionTask = async () =>
                {
                    var pooledValue = await pool.AcquirePooledValueAsync();
                    initialConsumerHasAcquiredValue = true;

                    while (releaseValueFlagForInitialConsumer == false)
                    {
                        await Task.Yield();
                    }

                    pooledValue.ReleaseBackToPool();
                };

                Func<Task> secondAndSupposedlyWaitingAcquisitionTask = async () =>
                {
                    while (initialConsumerHasAcquiredValue == false)
                    {
                        await Task.Yield();
                    }

                    secondActuallyWaitingForAcquisitionConsumerIsWaiting = true;
                    waitingConsumerAcquiredPooledValue = await pool.AcquirePooledValueAsync(PooledValueAcquisitionMode.AvailableInstanceOrWaitForNextOne);
                };

                Func<Task> acquistionAndReleaseSignalWatcherTask = async () =>
                {
                    while (initialConsumerHasAcquiredValue == false || secondActuallyWaitingForAcquisitionConsumerIsWaiting == false)
                    {
                        await Task.Yield();
                    }

                    releaseValueFlagForInitialConsumer = true;
                };

                return Task.WhenAll(Task.Run(initialAcquisitionTask), Task.Run(secondAndSupposedlyWaitingAcquisitionTask), Task.Run(acquistionAndReleaseSignalWatcherTask));
            };

            // then
            taskArrangement.ShouldNotThrow();
            waitingConsumerAcquiredPooledValue.Should().NotBe(default(Pooled<string>));
            waitingConsumerAcquiredPooledValue.Value.Should().NotBe(default(string));
            pool.AvailableInstancesCount.Should().Be(0);
        }

        public async Task AcquiredInstancesCannotBeReturnedToDifferentPoolTest()
        {
            // given
            var owningPool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);
            var secondPool = new Pool<string>((token) => Guid.NewGuid().ToString());

            var acquiredPooledItem = await owningPool.AcquirePooledValueAsync();

            // when
            Action returningToPoolAction = () => secondPool.ReleasePooledValue(acquiredPooledItem);
            Action accessingPoolValueAfterReturningToDifferentPoolAction = () => { var pooledValue = acquiredPooledItem.Value; };

            // then
            returningToPoolAction.ShouldThrow<ArgumentOutOfRangeException>().And.ParamName.Should().Be("pooledValue");

            owningPool.AvailableInstancesCount.Should().Be(0);
            acquiredPooledItem.HasBeenReleasedBackToPool.Should().Be(false);
            acquiredPooledItem.HasBeenDetachedFromPool.Should().Be(false);

            accessingPoolValueAfterReturningToDifferentPoolAction.ShouldNotThrow<InvalidOperationException>();
        }

        public async Task AcquiredInstancesCannotBeDetachedFromDifferentPoolTest()
        {
            // given
            var owningPool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);
            var secondPool = new Pool<string>((token) => Guid.NewGuid().ToString());

            var acquiredPooledItem = await owningPool.AcquirePooledValueAsync();

            // when
            Action detachFromPoolAction = () => secondPool.DetachPooledValue(acquiredPooledItem);

            // then
            detachFromPoolAction.ShouldThrow<ArgumentOutOfRangeException>().And.ParamName.Should().Be("pooledValue");

            owningPool.AvailableInstancesCount.Should().Be(0);
            acquiredPooledItem.HasBeenReleasedBackToPool.Should().Be(false);
            acquiredPooledItem.HasBeenDetachedFromPool.Should().Be(false);
        }

        public async Task AcquiredInstancesCanBeReturnedToOwningPoolTest(int poolSize)
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), poolSize);
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();

            // when
            Action returningToPoolAction = () => pool.ReleasePooledValue(acquiredPooledItem);
            Action accessingPoolValueAfterReturningToPoolAction = () => { var pooledValue = acquiredPooledItem.Value; };

            // then
            // prior to returning poolsize should be down by one
            pool.AvailableInstancesCount.Should().Be(poolSize -1);

            returningToPoolAction.ShouldNotThrow();

            // after returning poolsize should be back to expected size
            pool.AvailableInstancesCount.Should().Be(poolSize);
            acquiredPooledItem.HasBeenReleasedBackToPool.Should().Be(true);
            acquiredPooledItem.HasBeenDetachedFromPool.Should().Be(false);

            accessingPoolValueAfterReturningToPoolAction.ShouldThrow<InvalidOperationException>();
        }

        public async Task AcquiredInstancesCanBeDetachedFromOwningPoolTest(int poolSize)
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), poolSize);
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();
            var acquiredPooledItemValue = acquiredPooledItem.Value;

            // when
            var detachedValue = pool.DetachPooledValue(acquiredPooledItem);
            
            // then
            pool.TotalInstancesCount.Should().Be(poolSize - 1);
            pool.AvailableInstancesCount.Should().Be(poolSize - 1);
            detachedValue.Should().Be(acquiredPooledItemValue);

            acquiredPooledItem.HasBeenReleasedBackToPool.Should().Be(false);
            acquiredPooledItem.HasBeenDetachedFromPool.Should().Be(true);
        }

        public async Task AcquiredInstancesCannotBeReturnedMultipleTimesTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();

            // when
            Action returningToPoolAction = () => pool.ReleasePooledValue(acquiredPooledItem);

            // then
            // prior to returning poolsize should be down by one
            returningToPoolAction.ShouldNotThrow();
            
            // however a second (or more) time(s) should not be allowed
            returningToPoolAction.ShouldThrow<ArgumentOutOfRangeException>();
        }

        public async Task EmptyPoolPerformsInstanceCreationOnAcquisitionWhenRequestedTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString());

            // when
            var acquiredPooledItem = await pool.AcquirePooledValueAsync(PooledValueAcquisitionMode.AvailableInstanceOrCreateNewOne);

            // then
            acquiredPooledItem.Should().NotBeNull();
            acquiredPooledItem.Value.Should().NotBeNull();
            pool.AvailableInstancesCount.Should().Be(0);
        }

        public async Task EmptyPoolReturnsDefaultValueOnAcquisitionWhenRequestedTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString());

            // when
            var acquiredPooledItem = await pool.AcquirePooledValueAsync(PooledValueAcquisitionMode.AvailableInstanceOrDefaultValue);

            // then
            acquiredPooledItem.Should().Be(default(Pooled<string>));
            pool.AvailableInstancesCount.Should().Be(0);
        }

        public async Task WillBeReturnedToPoolOnDisposalTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();

            // then

            pool.AvailableInstancesCount.Should().Be(0);
            acquiredPooledItem.IsDisposed.Should().Be(false);

            acquiredPooledItem.Dispose();

            pool.AvailableInstancesCount.Should().Be(1);
            acquiredPooledItem.IsDisposed.Should().Be(true);
        }

        public async Task WillPreventFurtherDirectUsageAfterDisposalTest()
        {
            // given
            var pool = new Pool<string>((token) => Guid.NewGuid().ToString(), 1);
            var acquiredPooledItem = await pool.AcquirePooledValueAsync();

            // when
            Action accessingValueAction = () => { var value = acquiredPooledItem.Value; };

            Action accessingHasBeenDetachedFromPoolAction = () => { var value = acquiredPooledItem.HasBeenDetachedFromPool; };
            Action accessingHasBeenReleasedBackToPoolAction = () => { var value = acquiredPooledItem.HasBeenReleasedBackToPool; };

            acquiredPooledItem.Dispose();

            // then
            accessingValueAction.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be(acquiredPooledItem.GetType().Name);
            accessingHasBeenDetachedFromPoolAction.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be(acquiredPooledItem.GetType().Name);
            accessingHasBeenReleasedBackToPoolAction.ShouldThrow<ObjectDisposedException>().And.ObjectName.Should().Be(acquiredPooledItem.GetType().Name);
        }