Why there's no `DBconnection.CloseAsync()` while there is `DBconnection.OpenAsync()`?

Question

I'm changing our DAL to an async DAL.

Looking at :

await _conn.OpenAsync().ConfigureAwait(false);

I see that there's an async method for open connection.But why there's no async method for closing connection ?

• A shared connection might used by others
• Might return to the connection pool
• It is an I/O operation
• Possible delayed / time-consuming operation

(I might be wrong about all four above :-))

Question

It seems logic ( to me) that there's should be an async close method for a connection.

Is there a reason why there's not ?

PS I will obviously will use DAPPER at the end , but just for practicing , I've decided to create small mini mini dapper alike DAL.

Answer 1

A shared connection might used by others

Why would this make calling close on it take a long time? If anything this would mean that, in cases where the connection is still being used by others all that "closing" it means is indicating that you no longer needed it, and the actual underlying connection doesn't need to be closed.

It is an I/O operation

Not necessarily. As you said, if it's pooled/shared, then it's just returned to the pool, no IO would happen at all.

And what makes you think that, even if the underlying connection is being closed, that it would take a long time. All that needs to happen is to stop paying attention to the connection, possibly sending a courtesy message through the connection saying that you're done. That's not going to take a long time. You don't need to wait for any type of response to such a message, so you aren't waiting for a completed network round trip in this method.

Possible delayed / time-consuming operation

Why would it be time consuming? If it is delayed (if, for example, the connection is pooled and you're closing it when you're the last user of it) it means that that it'll likely be closed after a bit, but you aren't needing to wait for that.

Marking an object as "no longer in use" simply isn't time consuming, and at the end of the day that's all you're really doing.

Answer 2

In fact, IDbConnection interface (the one required to implement to develop an ADO.NET connection provider along with other interfaces like IDbCommand) doesn't provide OpenAsync.

Thus, OpenAsync is an implementation detail of DBConnection and, for example, it's the base class of System.Data.SqlClient.SqlConnection.

Why there's no CloseAsync? This should be asked to a .NET Framework Development Team member. When there's a design decision like this, usually it's motivated because of some particular requirement either in the framework itself or in some .NET-based solution developed by Microsoft or some partner. Maybe there's a potential question here: Why IDbConnection doesn't define both Open and Close asynchronous flavors? What about an IDbConnectionAsync interface in order to avoid a breaking change with exisiting code?.

BTW, I suspect opening a connection consumes more time than closing it, because closing process can be queued since the caller just expects an OK I'll do it (from the database server) while opening a connection it's not just signaling but an immediate availability of the connection itself.

Since network connectivity might slowdown the connection opening process, it seems like this is the main reason to implement it as an async operation.

Answer 3

As of 2019, there is a DbConnection.CloseAsync method; it was added in .NET Standard 2.1 and .NET Core 3.0, along with the IAsyncDisposable interface. The work was tracked by GitHub issue 28596.

It returns a Task, not a ValueTask, because it may be more complicated than just returning a connection to a pool; for example, there may be work that requires I/O associated with it (such as rolling back a transaction or freeing server-side resources for temporary tables or variables).