Partilhar via

Tratar de exceções de nível BLL e DAL (C#)

  • Artigo

por Scott Mitchell

Baixar PDF

Neste tutorial, veremos como lidar com tato com exceções geradas durante o fluxo de trabalho de atualização de um DataList editável.

Introdução

No tutorial Visão geral de edição e exclusão de dados no DataList , criamos uma DataList que oferecia recursos simples de edição e exclusão. Embora totalmente funcional, não foi fácil de usar, pois qualquer erro ocorrido durante o processo de edição ou exclusão resultou em uma exceção sem tratamento. Por exemplo, omitir o nome do produto ou, ao editar um produto, inserir um valor de preço muito acessível!, gera uma exceção. Como essa exceção não é capturada no código, ela se propaga até o runtime do ASP.NET, que exibe os detalhes da exceção na página da Web.

Como vimos no tutorial Manipulando exceções de BLL e DAL-Level em uma página ASP.NET , se uma exceção for gerada a partir das profundidades da Lógica de Negócios ou das Camadas de Acesso a Dados, os detalhes da exceção serão retornados para ObjectDataSource e, em seguida, para o GridView. Vimos como lidar normalmente com essas exceções criando Updated manipuladores de eventos ou RowUpdated para ObjectDataSource ou GridView, verificando se há uma exceção e indicando que a exceção foi tratada.

Nossos tutoriais de DataList, no entanto, não estão usando o ObjectDataSource para atualizar e excluir dados. Em vez disso, estamos trabalhando diretamente na BLL. Para detectar exceções originadas da BLL ou da DAL, precisamos implementar o código de tratamento de exceções dentro do code-behind de nossa página ASP.NET. Neste tutorial, veremos como lidar com mais tato com exceções geradas durante um fluxo de trabalho de atualização de DataList editável.

Observação

No tutorial Uma visão geral de edição e exclusão de dados no tutorial DataList discutimos técnicas diferentes para editar e excluir dados da DataList, algumas técnicas envolvidas usando um ObjectDataSource para atualização e exclusão. Se você empregar essas técnicas, poderá lidar com exceções da BLL ou da DAL por meio dos manipuladores de eventos ou UpdatedDeleted ObjectDataSource.

Etapa 1: Criando uma Lista de Dados Editável

Antes de nos preocuparmos em lidar com exceções que ocorrem durante o fluxo de trabalho de atualização, vamos primeiro criar um DataList editável. Abra a ErrorHandling.aspx página na EditDeleteDataList pasta , adicione um DataList à Designer, defina sua ID propriedade como Productse adicione um novo ObjectDataSource chamado ProductsDataSource. Configure o ObjectDataSource para usar o ProductsBLL método da classe s GetProducts() para selecionar registros; defina as listas suspensas nas guias INSERT, UPDATE e DELETE como (Nenhum).

Retornar as informações do produto usando o método GetProducts()

Figura 1: Retornar as informações do produto usando o GetProducts() método (clique para exibir a imagem em tamanho real)

Depois de concluir o assistente ObjectDataSource, o Visual Studio criará automaticamente um ItemTemplate para o DataList. Substitua isso por um ItemTemplate que exibe o nome e o preço de cada produto e inclui um botão Editar. Em seguida, crie um EditItemTemplate com um controle Web TextBox para nome e preço e botões Atualizar e Cancelar. Por fim, defina a propriedade DataList como RepeatColumns 2.

Após essas alterações, a marcação declarativa da página deverá ser semelhante à seguinte. Marcar duas vezes para garantir que os botões Editar, Cancelar e Atualizar tenham suas CommandName propriedades definidas como Editar, Cancelar e Atualizar, respectivamente.

<asp:DataList ID="Products" runat="server" DataKeyField="ProductID"
    DataSourceID="ProductsDataSource" RepeatColumns="2">
    <ItemTemplate>
        <h5>
            <asp:Label runat="server" ID="ProductNameLabel"
                Text='<%# Eval("ProductName") %>' />
        </h5>
        Price:
            <asp:Label runat="server" ID="Label1"
                Text='<%# Eval("UnitPrice", "{0:C}") %>' />
        <br />
            <asp:Button runat="server" id="EditProduct" CommandName="Edit"
                Text="Edit" />
        <br />
        <br />
    </ItemTemplate>
    <EditItemTemplate>
        Product name:
            <asp:TextBox ID="ProductName" runat="server"
                Text='<%# Eval("ProductName") %>' />
        <br />
        Price:
            <asp:TextBox ID="UnitPrice" runat="server"
                Text='<%# Eval("UnitPrice", "{0:C}") %>' />
        <br />
        <br />
            <asp:Button ID="UpdateProduct" runat="server" CommandName="Update"
                Text="Update" /> 
            <asp:Button ID="CancelUpdate" runat="server" CommandName="Cancel"
                Text="Cancel" />
    </EditItemTemplate>
</asp:DataList>
<asp:ObjectDataSource ID="ProductsDataSource" runat="server"
    SelectMethod="GetProducts" TypeName="ProductsBLL"
    OldValuesParameterFormatString="original_{0}">
</asp:ObjectDataSource>

Observação

Para este tutorial, o estado de exibição de DataList deve estar habilitado.

Reserve um momento para ver nosso progresso por meio de um navegador (consulte a Figura 2).

Cada produto inclui um botão Editar

Figura 2: cada produto inclui um botão Editar (clique para exibir a imagem em tamanho real)

Atualmente, o botão Editar só causa um postback que ainda não torna o produto editável. Para habilitar a edição, precisamos criar manipuladores de eventos para os eventos , CancelCommande UpdateCommand do EditCommandDataList. Os EditCommand eventos e CancelCommand simplesmente atualizam a propriedade DataList e EditItemIndex reassociam os dados à DataList:

protected void Products_EditCommand(object source, DataListCommandEventArgs e)
{
    // Set the DataList's EditItemIndex property to the
    // index of the DataListItem that was clicked
    Products.EditItemIndex = e.Item.ItemIndex;
    // Rebind the data to the DataList
    Products.DataBind();
}
protected void Products_CancelCommand(object source, DataListCommandEventArgs e)
{
    // Set the DataList's EditItemIndex property to -1
    Products.EditItemIndex = -1;
    // Rebind the data to the DataList
    Products.DataBind();
}

O UpdateCommand manipulador de eventos está um pouco mais envolvido. Ele precisa ler os produtos editados da ProductIDDataKeys coleção juntamente com o nome do produto e o preço das TextBoxes no e, em EditItemTemplateseguida, chamar o ProductsBLL método da classe s UpdateProduct antes de retornar o DataList para seu estado de pré-edição.

Por enquanto, vamos usar exatamente o mesmo código do manipulador de UpdateCommand eventos na Visão geral de edição e exclusão de dados no tutorial DataList . Adicionaremos o código para lidar normalmente com exceções na etapa 2.

protected void Products_UpdateCommand(object source, DataListCommandEventArgs e)
{
    // Read in the ProductID from the DataKeys collection
    int productID = Convert.ToInt32(Products.DataKeys[e.Item.ItemIndex]);
    // Read in the product name and price values
    TextBox productName = (TextBox)e.Item.FindControl("ProductName");
    TextBox unitPrice = (TextBox)e.Item.FindControl("UnitPrice");
    string productNameValue = null;
    if (productName.Text.Trim().Length > 0)
        productNameValue = productName.Text.Trim();
    decimal? unitPriceValue = null;
    if (unitPrice.Text.Trim().Length > 0)
        unitPriceValue = Decimal.Parse(unitPrice.Text.Trim(),
            System.Globalization.NumberStyles.Currency);
    // Call the ProductsBLL's UpdateProduct method...
    ProductsBLL productsAPI = new ProductsBLL();
    productsAPI.UpdateProduct(productNameValue, unitPriceValue, productID);
    // Revert the DataList back to its pre-editing state
    Products.EditItemIndex = -1;
    Products.DataBind();
}

Diante da entrada inválida que pode estar na forma de um preço unitário formatado incorretamente, um valor de preço unitário inválido, como -$5,00, ou a omissão do nome do produto, uma exceção será gerada. Como o UpdateCommand manipulador de eventos não inclui nenhum código de tratamento de exceção neste ponto, a exceção surgirá até o runtime do ASP.NET, em que ele será exibido para o usuário final (consulte a Figura 3).

Quando ocorre uma exceção sem tratamento, o usuário final vê uma página de erro

Figura 3: quando ocorre uma exceção sem tratamento, o usuário final vê uma página de erro

Etapa 2: manipulando normalmente exceções no manipulador de eventos UpdateCommand

Durante o fluxo de trabalho de atualização, podem ocorrer exceções no UpdateCommand manipulador de eventos, na BLL ou no DAL. Por exemplo, se um usuário inserir um preço muito caro, a Decimal.Parse instrução no UpdateCommand manipulador de eventos gerará uma FormatException exceção. Se o usuário omitir o nome do produto ou se o preço tiver um valor negativo, o DAL gerará uma exceção.

Quando ocorre uma exceção, queremos exibir uma mensagem informativa dentro da própria página. Adicione um controle Da Web rótulo à página cujo ID está definido como ExceptionDetails. Configure o texto rótulo s para exibir em uma fonte vermelha, extra-grande, negrito e itálico atribuindo sua CssClass propriedade à Warning classe CSS, que é definida no Styles.css arquivo.

Quando ocorre um erro, queremos que o Rótulo seja exibido apenas uma vez. Ou seja, em postbacks subsequentes, a mensagem de aviso Rótulo deve desaparecer. Isso pode ser feito desmarcando a propriedade Label s Text ou definindo sua Visible propriedade como False no Page_Load manipulador de eventos (como fizemos novamente no tutorial Manipulando exceções de BLL e DAL-Level em uma página de ASP.NET ) ou desabilitando o suporte ao estado de exibição rótulo s. Vamos usar a última opção.

<asp:Label ID="ExceptionDetails" EnableViewState="False" CssClass="Warning"
    runat="server" />

Quando uma exceção for gerada, atribuiremos os detalhes da exceção à ExceptionDetails propriedade do Text controle Label. Como seu estado de exibição está desabilitado, em postbacks subsequentes, as Text alterações programáticas da propriedade serão perdidas, revertendo para o texto padrão (uma cadeia de caracteres vazia), ocultando assim a mensagem de aviso.

Para determinar quando um erro foi gerado para exibir uma mensagem útil na página, precisamos adicionar um Try ... Catch bloco ao UpdateCommand manipulador de eventos. A Try parte contém código que pode levar a uma exceção, enquanto o Catch bloco contém o código executado diante de uma exceção. Confira a seção Conceitos básicos de tratamento de exceções na documentação do .NET Framework para obter mais informações sobre o Try ... Catch bloco.

protected void Products_UpdateCommand(object source, DataListCommandEventArgs e)
{
    // Handle any exceptions raised during the editing process
    try
    {
        // Read in the ProductID from the DataKeys collection
        int productID = Convert.ToInt32(Products.DataKeys[e.Item.ItemIndex]);
        ... Some code omitted for brevity ...
    }
    catch (Exception ex)
    {
        // TODO: Display information about the exception in ExceptionDetails
    }
}

Quando uma exceção de qualquer tipo é gerada pelo código dentro do Try bloco, o código s do Catch bloco começará a ser executado. O tipo de exceção que é gerada DbException, NoNullAllowedException, ArgumentExceptione assim por diante depende do que, exatamente, precipitou o erro em primeiro lugar. Se houver um problema no nível do banco de dados, um DbException será gerado. Se um valor inválido for inserido para os UnitPricecampos , UnitsInStockUnitsOnOrder, ou ReorderLevel , um ArgumentException será gerado, pois adicionamos código para validar esses valores de campo na ProductsDataTable classe (consulte o tutorial Criando uma camada de lógica de negócios).

Podemos fornecer uma explicação mais útil para o usuário final baseando o texto da mensagem no tipo de exceção capturada. O código a seguir, que foi usado em uma forma quase idêntica, no tutorial Manipulando exceções de BLL e DAL-Level em uma página ASP.NET fornece este nível de detalhes:

private void DisplayExceptionDetails(Exception ex)
{
    // Display a user-friendly message
    ExceptionDetails.Text = "There was a problem updating the product. ";
    if (ex is System.Data.Common.DbException)
        ExceptionDetails.Text += "Our database is currently experiencing problems.
            Please try again later.";
    else if (ex is NoNullAllowedException)
        ExceptionDetails.Text += "There are one or more required fields that are
            missing.";
    else if (ex is ArgumentException)
    {
        string paramName = ((ArgumentException)ex).ParamName;
        ExceptionDetails.Text +=
            string.Concat("The ", paramName, " value is illegal.");
    }
    else if (ex is ApplicationException)
        ExceptionDetails.Text += ex.Message;
}

Para concluir este tutorial, basta chamar o DisplayExceptionDetails método do Catch bloco que passa na instância capturada Exception (ex).

Com o Try ... Catch bloco em vigor, os usuários recebem uma mensagem de erro mais informativa, como mostram os Números 4 e 5. Observe que, diante de uma exceção, a DataList permanece no modo de edição. Isso ocorre porque, depois que a exceção ocorre, o fluxo de controle é redirecionado imediatamente para o Catch bloco, ignorando o código que retorna DataList para seu estado de pré-edição.

Uma mensagem de erro será exibida se um usuário omitir um campo obrigatório

Figura 4: uma mensagem de erro será exibida se um usuário omitir um campo obrigatório (clique para exibir a imagem em tamanho real)

Uma mensagem de erro é exibida ao inserir um preço negativo

Figura 5: Uma mensagem de erro é exibida ao inserir um preço negativo (clique para exibir a imagem em tamanho real)

Resumo

GridView e ObjectDataSource fornecem manipuladores de eventos de pós-nível que incluem informações sobre quaisquer exceções que foram geradas durante o fluxo de trabalho de atualização e exclusão, bem como propriedades que podem ser definidas para indicar se a exceção foi tratada ou não. No entanto, esses recursos não estão disponíveis ao trabalhar com o DataList e usar a BLL diretamente. Em vez disso, somos responsáveis por implementar o tratamento de exceções.

Neste tutorial, vimos como adicionar o tratamento de exceções a um fluxo de trabalho de atualização de DataList editável adicionando um Try ... Catch bloco ao UpdateCommand manipulador de eventos. Se uma exceção for gerada durante o fluxo de trabalho de atualização, o Catch código do bloco será executado, exibindo informações úteis no ExceptionDetails Rótulo.

Neste ponto, o DataList não faz nenhum esforço para impedir que exceções ocorram em primeiro lugar. Embora saibamos que um preço negativo resultará em uma exceção, ainda não adicionamos nenhuma funcionalidade para impedir proativamente que um usuário insira essa entrada inválida. Em nosso próximo tutorial, veremos como ajudar a reduzir as exceções causadas pela entrada de usuário inválida adicionando controles de validação no EditItemTemplate.

Programação feliz!

Leitura Adicional

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

Sobre o autor

Scott Mitchell, autor de sete livros do 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 contatado em mitchell@4GuysFromRolla.com. ou através de seu blog, que pode ser encontrado em http://ScottOnWriting.NET.

Agradecimentos Especiais

Esta série de tutoriais foi revisada por muitos revisores úteis. O revisor principal deste tutorial foi Ken Pespisa. Interessado em revisar meus próximos artigos do MSDN? Nesse caso, solte-me uma linha em mitchell@4GuysFromRolla.com.

AnteriorAvançar