Faactory.DbContext.SqlClient 0.6.0-preview-1

ADO.NET Extensions

This project contains a set of extensions to help with managing multiple data sources, more specifically, inside a DI scenario.

Getting started

Before we can use the extensions, we need to register the context provider with our DI container. We'll have to install the appropriate package, depending on the provider we want to use; the following are currently supported

We'll use SqlServer as an example

$ dotnet add package Faactory.DbContext.SqlClient

We'll then register the provider and configure our databases; we can add as many contexts as we need.

IServiceCollection services = ...

services.AddSqlDbContextProvider()
    .AddDbContext( "my-db", "connection_string" )
    .AddDbContext( "my-other-db", "connection_string" );

Wherever we need to get access to our database context, we'll use the injected IDbContextFactory instance to retrieve an IDbContext instance.

public class Example
{
    private readonly IDbContext mydb;

    public Example( IDbContextFactory dbContextFactory )
    {
        mydb = dbContextFactory.GetDbContext( "my-db" );
    }

    // ...
}

When we require a new connection, we'll use the IDbContext instance to construct it.

public class Example
{
    private readonly IDbContext mydb;

    // ...

    public async Task DoSomethingAsync()
    {
        using ( var connection = mydb.GetDbConnection() )
        {
            await connection.OpenAsync();

            // ...
        }
    }
}

We can also construct the connection and open it directly

public async Task DoSomethingAsync()
{
    using ( var connection = await mydb.OpenAsync() )
    {
        // ...
    }
}

From this point forward, we'll have a DbConnection instance ready to use. Please note that all DbConnection instances should be properly disposed after use. Most of the ADO implementations will pool connections and not properly disposing them can lead to exceeding the number of open connections (connection leaks).

Notice: Starting with version 0.6, the library has switched to use the DbConnection class instead of the IDbConnection interface. This was done mostly because the interface doesn't expose the async methods. Since DbConnection should be the base class for most (if not all) ADO.NET providers, this transition shouldn't cause any braking changes. Nonetheless, if you're using the IDbConnection interface, you'll have to update your code to use the DbConnection class instead.

Transactions

As an alternative to the DbConnection.BeginTransaction[Async] methods, there are extensions available to shorten the amount of code written. The UseTransaction[Async] methods take care of opening/reusing a connection, creating a transaction and gracefully disposing of it all when finished.

public async Task DoSomethingAsync()
{
    await mydb.UseTransactionAsync( async t =>
    {
        var sqlCommand = t.Connection.CreateCommand();

        // ...

        await t.CommitAsync();
    } );
}

If an exception is thrown, the transaction is automatically rolled back. We can also provide additional behaviour to when this happens.

public async Task DoSomethingAsync()
{
    await mydb.UseTransactionAsync( async t =>
    {
        var sqlCommand = t.Connection.CreateCommand();

        // ...

        await t.CommitAsync();
    }, ex =>
    {
        // handle exception
    } );
}