Reference counted IDisposable

[wilbennett]

Allow implicit reference counting for IDisposable instances.

Consider the following:

void MainMethod()
{
    using (var exp = new ExpensiveObject())
    {
       Process(exp);
       ProcessMore(exp);
    } // BAD: exp disposed but Process/ProcessAsync could still be using it.
}

async void/Task ProcessAsync(ExpensiveObject exp) => ...;
void Process(ExpensiveObject exp) => ProcessAsync(exp);
void ProcessMore(ExpensiveObject exp) => Console.WriteLine(exp);

I believe this to be an unnecessary restriction when implementing using blocks. All called methods must be finished with the "used" object on return.

This can be fixed by using reference counting.

Consider:

void MainMethod()
{
    // Use "ref new" to say "I want the constructed instance reference counted".
    var exp = ref new ExpensiveObject(); // Implicit reference count is 1.
    Process(exp);
    ProcessMore(exp);
} // Decrement exp reference count and dispose if 0.

async void/Task ProcessAsync(ExpensiveObject exp)
{ // exp instance is reference counted so increment the reference count.
   ...
} // Decrement exp reference count and dispose if 0.

void Process(ExpensiveObject exp)
{ // exp instance is reference counted so increment the reference count.
   ProcessAsync(exp);
} // Decrement exp reference count and dispose if 0.

void ProcessMore(ExpensiveObject exp)
{ // exp instance is reference counted so increment the reference count.
   Console.WriteLine(exp);
} // Decrement exp reference count and dispose if 0.

This approach can benefit a lot of use cases. For example, creating a pool of expensive objects can now be fairly trivial.

A pool class/service can contain a collection of expensive objects.
A consumer asks the class/service for an instance.
When the consumer finishes and the instance is disposed, it can be returned to the pool.
The benefit of this is the consumer can be written simply. It doesn't need to know about the pooling and doesn't need to do anything special. It just requests an instance and uses it.

[sharwell]

If semantics are the most important for you, Roslyn's ReferenceCountedDisposable<T> is a solid implementation. If performance is a concern with this approach, the changes in dotnet/roslyn@master...sharwell:lock-free-rcd should address most.

[wilbennett]

Interesting... I did not know about this. I'll look into it. Thanks!