La bonne façon d'utiliser BeginTransaction avec Dapper.IDbConnection

Manuellement l'ouverture de la connexion n'est pas "mauvaise pratique"; dapper fonctionne avec ouvert ou fermé connexions commodité, rien de plus. D'un commun gotcha est que les gens ayant des connexions qui sont laissées ouvertes, non utilisé, trop longtemps sans jamais les publier à la piscine - cependant, ce n'est pas un problème dans la plupart des cas, et vous pouvez certainement le faire:

using(var cn = CreateConnection()) {
    cn.Open();
    using(var tran = cn.BeginTransaction()) {
        try {
            //multiple operations involving cn and tran here

            tran.Commit();
        } catch {
            tran.Rollback();
            throw;
        }
    }
}

Noter que dapper est un paramètre facultatif pour passer dans la transaction, par exemple:

cn.Execute(sql, args, transaction: tran);

Je suis en fait tenté pour rendre les méthodes d'extension sur IDbTransaction qui fonctionnent de la même façon, depuis une opération toujours expose .Connexion; cela permettrait:

tran.Execute(sql, args);

Mais cela n'existe pas aujourd'hui.

TransactionScope est une autre option, mais ont des sémantiques différentes: cela pourrait impliquer la LTM ou la DTC, selon ... eh bien, la chance, principalement. Il est également tentant de créer un wrapper autour de IDbTransaction qui n'a pas besoin de la try/catch - plus comme la façon dont TransactionScope œuvres; quelque chose comme (cela n'existe pas):

using(var cn = CreateConnection())
using(var tran = cn.SimpleTransaction())
{
    tran.Execute(...);
    tran.Execute(...);

    tran.Complete();
}

Prendre un coup d'oeil à Tim Schreiber solution qui est simple, mais puissant et mis en œuvre en utilisant un modèle de référentiel et a Dapper Transactions à l'esprit.

La Commit() dans le code ci-dessous montre qu'il s'.

public class UnitOfWork : IUnitOfWork
{
private IDbConnection _connection;
private IDbTransaction _transaction;
private IBreedRepository _breedRepository;
private ICatRepository _catRepository;
private bool _disposed;
public UnitOfWork(string connectionString)
{
_connection = new SqlConnection(connectionString);
_connection.Open();
_transaction = _connection.BeginTransaction();
}
public IBreedRepository BreedRepository
{
get { return _breedRepository ?? (_breedRepository = new BreedRepository(_transaction)); }
}
public ICatRepository CatRepository
{
get { return _catRepository ?? (_catRepository = new CatRepository(_transaction)); }
}
public void Commit()
{
try
{
_transaction.Commit();
}
catch
{
_transaction.Rollback();
throw;
}
finally
{
_transaction.Dispose();
_transaction = _connection.BeginTransaction();
resetRepositories();
}
}
private void resetRepositories()
{
_breedRepository = null;
_catRepository = null;
}
public void Dispose()
{
dispose(true);
GC.SuppressFinalize(this);
}
private void dispose(bool disposing)
{
if (!_disposed)
{
if(disposing)
{
if (_transaction != null)
{
_transaction.Dispose();
_transaction = null;
}
if(_connection != null)
{
_connection.Dispose();
_connection = null;
}
}
_disposed = true;
}
}
~UnitOfWork()
{
dispose(false);
}
}