Encapsulamento de modificações de banco de dados em uma transação (VB)

por Scott Mitchell

Baixar PDF

Este tutorial é o primeiro dos quatro que analisa a atualização, a exclusão e a inserção de lotes de dados. Neste tutorial, aprendemos como as transações de banco de dados permitem que as modificações em lote sejam realizadas como uma operação atômica, o que garante que todas as etapas sejam bem-sucedidas ou todas as etapas falhem.

Introdução

Como vimos começando com o tutorial Uma Visão Geral de Inserção, Atualização e Exclusão de Dados , o GridView fornece suporte interno para edição e exclusão em nível de linha. Com alguns cliques do mouse, é possível criar uma interface rica de modificação de dados sem escrever uma linha de código, desde que você esteja satisfeito com a edição e exclusão por linha. No entanto, em determinados cenários isso é insuficiente e precisamos fornecer aos usuários a capacidade de editar ou excluir um lote de registros.

Por exemplo, a maioria dos clientes de email baseados na Web usa uma grade para listar cada mensagem em que cada linha inclui uma caixa de seleção junto com as informações de email (assunto, remetente e assim por diante). Essa interface permite que o usuário exclua várias mensagens verificando-as e clicando em um botão Excluir Mensagens Selecionadas. Uma interface de edição em lote é ideal em situações em que os usuários geralmente editam muitos registros diferentes. Em vez de forçar o usuário a clicar em Editar, fazer a alteração e clicar em Atualizar para cada registro que precisa ser modificado, uma interface de edição em lote renderiza cada linha com sua interface de edição. O usuário pode modificar rapidamente o conjunto de linhas que precisam ser alteradas e, em seguida, salvar essas alterações clicando em um botão Atualizar Tudo. Neste conjunto de tutoriais, examinaremos como criar interfaces para inserir, editar e excluir lotes de dados.

Ao executar operações em lote, é importante determinar se deve ser possível que algumas das operações no lote tenham êxito enquanto outras falham. Considere uma interface de exclusão em lote – o que deve acontecer se o primeiro registro selecionado for excluído com êxito, mas o segundo falhará, digamos, devido a uma violação de restrição de chave estrangeira? A exclusão do primeiro registro deve ser revertida ou é aceitável que o primeiro registro permaneça excluído?

Se você quiser que a operação em lote seja tratada como uma operação atômica, uma em que todas as etapas são bem-sucedidas ou todas as etapas falham, a Camada de Acesso a Dados precisa ser aumentada para incluir suporte para transações de banco de dados. As transações de banco de dados garantem a atomicidade para o conjunto de instruções INSERT, UPDATE e DELETE executadas dentro do escopo da transação e são um recurso suportado pela maioria dos sistemas de banco de dados modernos.

Neste tutorial, examinaremos como estender o DAL para usar transações de banco de dados. Os tutoriais subsequentes examinarão a implementação de páginas da Web para inserir, atualizar e excluir interfaces em lote. Vamos começar!

Observação

Ao modificar dados em uma transação em lote, a atomicidade nem sempre é necessária. Em alguns cenários, pode ser aceitável ter algumas modificações de dados bem-sucedidas e outras no mesmo lote falharem, como ao excluir um conjunto de emails de um cliente de email baseado na Web. Se houver um erro de banco de dados no meio do processo de exclusão, provavelmente é aceitável que esses registros processados sem erro permaneçam excluídos. Nesses casos, o DAL não precisa ser modificado para dar suporte a transações de banco de dados. Há outros cenários de operação em lotes, no entanto, em que a atomicidade é vital. Quando um cliente move seus fundos de uma conta bancária para outra, duas operações devem ser executadas: os fundos devem ser deduzidos da primeira conta e, em seguida, adicionados ao segundo. Embora o banco possa não se importar em ter o primeiro passo bem-sucedido e o segundo falhar, seus clientes ficariam compreensivelmente chateados. Eu o encorajo a trabalhar neste tutorial e implementar os aprimoramentos no DAL para dar suporte a transações de banco de dados, mesmo que você não planeje usá-los nas operações de inserção, atualização e exclusão em lote que criaremos nas três interfaces dos tutoriais a seguir.

Uma visão geral das transações

A maioria dos bancos de dados inclui suporte para transações, que permitem que vários comandos de banco de dados sejam agrupados em uma única unidade lógica de trabalho. Os comandos de banco de dados que compõem uma transação têm a garantia de serem atômicos, o que significa que todos os comandos falharão ou todos serão bem-sucedidos.

Em geral, as transações são implementadas por meio de instruções SQL usando o seguinte padrão:

1. Indique o início de uma transação.
2. Execute as instruções SQL que compõem a transação.
3. Se houver um erro em uma das instruções da Etapa 2, reverta a transação.
4. Se todas as instruções da Etapa 2 forem concluídas sem erro, confirme a transação.

As instruções SQL usadas para criar, confirmar e reverter a transação podem ser inseridas manualmente ao escrever scripts SQL ou criar procedimentos armazenados ou por meio de meios programáticos usando ADO.NET ou as classes no System.Transactions namespace. Neste tutorial, examinaremos apenas o gerenciamento de transações usando ADO.NET. Em um tutorial futuro, examinaremos como usar procedimentos armazenados na Camada de Acesso a Dados, momento em que exploraremos as instruções SQL para criar, reverter e confirmar transações. Enquanto isso, consulte Gerenciar Transações em Procedimentos Armazenados do SQL Server para obter mais informações.

Observação

A TransactionScope classe no System.Transactions namespace permite aos desenvolvedores encapsular programaticamente uma série de instruções no escopo de uma transação e inclui suporte para transações complexas que envolvem várias fontes, como dois bancos de dados diferentes ou até mesmo tipos heterogêneos de armazenamentos de dados, como um banco de dados do Microsoft SQL Server, um banco de dados Oracle e um serviço Web. Decidi usar ADO.NET transações para este tutorial em vez da TransactionScope classe porque ADO.NET é mais específico para transações de banco de dados e, em muitos casos, é muito menos intensivo em recursos. Além disso, em determinados cenários, a TransactionScope classe usa o MSDTC (Coordenador de Transações Distribuídas da Microsoft). Os problemas de configuração, implementação e desempenho em torno do MSDTC o tornam um tópico bastante especializado e avançado e além do escopo desses tutoriais.

Ao trabalhar com o provedor sqlClient em ADO.NET, as transações são iniciadas por meio de uma chamada para o SqlConnection método da BeginTransactionclasse, que retorna um SqlTransaction objeto. As instruções de modificação de dados que compõem a transação são colocadas dentro de um try...catch bloco. Se ocorrer um erro em uma instrução no bloco try, a execução será transferida para o bloco catch, onde a transação pode ser revertida por meio do método Rollback do objeto . Se todas as instruções forem concluídas com êxito, uma chamada ao método SqlTransaction do objeto Commit no final do bloco confirmará a transação. O snippet de código a seguir ilustra esse padrão.

' Create the SqlTransaction object
Dim myTransaction As SqlTransaction = SqlConnectionObject.BeginTransaction();
Try
    '
    ' ... Perform the database transaction�s data modification statements...
    '
    ' If we reach here, no errors, so commit the transaction
    myTransaction.Commit()
Catch
    ' If we reach here, there was an error, so rollback the transaction
    myTransaction.Rollback()
    Throw
End Try

Por padrão, os TableAdapters em um Conjunto de Dados Tipado não usam transações. Para fornecer suporte para transações, precisamos aumentar as classes TableAdapter para incluir métodos adicionais que usam o padrão acima para executar uma série de instruções de modificação de dados no escopo de uma transação. Na Etapa 2, veremos como usar classes parciais para adicionar esses métodos.

Etapa 1: Criando as Páginas da Web de Trabalho com Dados em Lote

Antes de começarmos a explorar como aumentar o DAL para dar suporte a transações de banco de dados, vamos primeiro ter um momento para criar as páginas da Web ASP.NET que precisaremos para este tutorial e as três a seguir. Comece adicionando uma nova pasta nomeada BatchData e adicione as seguintes páginas ASP.NET, associando cada página à Site.master página mestra.

• Default.aspx
• Transactions.aspx
• BatchUpdate.aspx
• BatchDelete.aspx
• BatchInsert.aspx

Figura 1: Adicionar as páginas de ASP.NET para os tutoriais do SqlDataSource-Related

Assim como acontece com as outras pastas, Default.aspx usará o SectionLevelTutorialListing.ascx Controle de Usuário para listar os tutoriais em sua seção. Portanto, adicione esse Controle de Usuário arrastando-o Default.aspx do Gerenciador de Soluções para o modo de exibição Design da página.

Figura 2: Adicionar o controle de SectionLevelTutorialListing.ascx usuário (Default.aspxclique para exibir a imagem em tamanho real)

Por fim, adicione essas quatro páginas como entradas ao Web.sitemap arquivo. Especificamente, adicione a seguinte marcação após a Personalização do Mapa <siteMapNode>do Site:

<siteMapNode title="Working with Batched Data" 
    url="~/BatchData/Default.aspx" 
    description="Learn how to perform batch operations as opposed to 
                 per-row operations.">
    
    <siteMapNode title="Adding Support for Transactions" 
        url="~/BatchData/Transactions.aspx" 
        description="See how to extend the Data Access Layer to support 
                     database transactions." />
    <siteMapNode title="Batch Updating" 
        url="~/BatchData/BatchUpdate.aspx" 
        description="Build a batch updating interface, where each row in a 
                      GridView is editable." />
    <siteMapNode title="Batch Deleting" 
        url="~/BatchData/BatchDelete.aspx" 
        description="Explore how to create an interface for batch deleting 
                     by adding a CheckBox to each GridView row." />
    <siteMapNode title="Batch Inserting" 
        url="~/BatchData/BatchInsert.aspx" 
        description="Examine the steps needed to create a batch inserting 
                     interface, where multiple records can be created at the 
                     click of a button." />
</siteMapNode>

Após a atualização Web.sitemap, reserve um momento para visualizar o site de tutoriais por meio de um navegador. O menu à esquerda agora inclui itens para tutoriais sobre processamento de dados em lote.

Figura 3: O mapa do site agora inclui entradas para o trabalho com tutoriais de dados em lote

Etapa 2: Atualizando a camada de acesso a dados para dar suporte a transações de banco de dados

Como discutimos no primeiro tutorial, Criando uma camada de acesso a dados, o Conjunto de Dados Tipado em nosso DAL é composto por DataTables e TableAdapters. Os DataTables contêm dados enquanto os TableAdapters fornecem a funcionalidade de ler dados do banco de dados para os DataTables, atualizar o banco de dados com alterações feitas nas DataTables e assim por diante. Lembre-se de que os TableAdapters fornecem dois padrões para atualizar dados, que eu referi como Atualização em Lote e DB-Direct. Com o padrão de Atualização em Lote, o TableAdapter recebe um DataSet, DataTable ou coleção de DataRows. Esses dados são enumerados e para cada linha inserida, modificada ou excluída, a InsertCommand, UpdateCommandou DeleteCommand é executada. Com o padrão DB-Direct, são-lhe passados os valores das colunas necessárias para inserir, atualizar ou excluir um único registro no TableAdapter. Em seguida, o método de padrão direto do BD usa esses valores passados para executar a instrução apropriada InsertCommand, UpdateCommand ou DeleteCommand.

Independentemente do padrão de atualização usado, os métodos gerados automaticamente pelo TableAdapters não usam transações. Por padrão, cada inserção, atualização ou exclusão executada pelo TableAdapter é tratada como uma única operação discreta. Por exemplo, imagine que o padrão de DB-Direct é usado por algum código na BLL para inserir dez registros no banco de dados. Esse código chamaria dez vezes o método do TableAdapter Insert. Se as cinco primeiras inserções forem bem-sucedidas, mas a sexta resultar em uma exceção, os cinco primeiros registros inseridos permanecerão no banco de dados. Da mesma forma, se o padrão de Atualização em Lote for usado para executar inserções, atualizações e exclusões nas linhas inseridas, modificadas e excluídas em uma DataTable, se as primeiras várias modificações tiverem sido bem-sucedidas, mas uma posterior encontrar um erro, as modificações anteriores concluídas permanecerão no banco de dados.

Em certos cenários, queremos garantir a atomicidade em uma série de modificações. Para fazer isso, devemos estender manualmente o TableAdapter adicionando novos métodos que executam o InsertCommand, UpdateCommand e DeleteCommand sob o contexto de uma transação. Ao criar uma camada de acesso a dados , analisamos o uso de classes parciais para estender a funcionalidade das DataTables dentro do Conjunto de Dados Tipado. Essa técnica também pode ser usada com TableAdapters.

O Conjunto de Dados Northwind.xsd Digitado está localizado na App_Code subpasta da DAL pasta. Crie uma subpasta na DAL pasta nomeada TransactionSupport e adicione um novo arquivo de classe chamado ProductsTableAdapter.TransactionSupport.vb (consulte a Figura 4). Esse arquivo conterá a implementação parcial do ProductsTableAdapter, que inclui métodos para executar modificações de dados usando uma transação.

Figura 4: Adicionar uma pasta nomeada TransactionSupport e um arquivo de classe nomeado ProductsTableAdapter.TransactionSupport.vb

Insira o seguinte código no ProductsTableAdapter.TransactionSupport.vb arquivo:

Imports System.Data
Imports System.Data.SqlClient
Namespace NorthwindTableAdapters
    Partial Public Class ProductsTableAdapter
        Private _transaction As SqlTransaction
        Private Property Transaction() As SqlTransaction
            Get
                Return Me._transaction
            End Get
            Set(ByVal Value As SqlTransaction)
                Me._transaction = Value
            End Set
        End Property
        Public Sub BeginTransaction()
            ' Open the connection, if needed
            If Me.Connection.State <> ConnectionState.Open Then
                Me.Connection.Open()
            End If
            ' Create the transaction and assign it to the Transaction property
            Me.Transaction = Me.Connection.BeginTransaction()
            ' Attach the transaction to the Adapters
            For Each command As SqlCommand In Me.CommandCollection
                command.Transaction = Me.Transaction
            Next
            Me.Adapter.InsertCommand.Transaction = Me.Transaction
            Me.Adapter.UpdateCommand.Transaction = Me.Transaction
            Me.Adapter.DeleteCommand.Transaction = Me.Transaction
        End Sub
        Public Sub CommitTransaction()
            ' Commit the transaction
            Me.Transaction.Commit()
            ' Close the connection
            Me.Connection.Close()
        End Sub
        Public Sub RollbackTransaction()
            ' Rollback the transaction
            Me.Transaction.Rollback()
            ' Close the connection
            Me.Connection.Close()
        End Sub
    End Class
End Namespace

A Partial palavra-chave na declaração de classe aqui indica ao compilador que os membros adicionados dentro devem ser adicionados à ProductsTableAdapter classe no NorthwindTableAdapters namespace. Observe a Imports System.Data.SqlClient instrução na parte superior do arquivo. Como o TableAdapter foi configurado para usar o provedor sqlClient, ele usa internamente um SqlDataAdapter objeto para emitir seus comandos para o banco de dados. Consequentemente, precisamos usar a SqlTransaction classe para iniciar a transação e, em seguida, confirmá-la ou revertê-la. Se você estiver usando um armazenamento de dados diferente do Microsoft SQL Server, precisará usar o provedor apropriado.

Esses métodos fornecem os blocos de construção necessários para iniciar, reverter e confirmar uma transação. Elas são marcadas Public, permitindo que sejam usadas de dentro do ProductsTableAdapter, de outra classe no DAL ou de outra camada na arquitetura, como a BLL. BeginTransaction abre o TableAdapter interno SqlConnection (se necessário), inicia a transação e a atribui à propriedade Transaction, e anexa a transação aos objetos internos SqlDataAdapter e SqlCommand. CommitTransaction e RollbackTransaction chamam os métodos Transaction e Commit do objeto Rollback, respectivamente, antes de fechar o objeto interno Connection.

Etapa 3: Adicionar métodos para atualizar e excluir dados sob o guarda-chuva de uma transação

Com esses métodos concluídos, estamos prontos para adicionar métodos a ProductsDataTable ou a BLL que executem uma série de comandos sob a égide de uma transação. O método a seguir usa o padrão de Atualização em Lote para atualizar uma ProductsDataTable instância usando uma transação. Ele inicia uma transação chamando o BeginTransaction método e, em seguida, usa um Try...Catch bloco para emitir as instruções de modificação de dados. Se a chamada para o Adapter método do Update objeto resultar em uma exceção, a execução será transferida para o catch bloco em que a transação será revertida e a exceção será relançada. Lembre-se de que o método Update implementa o padrão de Atualização em Lote ao enumerar as linhas do ProductsDataTable fornecido e ao realizar as operações necessárias de InsertCommand, UpdateCommand e DeleteCommand. Se qualquer um desses comandos resultar em um erro, a transação será revertida, desfazendo as modificações anteriores feitas durante o tempo de vida da transação. Se a instrução Update for concluída sem erros, a transação será confirmada em sua totalidade.

Public Function UpdateWithTransaction _
    (ByVal dataTable As Northwind.ProductsDataTable) As Integer
    
    Me.BeginTransaction()
    Try
        ' Perform the update on the DataTable
        Dim returnValue As Integer = Me.Adapter.Update(dataTable)
        ' If we reach here, no errors, so commit the transaction
        Me.CommitTransaction()
        Return returnValue
    Catch
        ' If we reach here, there was an error, so rollback the transaction
        Me.RollbackTransaction()
        Throw
    End Try
End Function

Adicione o método UpdateWithTransaction à classe ProductsTableAdapter através da classe parcial em ProductsTableAdapter.TransactionSupport.vb. Como alternativa, esse método pode ser adicionado à classe ProductsBLL da Camada de Lógica de Negócios com algumas pequenas alterações sintáticas. Ou seja, a palavra-chave Me em Me.BeginTransaction(), Me.CommitTransaction(), e Me.RollbackTransaction() precisaria ser substituída por Adapter (lembre-se que Adapter é o nome de uma propriedade no ProductsBLL do tipo ProductsTableAdapter).

O UpdateWithTransaction método usa o padrão de Atualização em Lote, mas uma série de chamadas DB-Direct também podem ser usadas no escopo de uma transação, como mostra o método a seguir. O método DeleteProductsWithTransaction aceita como entrada um List(Of T) do tipo Integer, que são os ProductIDs a serem excluídos. O método inicia a transação por meio de uma chamada para BeginTransaction e, em seguida, no bloco Try, itera através da lista fornecida chamando o método do padrão DB-Direct Delete para cada valor ProductID. Se qualquer uma das chamadas a Delete falhar, o controle será transferido para o bloco Catch, onde a transação é revertida e a exceção será lançada novamente. Se todas as chamadas forem Delete bem-sucedidas, a transação será efetuada. Adicione esse método à ProductsBLL classe.

Public Sub DeleteProductsWithTransaction _
    (ByVal productIDs As System.Collections.Generic.List(Of Integer))
    
    ' Start the transaction
    Adapter.BeginTransaction()
    Try
        ' Delete each product specified in the list
        For Each productID As Integer In productIDs
            Adapter.Delete(productID)
        Next
        ' Commit the transaction
        Adapter.CommitTransaction()
    Catch
        ' There was an error - rollback the transaction
        Adapter.RollbackTransaction()
        Throw
    End Try
End Sub

Aplicando transações em vários TableAdapters

O código relacionado à transação examinado neste tutorial permite que várias instruções referentes ao ProductsTableAdapter sejam tratadas como uma operação atômica. Mas e se várias modificações em tabelas de banco de dados diferentes precisarem ser executadas atomicamente? Por exemplo, ao excluir uma categoria, talvez primeiro queiramos reatribuir seus produtos atuais para alguma outra categoria. Essas duas etapas para reatribuir os produtos e excluir a categoria devem ser executadas como uma operação atômica. Mas os ProductsTableAdapter métodos incluem apenas para modificar a Products tabela e os CategoriesTableAdapter métodos incluem apenas para modificar a Categories tabela. Então, como uma transação pode abranger os dois TableAdapters?

Uma opção é adicionar um método ao CategoriesTableAdapter nomeado DeleteCategoryAndReassignProducts(categoryIDtoDelete, reassignToCategoryID) e fazer com que esse método chame um procedimento armazenado que reatribua os produtos e exclua a categoria dentro do escopo de uma transação definida dentro do procedimento armazenado. Examinaremos como iniciar, confirmar e reverter transações em procedimentos armazenados em um tutorial futuro.

Outra opção é criar uma classe auxiliar no DAL que contenha o DeleteCategoryAndReassignProducts(categoryIDtoDelete, reassignToCategoryID) método. Esse método criaria uma instância de CategoriesTableAdapter e de ProductsTableAdapter, e então definiria as propriedades dos dois TableAdapters Connection para a mesma instância SqlConnection. Nesse ponto, um dos dois TableAdapters iniciaria a transação com uma chamada para BeginTransaction. Os métodos dos TableAdapters para reatribuir os produtos e excluir a categoria seriam invocados em um bloco Try...Catch com a transação sendo confirmada ou revertida conforme necessário.

Etapa 4: Adicionar oUpdateWithTransactionmétodo à camada lógica de negócios

Na Etapa 3, adicionamos um método UpdateWithTransaction à ProductsTableAdapter DAL. Devemos adicionar um método correspondente à BLL. Embora a Camada de Apresentação possa chamar diretamente o DAL para invocar o UpdateWithTransaction método, esses tutoriais têm se esforçado para definir uma arquitetura em camadas que isole o DAL da Camada de Apresentação. Portanto, cabe a nós continuar essa abordagem.

Abra o ProductsBLL arquivo de classe e adicione um método chamado UpdateWithTransaction que simplesmente faz chamadas para o método DAL correspondente. Agora deve haver dois novos métodos em ProductsBLL: UpdateWithTransaction, que você acabou de adicionar e DeleteProductsWithTransaction, que foi adicionado na Etapa 3.

Public Function UpdateWithTransaction _
    (ByVal products As Northwind.ProductsDataTable) As Integer
    
    Return Adapter.UpdateWithTransaction(products)
End Function
Public Sub DeleteProductsWithTransaction _
    (ByVal productIDs As System.Collections.Generic.List(Of Integer))
    
    ' Start the transaction
    Adapter.BeginTransaction()
    Try
        ' Delete each product specified in the list
        For Each productID As Integer In productIDs
            Adapter.Delete(productID)
        Next
        ' Commit the transaction
        Adapter.CommitTransaction()
    Catch
        ' There was an error - rollback the transaction
        Adapter.RollbackTransaction()
        Throw
    End Try
End Sub

Observação

Esses métodos não incluem o DataObjectMethodAttribute atributo atribuído à maioria dos outros métodos na ProductsBLL classe porque invocaremos esses métodos diretamente das classes code-behind de páginas ASP.NET. Lembre-se de que DataObjectMethodAttribute é usado para sinalizar quais métodos devem aparecer no assistente Configurar Fonte de Dados do ObjectDataSource e em qual guia (SELECT, UPDATE, INSERT ou DELETE). Como o GridView não tem suporte interno para edição ou exclusão em lote, teremos que invocar esses métodos programaticamente em vez de usar a abordagem declarativa sem código.

Etapa 5: Atualizar atomicamente dados de banco de dados da camada de apresentação

Para ilustrar o efeito que a transação tem ao atualizar um lote de registros, vamos criar uma interface do usuário que lista todos os produtos em um GridView e inclui um controle Web de botão que, quando clicado, reatribui os valores dos produtos CategoryID . Em particular, a reatribuição de categoria progredirá para que os primeiros produtos sejam atribuídos com um valor válido CategoryID, enquanto outros recebam propositalmente um valor inexistente CategoryID. Se tentarmos atualizar o banco de dados com um produto cuja CategoryID categoria não corresponda a CategoryIDuma categoria existente, ocorrerá uma violação de restrição de chave estrangeira e uma exceção será gerada. O que veremos neste exemplo é que, ao usar uma transação, a exceção gerada da violação de restrição de chave estrangeira fará com que as alterações válidas CategoryID anteriores sejam revertidas. Quando não estiver usando uma transação, no entanto, as modificações nas categorias iniciais permanecerão.

Comece abrindo a Transactions.aspxBatchData página na pasta e arraste um GridView da Caixa de Ferramentas para o Designer. Defina-o ID como Products e, a partir de sua marca inteligente, vincule-o a um novo ObjectDataSource chamado ProductsDataSource. Configure o ObjectDataSource para extrair seus dados do ProductsBLL método da GetProducts classe. Esse será um GridView somente leitura, portanto, defina as listas suspensas nas guias UPDATE, INSERT e DELETE como (None) e clique em Concluir.

Figura 5: Configurar o ObjectDataSource para usar o ProductsBLL método da GetProducts classe (clique para exibir a imagem em tamanho real)

Figura 6: Definir as listas de Drop-Down nas guias UPDATE, INSERT e DELETE como (Nenhum) (Clique para exibir a imagem em tamanho real)

Depois de concluir o assistente Configurar Fonte de Dados, o Visual Studio criará BoundFields e um CheckBoxField para os campos de dados do produto. Remova todos esses campos, exceto ProductID, ProductName, CategoryID e CategoryName, e renomeie as propriedades BoundFields ProductName e CategoryName para Produto e Categoria, respectivamente. Na marca inteligente, verifique a opção Habilitar Paginação. Depois de fazer essas modificações, a marcação declarativa de GridView e ObjectDataSource deve ser semelhante à seguinte:

<asp:GridView ID="Products" runat="server" AllowPaging="True" 
    AutoGenerateColumns="False" DataKeyNames="ProductID" 
    DataSourceID="ProductsDataSource">
    <Columns>
        <asp:BoundField DataField="ProductID" HeaderText="ProductID" 
            InsertVisible="False" ReadOnly="True" 
            SortExpression="ProductID" />
        <asp:BoundField DataField="ProductName" HeaderText="Product" 
            SortExpression="ProductName" />
        <asp:BoundField DataField="CategoryID" HeaderText="CategoryID" 
            SortExpression="CategoryID" />
        <asp:BoundField DataField="CategoryName" HeaderText="Category" 
            SortExpression="CategoryName" />
    </Columns>
</asp:GridView>
<asp:ObjectDataSource ID="ProductsDataSource" runat="server" 
    OldValuesParameterFormatString="original_{0}"
    SelectMethod="GetProducts" TypeName="ProductsBLL">
</asp:ObjectDataSource>

Em seguida, adicione três controles Web de botão acima do GridView. Defina a propriedade Texto do primeiro Botão como Atualizar Grade, a do segundo como Modificar Categorias (COM TRANSAÇÃO) e a do terceiro como Modificar Categorias (SEM TRANSAÇÃO).

<p>
    <asp:Button ID="RefreshGrid" runat="server" Text="Refresh Grid" />
</p>
<p>
    <asp:Button ID="ModifyCategoriesWithTransaction" runat="server"
        Text="Modify Categories (WITH TRANSACTION)" />
</p>
<p>
    <asp:Button ID="ModifyCategoriesWithoutTransaction" runat="server"
        Text="Modify Categories (WITHOUT TRANSACTION)" />
</p>

Neste ponto, a exibição Design no Visual Studio deve ser semelhante à captura de tela mostrada na Figura 7.

Figura 7: a página contém um GridView e três controles Web de botão (clique para exibir a imagem em tamanho real)

Crie manipuladores de eventos para cada um dos três eventos do Click Botão e use o seguinte código:

Protected Sub RefreshGrid_Click _
    (ByVal sender As Object, ByVal e As System.EventArgs) _
    Handles RefreshGrid.Click
    
    Products.DataBind()
End Sub
Protected Sub ModifyCategoriesWithTransaction_Click _
    (ByVal sender As Object, ByVal e As System.EventArgs) _
    Handles ModifyCategoriesWithTransaction.Click
    
    ' Get the set of products
    Dim productsAPI As New ProductsBLL()
    Dim productsData As Northwind.ProductsDataTable = productsAPI.GetProducts()
    ' Update each product's CategoryID
    For Each product As Northwind.ProductsRow In productsData
        product.CategoryID = product.ProductID
    Next
    ' Update the data using a transaction
    productsAPI.UpdateWithTransaction(productsData)
    ' Refresh the Grid
    Products.DataBind()
End Sub
Protected Sub ModifyCategoriesWithoutTransaction_Click _
    (ByVal sender As Object, ByVal e As System.EventArgs) _
    Handles ModifyCategoriesWithoutTransaction.Click
    
    ' Get the set of products
    Dim productsAPI As New ProductsBLL()
    Dim productsData As Northwind.ProductsDataTable = productsAPI.GetProducts()
    ' Update each product's CategoryID
    For Each product As Northwind.ProductsRow In productsData
        product.CategoryID = product.ProductID
    Next
    ' Update the data WITHOUT using a transaction
    Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
    productsAdapter.Update(productsData)
    ' Refresh the Grid
    Products.DataBind()
End Sub

O manipulador de eventos do Botão de Click Atualização simplesmente revincula os dados ao GridView ao chamar o método Products do GridView DataBind.

O segundo manipulador de eventos reatribui os produtos CategoryID e usa o novo método de transação da BLL para executar as atualizações de banco de dados sob o guarda-chuva de uma transação. Observe que cada produto CategoryID é arbitrariamente definido com o mesmo valor de seu ProductID. Isso funcionará bem para os primeiros produtos, já que esses produtos têm valores de ProductID que são mapeados para CategoryID s válidos. Mas uma vez que os ProductID s começam a ficar muito grandes, essa sobreposição coincidente de ProductID s e CategoryID s não se aplica mais.

O terceiro Click manipulador de eventos atualiza os produtos CategoryID da mesma maneira, mas envia a atualização para o banco de dados usando o ProductsTableAdapter método padrão Update . Esse Update método não encapsula a série de comandos dentro de uma transação, portanto, essas alterações são feitas antes do primeiro erro de violação de restrição de chave estrangeira encontrado persistir.

Para demonstrar esse comportamento, visite esta página por meio de um navegador. Inicialmente, você deverá ver a primeira página de dados, conforme mostrado na Figura 8. Em seguida, clique no botão Modificar Categorias (COM TRANSAÇÃO). Isso causará um postback e tentará atualizar todos os valores do produto CategoryID, mas resultará em uma violação de restrição de chave estrangeira (consulte a Figura 9).

Figura 8: Os produtos são exibidos em um Pageable GridView (Clique para exibir a imagem em tamanho real)

Figura 9: Reatribuindo os resultados das categorias em uma violação de restrição de chave estrangeira (clique para exibir a imagem em tamanho real)

Agora, clique no botão Voltar do navegador e, em seguida, clique no botão Atualizar Tabela. Ao atualizar os dados, você deverá ver exatamente a mesma saída mostrada na Figura 8. Ou seja, mesmo que alguns dos produtos CategoryID tenham sido alterados para valores legais e atualizados no banco de dados, eles foram revertidos quando ocorreu a violação da restrição de chave estrangeira.

Agora tente clicar no botão Modificar Categorias (SEM TRANSAÇÃO). Isso resultará no mesmo erro de violação de restrição de chave estrangeira (consulte a Figura 9), mas desta vez os produtos cujos CategoryID valores foram alterados para um valor legal não serão revertidos. Clique no botão Voltar do navegador, depois no botão Atualizar Grade de Dados. Como mostra a Figura 10, os CategoryID s dos oito primeiros produtos foram reatribuídos. Por exemplo, na Figura 8, Chang tinha um CategoryID de 1, mas na Figura 10 ele foi reatribuído para 2.

Figura 10: Alguns valores de produtos CategoryID foram atualizados enquanto outros não foram (clique para exibir imagem em tamanho real)

Resumo

Por padrão, os métodos tableAdapter não encapsulam as instruções de banco de dados executadas no escopo de uma transação, mas com um pouco de trabalho podemos adicionar métodos que criarão, confirmarão e reverterão uma transação. Neste tutorial, criamos três métodos desse tipo na ProductsTableAdapter classe: BeginTransaction, CommitTransactione RollbackTransaction. Vimos como usar esses métodos junto com um Try...Catch bloco para tornar atômica uma série de instruções de modificação de dados. Em específico, criamos o UpdateWithTransaction método no ProductsTableAdapter, que usa o padrão de Atualização em Lote para realizar as modificações necessárias nas linhas de um ProductsDataTable fornecido. Adicionamos também o método DeleteProductsWithTransaction à classe ProductsBLL na BLL, que aceita um List com ProductID valores como entrada e chama o método padrão Delete DB-Direct para cada valor de ProductID. Ambos os métodos começam criando uma transação e executando as instruções de modificação de dados em um Try...Catch bloco. Se ocorrer uma exceção, a transação será revertida, caso contrário, ela será confirmada.

A etapa 5 ilustrou o efeito das atualizações em lotes transacionais em comparação com as atualizações em lotes que ignoraram o uso de uma transação. Nos próximos três tutoriais, criaremos as bases estabelecidas neste tutorial e criaremos interfaces de usuário para executar atualizações em lotes, exclusões e inserções.

Divirta-se programando!

Leitura Adicional

Para obter mais informações sobre os tópicos discutidos neste tutorial, consulte os seguintes recursos:

• Transações Facilitadas: System.Transactions
• TransactionScope e DataAdapters
• Usando transações de banco de dados Oracle no .NET

Sobre o autor

Scott Mitchell, autor de sete livros asp/ASP.NET e fundador da 4GuysFromRolla.com, trabalha com tecnologias da Microsoft Web desde 1998. Scott trabalha como consultor independente, treinador e escritor. Seu último livro é Sams Teach Yourself ASP.NET 2.0 em 24 Horas. Ele pode ser alcançado em mitchell@4GuysFromRolla.com.

Agradecimentos Especiais a

Esta série de tutoriais foi revisada por muitos revisores úteis. Os principais revisores deste tutorial foram Dave Gardner, Hilton Giesenow e Teresa Murphy. Interessado em revisar meus próximos artigos do MSDN? Se assim for, deixe-me uma linha em mitchell@4GuysFromRolla.com.

AnteriorPróximo