Por Dennes Torres dennes@bufaloinfo.com.br Dennes Torres possui as certificações MCAD, MCSD,MCSE, MCDBA e MCT. Atualmente atua Como diretor da Búfalo Informática, líder do grupo de usuários DevASPNet no Rio de Janeiro e membro da liderança dos grupos getWindows e devSQL, também do Rio de Janeiro, podendo sempre ser encontrado na lista de discussão do grupo DevASPNet (devaspnet-subscribe@yahoogrupos.com.br) bem como nas reuniões do grupo. Mantém dois blogs em http://cidadaocarioca.blogspot.com
System.Transactions e DbConnectionScope

Pesquisa personalizada

No Framework .NET 2.0 foi criado um namespace chamado System.Transactions com o objetivo de controlar transações de negócio, o que a principio seriam transações distribuidas.

Este conceito já existia anteriormente, no COM+, mas para muitos foi uma grande novidade. Porém é um conceito tão natural e necessário para o desenvolvimento em camadas que antes do surgimento do System.Transactions - e antes que muitos se acostumassem com ele - já se buscavam soluções alternativas.

Um exemplo : Em um sistema em camadas, imagine a existência de um componente de Estoque, e um de clientes. Para realizar uma venda, o componente de estoque teria que ser chamado para reduzir o estoque e o de clientes para cadastrar os clientes.

A questão é que todo o processo - a venda - precisaria ser transacional. Porém o componente e estoque e o de clientes precisam, em um sistema OO bem delineado, ser independentes, controlando sua própria conexão de acesso a banco.

É neste ponto que entra o namespace System.Transactions. Com ele podemos abrir uma transação e incorporar na transação ações de métodos de outros componentes. Os métodos em questão não precisam ter sido codificados especialmente para fazer parte da transação, serão incorporados a ela automaticamente :

   1: using tr as new transactionscope()

   2:     try

   3:         objEstoque.ReduzEstoque(qtd)

   4:         objCliente.CadastraCliente(Dados)

   5:         tr.complete

   6:     catch ex as exception

   7:         tr.dispose

   8:     end try

   9: end using

A mágica é feita por um serviço que faz parte do sistema operacional desde o Windows 2000, o MSDTC - Microsoft Distributed Transaction Coordinator. O MSDTC assume o controle da transação, interceptando as conexões a banco para fazer contato com os servidores de forma transacional.

Antes da existência do namespace System.Transactions, desenvolvedores criavam alternativas passando como parâmetro para os métodos uma conexão aberta. Com a conexão sendo passada como parâmetro, todos os métodos estariam utilizando a mesma conexão de banco, tornando possível fazer uma transação diretamente com a conexão de banco.

O problema desta alternativa que foi muito usada é que criava uma dependência entre classes que deveriam ser mais independentes, criando um alto acoplamento entre os componentes. O System.Transactions, então, sempre foi a solução ideal.

Porém nem todos apreciam o uso do System.Transactions. Isso porque as transações distribuidas com MSDTC consomem mais recursos da máquina do que uma simples transação de banco.

Em uma revitalização do antigo modelo de compartilhamento de conexões, membros da equipe de ADO.NET da Microsoft disponibilizaram o código fonte de uma classe chamada dbConnectionScope. Em resumo, esta classe permite o compartilhamento de conexões entre componentes, mas sem aumentar demasiadamente o acoplamento, criando um meio termo entre ambas as soluções.

Aplicando a classe dbConnectionScope, o código da transação fica da seguinte forma :

   1: using tr as new transactionscope

   2:     using db as new dbConnectionScope

   3:         try

   4:             objestoque.ReduzEstoque(qtd)

   5:             objCliente.CadastraCliente(dados)

   6:             tr.Complete()

   7:         catch ex as exception

   8:             tr.Dispose()

   9:         end try

  10:     end using

  11: end using

O segredo fica dentro do código interno dos método ReduzEstoque e CadastraCliente : Sim, os métodos precisarão ter sido construidos de forma a suportar este recurso. Porém a classe dbConnectionScope  é, digamos, hibrida, funciona com ou sem transação. Veja o ponto chave dentro do método :

   1: cmd.Connection = DbConnectionScope.Current.GetOpenConnection(SqlClientFactory.Instance, connStr)

Desta forma, é a classe DbConnectionScope que fornece a conexão de ambos os métodos. Esta classe guarda as conexões anteriormente abertas para serem re-utilizadas nos métodos.

O resultado é que, com 2 métodos utilizando uma única conexão, o TransactionScope não precisa elevar o nível da transação para transação distribuida, podendo utilizar uma simples transação de banco, mantendo assim a aplicação mais leve.

Considerando a técnica com tableAdapters que gosto de utilizar, o código de uma transação distribuida fica da seguinte forma :

   1: Using tr As New TransactionScope

   2:     Try

   3:         trCli.AtualizarRegiao("Rio", "Brazil")

   4:         trprod.AumentarPreco(1.1)

   5:         tr.Complete()

   6:     Catch ex As Exception

   7:         tr.Dispose()

   8:     End Try

   9: End Using

Para utilizar o DbConnectionScope neste exemplo temos 2 opções : Podemos utilizar partial class do table adapter ou podemos fazer isso diretamente na montagem da transação, veja como fica este 2o caso :

   1: Using tr As New TransactionScope

   2:     Using db As New DbConnectionScope

   3:         Try

   4:             trCli.Connection = DbConnectionScope.Current.GetOpenConnection(SqlClientFactory.Instance, trCli.Connection.ConnectionString)

   5:             trprod.Connection = DbConnectionScope.Current.GetOpenConnection(SqlClientFactory.Instance, trCli.Connection.ConnectionString)

   6:             trCli.AtualizarRegiao("Rio", "Brazil")

   7:             trprod.AumentarPreco(1.1)

   8:             tr.Complete()

   9:         Catch ex As Exception

  10:             tr.Dispose()

  11:         End Try

  12:     End Using

  13: End Using

O interessante deste caso é que o controle da conexão pode ser programado dentro dos tableAdapters - através das partial class - ou fora, como no exemplo acima.

Veja como fica o resultado destas duas transações pelo SQL Profiler :

Observe no resultado acima a diferença entre uma transação distribuida simples - com duas conexões - e uma transação utilizando o dbconnectionscope, mantendo consequentemente uma única conexão nos acessos a dados.

O resultado também pode ser observado na análise das estatísticas de transação do MSDTC. Isso pode ser obtido rodando-se o MMC e adicionando-se o snap-in do gerenciador de componentes, então observamos o seguinte :

A observação é simples : A cada vez que executamos a transação distribuida simples a quantidade de transações na estatística do MSDTC aumenta automaticamente. Quando rodamos a transação com o DbConnectionScope a quantidade fica inalterada.

Observações

O TransactionScope não abre diretamente uma transação distribuida como poderia-se pensar, ele apenas transforma a transação em distribuida se isso se tornar necessário durante a execução.

O DbConnectionScope é uma forma elegante de trabalhar e mantém um acoplamento menor do que as antigas gambiarras, mas o acoplamento ainda não é tão baixo quando poderia com as transações distribuidas especialmente se considerar as limitações de uso de uma mesma conexão (não poder manter dois datareaders simultâneos, exceto com MARS). Enfim, é uma escolha delicada de arquitetura.

O ThreadStatic no código do DbConnectionScope deve ser alterado para que funcione em ambiente WEB - ASP.NET