Partilhar via

Validar dados em conjuntos de dados em aplicativos .NET Framework

Observação

A DataSet classe e as classes relacionadas são tecnologias herdadas do .NET Framework do início dos anos 2000 que permitem que os aplicativos trabalhem com dados na memória enquanto os aplicativos estão desconectados do banco de dados. As tecnologias são especialmente úteis para aplicativos que permitem aos usuários modificar dados e manter as alterações de volta ao banco de dados. Embora os conjuntos de dados sejam uma tecnologia comprovadamente bem-sucedida, a abordagem recomendada para novos aplicativos .NET é usar o Entity Framework Core. O Entity Framework fornece uma maneira mais natural de trabalhar com dados tabulares como modelos de objeto e tem uma interface de programação mais simples.

A validação de dados é o processo de confirmar que os valores que estão sendo inseridos em objetos de dados estão em conformidade com as restrições dentro do esquema de um conjunto de dados. O processo de validação também confirma que estes valores estão a seguir as regras que foram estabelecidas para a sua aplicação. É uma boa prática validar dados antes de enviar atualizações para o banco de dados subjacente. Isso reduz os erros, bem como o número potencial de viagens de ida e volta entre um aplicativo e o banco de dados.

Você pode confirmar se os dados que estão sendo gravados em um conjunto de dados são válidos criando verificações de validação no próprio conjunto de dados. O conjunto de dados pode verificar os dados, independentemente de como a atualização está sendo executada — seja diretamente por controles em um formulário, dentro de um componente ou de alguma outra forma. Como o conjunto de dados faz parte do seu aplicativo (ao contrário do back-end do banco de dados), é um local lógico para criar a validação específica do aplicativo.

O melhor lugar para adicionar validação ao seu aplicativo é no arquivo de classe parcial do conjunto de dados. No Visual Basic ou Visual C#, abra o Dataset Designer e clique duas vezes na coluna ou tabela para a qual você deseja criar a validação. Essa ação abre o arquivo de código, onde você pode criar um manipulador de ColumnChanging eventos ou RowChanging .

private static void OnColumnChanging(object sender, DataColumnChangeEventArgs e)
{

}

Valide os dados

A validação dentro de um conjunto de dados é realizada das seguintes maneiras:

  • Criando a sua própria validação específica da aplicação que pode verificar valores em uma coluna de dados específica durante as mudanças. Para obter mais informações, consulte Como validar dados durante alterações de coluna.

  • Criando sua própria validação específica do aplicativo que pode verificar dados para valores enquanto uma linha de dados inteira está mudando. Para obter mais informações, consulte Como validar dados durante alterações de linha.

  • Criando chaves, restrições exclusivas e assim por diante como parte da definição de esquema real do conjunto de dados.

  • Definindo as DataColumn propriedades do objeto, como MaxLength, AllowDBNulle Unique.

Vários eventos são gerados pelo DataTable objeto quando uma alteração está ocorrendo em um registro:

  • Os eventos ColumnChanging e ColumnChanged são gerados durante e após cada alteração em uma única coluna. O ColumnChanging evento é útil quando você deseja validar alterações em colunas específicas. As informações sobre a alteração proposta são passadas como um argumento com o evento.
  • Os eventos RowChanging e RowChanged são gerados durante e após qualquer alteração em uma linha. O RowChanging evento é mais geral. Isso indica que uma alteração está ocorrendo em algum lugar na linha, mas você não sabe qual coluna foi alterada.

Por padrão, cada alteração em uma coluna, portanto, gera quatro eventos. O primeiro são os eventos ColumnChanging e ColumnChanged para a coluna específica que está a ser alterada. Seguem-se os eventos RowChanging e RowChanged. Se várias alterações estiverem sendo feitas na linha, os eventos serão gerados para cada alteração.

Observação

O método da linha de dados BeginEdit desativa os eventos RowChanging e RowChanged após cada alteração de coluna individual. Nesse caso, o evento não é gerado até que o EndEdit método tenha sido chamado, quando os RowChanging eventos e RowChanged são gerados apenas uma vez. Para obter mais informações, consulte Desativar restrições ao preencher um conjunto de dados.

O evento escolhido depende de quão granular você deseja que a validação seja. Se for importante detetar um erro imediatamente quando uma coluna for alterada, crie a validação usando o ColumnChanging evento. Caso contrário, use o evento RowChanging, que pode levar à captura de vários erros de uma só vez. Além disso, se os dados estiverem estruturados de modo que o valor de uma coluna seja validado com base no conteúdo de outra coluna, execute a validação durante o RowChanging evento.

Quando os registros são atualizados, o DataTable objeto gera eventos aos quais você pode responder à medida que as alterações estão ocorrendo e depois que as alterações são feitas.

Se seu aplicativo usa um conjunto de dados tipado, você pode criar manipuladores de eventos fortemente tipados. Isso adiciona quatro eventos digitados adicionais para os quais você pode criar manipuladores: dataTableNameRowChanging, dataTableNameRowChanged, dataTableNameRowDeletinge dataTableNameRowDeleted. Esses manipuladores de eventos tipados passam um argumento que inclui os nomes das colunas da tabela que tornam o código mais fácil de escrever e ler.

Eventos de atualização de dados

Evento Descrição
ColumnChanging O valor em uma coluna está sendo alterado. O evento passa a linha e a coluna para você, juntamente com o novo valor proposto.
ColumnChanged O valor em uma coluna foi alterado. O evento passa a linha e a coluna para você, juntamente com o valor proposto.
RowChanging As alterações feitas em um DataRow objeto estão prestes a ser confirmadas de volta no conjunto de dados. Se você não tiver chamado o BeginEdit método, o RowChanging evento será gerado para cada alteração em uma coluna imediatamente após o ColumnChanging evento ter sido gerado. Se BeginEdit foi chamado antes de fazer alterações, o evento RowChanging é gerado somente quando chamar o método EndEdit.

O evento passa a linha para você, juntamente com um valor que indica que tipo de ação (alterar, inserir e assim por diante) está sendo executada.
RowChanged Uma linha foi alterada. O evento passa a linha para você, juntamente com um valor que indica que tipo de ação (alterar, inserir e assim por diante) está sendo executada.
RowDeleting Uma linha está sendo excluída. O evento passa a linha para você, juntamente com um valor que indica que tipo de ação (excluir) está sendo executada.
RowDeleted Uma linha foi excluída. O evento passa a linha para você, juntamente com um valor que indica que tipo de ação (excluir) está sendo executada.

Os eventos ColumnChanging, RowChanging e RowDeleting são gerados durante o processo de atualização. Você pode usar esses eventos para validar dados ou executar outros tipos de processamento. Como a atualização está em processo durante esses eventos, você pode cancelá-la lançando uma exceção, o que impede que a atualização seja concluída.

Os ColumnChanged, RowChanged e RowDeleted são eventos de notificação que são ativados quando a atualização é concluída com êxito. Esses eventos são úteis quando você deseja tomar outras medidas com base em uma atualização bem-sucedida.

Validar dados durante alterações de coluna

Observação

O Dataset Designer cria uma classe parcial na qual a lógica de validação pode ser adicionada a um conjunto de dados. O conjunto de dados gerado pelo designer não exclui nem altera nenhum código na classe parcial.

Você pode validar dados quando o valor em uma coluna de dados é alterado respondendo ao ColumnChanging evento. Quando gerado, esse evento passa um argumento de evento (ProposedValue) que contém o valor que está sendo proposto para a coluna atual. Com base no conteúdo do e.ProposedValue, você pode:

  • Aceite o valor proposto sem fazer nada.

  • Rejeite o valor proposto definindo o erro de coluna (SetColumnError) de dentro do manipulador de eventos de alteração de coluna.

  • Opcionalmente, use um ErrorProvider controle para exibir uma mensagem de erro para o usuário. Para obter mais informações, consulte Componente ErrorProvider.

A validação também pode ser realizada durante o RowChanging evento.

Validar dados durante alterações de linha

Você pode escrever código para verificar se cada coluna que deseja validar contém dados que atendem aos requisitos do seu aplicativo. Faça isso definindo a coluna para indicar que ela contém um erro se um valor proposto for inaceitável. Os exemplos a seguir definem um erro de coluna quando a Quantity coluna é 0 ou menos. Os manipuladores de eventos de mudança de linha devem ser semelhantes aos exemplos a seguir.

Para validar dados quando uma linha é alterada (Visual Basic)

  1. Abra seu conjunto de dados no Dataset Designer. Para obter mais informações, consulte Passo a passo: Criando um conjunto de dados no Dataset Designer.

  2. Clique duas vezes na barra de título da tabela que você deseja validar. Essa ação cria automaticamente, no arquivo de classe parcial do conjunto de dados, o manipulador de eventos RowChanging do DataTable.

    Sugestão

    Clique duas vezes à esquerda do nome da tabela para criar o manipulador de eventos de alteração de linha. Se você clicar duas vezes no nome da tabela, poderá editá-la.

    Private Sub Order_DetailsDataTable_Order_DetailsRowChanging(
    ByVal sender As System.Object, 
    ByVal e As Order_DetailsRowChangeEvent
  ) Handles Me.Order_DetailsRowChanging

    If CType(e.Row.Quantity, Short) <= 0 Then
        e.Row.SetColumnError("Quantity", "Quantity must be greater than 0")
    Else
        e.Row.SetColumnError("Quantity", "")
    End If
End Sub

Para validar dados quando uma linha é alterada (C#)

  1. Abra seu conjunto de dados no Dataset Designer. Para obter mais informações, consulte Passo a passo: Criando um conjunto de dados no Dataset Designer.

  2. Clique duas vezes na barra de título da tabela que você deseja validar. Esta ação cria um arquivo de classe parcial para o DataTable.

    Observação

    O Dataset Designer não cria automaticamente um manipulador de eventos para o RowChanging evento. Você precisa criar um método para manipular o RowChanging evento e executar código para conectar o evento no método de inicialização da tabela.

  3. Copie o seguinte código para a classe parcial:

    public override void EndInit()
{
    base.EndInit();
    Order_DetailsRowChanging += TestRowChangeEvent;
}

public void TestRowChangeEvent(object sender, Order_DetailsRowChangeEvent e)
{
    if ((short)e.Row.Quantity <= 0)
    {
        e.Row.SetColumnError("Quantity", "Quantity must be greater than 0");
    }
    else
    {
        e.Row.SetColumnError("Quantity", "");
    }
}

Para recuperar linhas alteradas

Cada linha em uma tabela de dados tem uma RowState propriedade que controla o estado atual dessa linha usando os valores na DataRowState enumeração. Você pode retornar linhas alteradas de um conjunto de dados ou tabela de dados chamando o GetChanges método de um DataSet ou DataTable. Você pode verificar se existem alterações antes de chamar GetChanges chamando o HasChanges método de um conjunto de dados.

Observação

Depois de confirmar alterações em um conjunto de dados ou tabela de dados (chamando o AcceptChanges método), o GetChanges método não retorna dados. Se seu aplicativo precisar processar linhas alteradas, você deverá processar as alterações antes de chamar o AcceptChanges método.

Chamar o GetChanges método de um conjunto de dados ou tabela de dados retorna um novo conjunto de dados ou tabela de dados que contém apenas registros que foram alterados. Se você quiser obter registros específicos — por exemplo, apenas registros novos ou somente registros modificados — você pode passar um valor da DataRowState enumeração como um parâmetro para o GetChanges método.

Use a DataRowVersion enumeração para acessar as diferentes versões de uma linha (por exemplo, os valores originais que estavam em uma linha antes de processá-la).

Para obter todos os registros alterados de um conjunto de dados

  • Invoque o método GetChanges de um conjunto de dados.

    O exemplo a seguir cria um novo conjunto de dados chamado changedRecords e o preenche com todos os registros alterados de outro conjunto de dados chamado dataSet1.

    DataSet changedRecords = dataSet1.GetChanges();

Para obter todos os registros alterados de uma tabela de dados

  • Chame o método GetChanges de um DataTable.

    O exemplo a seguir cria uma nova tabela de dados chamada changedRecordsTable e a preenche com todos os registros alterados de outra tabela de dados chamada dataTable1.

    DataTable changedRecordsTable = dataTable1.GetChanges();

Para obter todos os registros que têm um estado de linha específico

  • Chame o GetChanges método de um conjunto de dados ou tabela de dados e passe um DataRowState valor de enumeração como um argumento.

    O exemplo a seguir mostra como criar um novo conjunto de dados chamado addedRecords e preenchê-lo somente com registros que foram adicionados ao dataSet1 conjunto de dados.

    DataSet addedRecords = dataSet1.GetChanges(DataRowState.Added);

    O exemplo a seguir mostra como retornar todos os registros que foram adicionados recentemente à Customers tabela:

    private NorthwindDataSet.CustomersDataTable GetNewRecords()
{
    return (NorthwindDataSet.CustomersDataTable)
        northwindDataSet1.Customers.GetChanges(DataRowState.Added);
}

Acessar a versão original de um DataRow

Quando são feitas alterações nas linhas de dados, o conjunto de dados mantém as versões original (Original) e nova (Current) da linha. Por exemplo, antes de chamar o AcceptChanges método, seu aplicativo pode acessar as diferentes versões de um registro (conforme definido na DataRowVersion enumeração) e processar as alterações de acordo.

Observação

Diferentes versões de uma linha existem somente depois que ela foi editada e antes dela o AcceptChanges método foi chamado. Após o AcceptChanges método ter sido chamado, as versões atual e original são as mesmas.

Passar o DataRowVersion valor junto com o índice da coluna (ou o nome da coluna como uma cadeia de caracteres) retorna o valor da versão de linha específica dessa coluna. A coluna alterada é identificada durante os eventos ColumnChanging e ColumnChanged. Este é um bom momento para verificar as diferentes versões de linha para efeitos de validação. No entanto, se você tiver restrições suspensas temporariamente, esses eventos não serão gerados e você precisará identificar programaticamente quais colunas foram alteradas. Você pode fazer isso iterando através da Columns coleção e comparando os diferentes DataRowVersion valores.

Para obter a versão original de um registo

  • Acede ao valor de uma coluna inserindo o DataRowVersion da linha que pretendes retornar.

    O exemplo a seguir mostra como usar um DataRowVersion valor para obter o valor original de um CompanyName campo em um DataRow:

    string originalCompanyName;
originalCompanyName = northwindDataSet1.Customers[0]
    ["CompanyName", DataRowVersion.Original].ToString();

Acessar a versão atual de um DataRow

Para obter a versão atual de um registro

  • Acesse o valor de uma coluna e adicione um parâmetro ao índice que indica qual versão de uma linha você deseja retornar.

    O exemplo a seguir mostra como usar um DataRowVersion valor para obter o valor atual de um CompanyName campo em um DataRow:

    string currentCompanyName;
currentCompanyName = northwindDataSet1.Customers[0]
    ["CompanyName", DataRowVersion.Current].ToString();

Conteúdo relacionado

  • Last updated on