CodeProject.ObjectPool.MicrosoftExtensionsAdapter 6.1.0

.NET 6.0 .NET Core 3.1 .NET Framework 4.6.1
This package has a SemVer 2.0.0 package version: 6.1.0+6fa6bf8.
Install-Package CodeProject.ObjectPool.MicrosoftExtensionsAdapter -Version 6.1.0
dotnet add package CodeProject.ObjectPool.MicrosoftExtensionsAdapter --version 6.1.0
<PackageReference Include="CodeProject.ObjectPool.MicrosoftExtensionsAdapter" Version="6.1.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add CodeProject.ObjectPool.MicrosoftExtensionsAdapter --version 6.1.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: CodeProject.ObjectPool.MicrosoftExtensionsAdapter, 6.1.0"
#r directive can be used in F# Interactive, C# scripting and .NET Interactive. Copy this into the interactive tool or source code of the script to reference the package.
// Install CodeProject.ObjectPool.MicrosoftExtensionsAdapter as a Cake Addin
#addin nuget:?package=CodeProject.ObjectPool.MicrosoftExtensionsAdapter&version=6.1.0

// Install CodeProject.ObjectPool.MicrosoftExtensionsAdapter as a Cake Tool
#tool nuget:?package=CodeProject.ObjectPool.MicrosoftExtensionsAdapter&version=6.1.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.

Object Pool

License: MIT Donate Docs NuGet version NuGet downloads

standard-readme compliant GitLab pipeline status Quality gate Code coverage Renovate enabled

A generic, concurrent, portable and flexible Object Pool for .NET, completely based on the Code Project article of Ofir Makmal.

Library is feature complete and no further development is planned on this project, except for routine maintenance and bug fixes.

Original source code has been modified, in order to introduce:

  • A Parameterized Object Pool, already drafted by Ofir Makmal in the comments of the article.
  • A Timed Object Pool, where objects are automatically removed after a period of inactivity.
  • Memory Stream and String Builder pools.
    • For use cases which might involve very large memory streams, I suggest to use the Microsoft.IO.RecyclableMemoryStream library from Microsoft. It eliminates Large Object Heap allocations, which this library does not do.

Moreover, a few unit tests have been added, in order to improve code reliability, and a lot of other small changes have also been applied.

Of course, all modified source code is freely available in this repository.

Many thanks to Ofir Makmal for his great work.

Table of Contents


NuGet package CodeProject.ObjectPool is available for download:

dotnet add package CodeProject.ObjectPool

An adapter for Microsoft.Extensions.ObjectPool is also available on NuGet:

dotnet add package CodeProject.ObjectPool.MicrosoftExtensionsAdapter


Quick and dirty example:

/// <summary>
///   Example usages of ObjectPool.
/// </summary>
internal static class Program
    /// <summary>
    ///   Example usages of ObjectPool.
    /// </summary>
    private static void Main()
        // Creating a pool with a maximum size of 25, using custom Factory method to create and
        // instance of ExpensiveResource.
        var pool = new ObjectPool<ExpensiveResource>(25, () => new ExpensiveResource(/* resource specific initialization */));

        using (var resource = pool.GetObject())
            // Using the resource...
        } // Exiting the using scope will return the object back to the pool.

        // Creating a pool with wrapper object for managing external resources, that is, classes
        // which cannot inherit from PooledObject.
        var newPool = new ObjectPool<PooledObjectWrapper<ExternalExpensiveResource>>(() =>
            new PooledObjectWrapper<ExternalExpensiveResource>(CreateNewResource())
                OnReleaseResources = ExternalResourceReleaseResource,
                OnResetState = ExternalResourceResetState

        using (var wrapper = newPool.GetObject())
            // wrapper.InternalResource contains the object that you pooled.
        } // Exiting the using scope will return the object back to the pool.

        // Creates a pool where objects which have not been used for over 2 seconds will be
        // cleaned up by a dedicated thread.
        var timedPool = new TimedObjectPool<ExpensiveResource>(TimeSpan.FromSeconds(2));

        using (var resource = timedPool.GetObject())
            // Using the resource...
        } // Exiting the using scope will return the object back to the pool and record last usage.

        Console.WriteLine($"Timed pool size after 0 seconds: {timedPool.ObjectsInPoolCount}"); // Should be 1
        Console.WriteLine($"Timed pool size after 4 seconds: {timedPool.ObjectsInPoolCount}"); // Should be 0

        // Adapts a timed pool to Microsoft Extensions abstraction.
        var mPool = ObjectPoolAdapter.CreateForPooledObject(timedPool);

        // Sample usage of Microsoft pool.
        var mResource = mPool.Get();
        Debug.Assert(mResource != null);

        // Adapts a new pool to Microsoft Extensions abstraction. This example shows how to adapt
        // when object type does not extend PooledObject.
        var mPool2 = ObjectPoolAdapter.Create(new ObjectPool<PooledObjectWrapper<MemoryStream>>(
            () => PooledObjectWrapper.Create(new MemoryStream())));

        // Sample usage of second Microsoft pool.
        var mResource2 = mPool2.Get();
        Debug.Assert(mResource2 != null);


    private static ExternalExpensiveResource CreateNewResource()
        return new ExternalExpensiveResource();

    public static void ExternalResourceResetState(ExternalExpensiveResource resource)
        // External Resource reset state code.

    public static void ExternalResourceReleaseResource(ExternalExpensiveResource resource)
        // External Resource release code.

internal sealed class ExpensiveResource : PooledObject
    public ExpensiveResource()
        OnReleaseResources = () =>
            // Called if the resource needs to be manually cleaned before the memory is reclaimed.

        OnResetState = () =>
            // Called if the resource needs resetting before it is getting back into the pool.

    public void DoStuff()
        // Do some work here, for example.

internal sealed class ExternalExpensiveResource
    public void DoOtherStuff()
        // Do some work here, for example.

Async support

Starting from v4, Object Pool supports async pooled object initialization. Therefore, objects can be retrieved in two ways:

obj = pool.GetObject();
obj = await pool.GetObjectAsync();

Those methods depend on the factory method specified during pool initialization. Because making async factories "sync" is usually a problem, which can lead to deadlocks, we have the following situation:

Factory type GetObject GeObjectAsync
Not specified OK OK, uses a result task
Sync OK OK, uses a result task
Async KO, throws an exception OK

So, to sum it up:

  • If a sync factory is specified, both retrieval methods can be used.
  • If an async factory is specified, only the async retrieval can be used.




PRs accepted.

Small note: If editing the README, please conform to the standard-readme specification.


MIT © 2013-2021 Alessio Parma

Product Versions
.NET net5.0 net5.0-windows net6.0 net6.0-android net6.0-ios net6.0-maccatalyst net6.0-macos net6.0-tvos net6.0-windows
.NET Core netcoreapp3.1
.NET Framework net461 net462 net463 net47 net471 net472 net48
Compatible target framework(s)
Additional computed target framework(s)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
6.1.0 751 11/20/2021
6.0.0 72 11/3/2021
5.0.5 77 11/3/2021
5.0.4 86 9/26/2021
5.0.3 187 6/13/2021
5.0.2 234 12/26/2020
5.0.1 282 11/14/2020
5.0.0 235 11/1/2020
4.0.2 1,320 2/23/2020
4.0.1 431 6/22/2019
3.2.4 397 6/13/2019
3.2.3 385 5/12/2019
3.2.2 4,663 10/28/2017
3.2.1 769 9/30/2017