Manipulando eventos DataTable

O DataTable objeto fornece uma série de eventos que podem ser processados por um aplicativo. A tabela a seguir descreve DataTable os eventos.

Evento	Descrição
Initialized	Ocorre depois que o EndInit método de a DataTable é chamado. Este evento destina-se principalmente a suportar cenários de tempo de design.
ColumnChanged	Ocorre depois que um valor foi alterado com êxito em um DataColumnarquivo .
ColumnChanging	Ocorre quando um valor foi enviado para um DataColumnarquivo .
RowChanged	Ocorre depois que um DataColumn valor ou o RowState de um DataRow no DataTable foi alterado com êxito.
RowChanging	Ocorre quando uma alteração foi enviada para um DataColumn valor ou o RowState de a DataRow no DataTable.
RowDeleted	Ocorre depois de DataTable a DataRow no ter sido marcado como Deleted.
RowDeleting	Ocorre antes de DataTable a DataRow no é marcado como Deleted.
TableCleared	Ocorre depois que uma chamada para o Clear método do DataTable foi limpo com êxito cada DataRowarquivo .
TableClearing	Ocorre depois que o método é chamado, Clear mas antes que a Clear operação comece.
TableNewRow	Ocorre depois que um novo DataRow é criado por uma chamada para o NewRow método do DataTable.
Disposed	Ocorre quando o DataTable é Disposed. Herdado de MarshalByValueComponent.

Nota

A maioria das operações que adicionam ou excluem linhas não geram os ColumnChanged eventos e ColumnChanging . No entanto, o ReadXml método não gera ColumnChanged eventos e ColumnChanging , a menos que o XmlReadMode é definido como DiffGram ou está definido como Auto quando o documento XML que está sendo lido é um DiffGramarquivo .

Aviso

A corrupção de dados pode ocorrer se os dados forem modificados em um DataSet a partir do qual o RowChanged evento é gerado. Nenhuma exceção será levantada se tal corrupção de dados ocorrer.

Eventos Relacionados Adicionais

A Constraints propriedade possui uma ConstraintCollection instância. A ConstraintCollection aula expõe um CollectionChanged evento. Esse evento é acionado quando uma restrição é adicionada, modificada ou removida do ConstraintCollection.

A Columns propriedade possui uma DataColumnCollection instância. A DataColumnCollection aula expõe um CollectionChanged evento. Esse evento é acionado quando um DataColumn é adicionado, modificado ou removido do DataColumnCollection. As modificações que fazem com que o evento seja acionado incluem alterações no nome, tipo, expressão ou posição ordinal de uma coluna.

A Tables propriedade de um DataSet detém uma DataTableCollection instância. A DataTableCollection aula expõe um CollectionChanged e um CollectionChanging evento. Esses eventos são acionados quando um DataTable é adicionado ou removido do DataSet.

Alterações em DataRows também podem disparar eventos para um .DataView A DataView classe expõe um ListChanged evento que é acionado quando um DataColumn valor é alterado ou quando a composição ou a ordem de classificação do modo de exibição muda. A DataRowView classe expõe um PropertyChanged evento que é acionado quando um valor associado DataColumn é alterado.

Sequência de operações

Aqui está a sequência de operações que ocorrem quando um DataRow é adicionado, modificado ou excluído:

1. Crie o registro proposto e aplique as alterações.

2. Verifique as restrições para colunas que não sejam de expressão.

3. Levante os RowChanging eventos ou RowDeleting conforme aplicável.

4. Defina o registro proposto como o registro atual.

5. Atualize todos os índices associados.

6. Gerar ListChanged eventos para objetos associados DataView e PropertyChanged eventos para objetos associados DataRowView .

7. Avalie todas as colunas de expressão, mas atrase a verificação de quaisquer restrições nessas colunas.

8. Levante ListChanged eventos para objetos associados DataView e PropertyChanged eventos para objetos associados DataRowView afetados pelas avaliações da coluna de expressão.

9. Aumento RowChanged ou RowDeleted eventos, conforme aplicável.

10. Verifique as restrições nas colunas de expressão.

Nota

As alterações nas colunas de expressão nunca geram DataTable eventos. As alterações nas colunas de expressão apenas geram DataView e DataRowView eventos. As colunas de expressão podem ter dependências em várias outras colunas e podem ser avaliadas várias vezes durante uma única DataRow operação. Cada avaliação de expressão gera eventos, e uma única DataRow operação pode gerar vários ListChanged eventos quando PropertyChanged as colunas de expressão são afetadas, possivelmente incluindo vários eventos para a mesma coluna de expressão.

Aviso

Não lance um NullReferenceException dentro do manipulador de RowChanged eventos. Se um NullReferenceException é lançado dentro do RowChanged evento de um DataTable, então o testamento DataTable será corrompido.

Exemplo

O exemplo a seguir demonstra como criar manipuladores de eventos para os RowChangedeventos , RowChanging, RowDeleted, RowDeleting, ColumnChanged, ColumnChangingTableNewRow, TableCleared, e , ,TableClearing Cada manipulador de eventos exibe a saída na janela do console quando é acionado.

static void DataTableEvents()
{
    DataTable table = new("Customers");
    // Add two columns, id and name.
    table.Columns.Add("id", typeof(int));
    table.Columns.Add("name", typeof(string));

    // Set the primary key.
    table.Columns["id"].Unique = true;
    table.PrimaryKey = new DataColumn[] { table.Columns["id"] };

    // Add a RowChanged event handler.
    table.RowChanged += Row_Changed;

    // Add a RowChanging event handler.
    table.RowChanging += Row_Changing;

    // Add a RowDeleted event handler.
    table.RowDeleted += Row_Deleted;

    // Add a RowDeleting event handler.
    table.RowDeleting += Row_Deleting;

    // Add a ColumnChanged event handler.
    table.ColumnChanged +=
        Column_Changed;

    // Add a ColumnChanging event handler.
    table.ColumnChanging +=
        Column_Changing;

    // Add a TableNewRow event handler.
    table.TableNewRow +=
        Table_NewRow;

    // Add a TableCleared event handler.
    table.TableCleared +=
        Table_Cleared;

    // Add a TableClearing event handler.
    table.TableClearing +=
        Table_Clearing;

    // Add a customer.
    DataRow row = table.NewRow();
    row["id"] = 1;
    row["name"] = "Customer1";
    table.Rows.Add(row);

    table.AcceptChanges();

    // Change the customer name.
    table.Rows[0]["name"] = "ChangedCustomer1";

    // Delete the row.
    table.Rows[0].Delete();

    // Clear the table.
    table.Clear();
}

static void Row_Changed(object sender, DataRowChangeEventArgs e) =>
    Console.WriteLine("Row_Changed Event: name={0}; action={1}",
        e.Row["name"], e.Action);

static void Row_Changing(object sender, DataRowChangeEventArgs e) =>
    Console.WriteLine("Row_Changing Event: name={0}; action={1}",
        e.Row["name"], e.Action);

static void Row_Deleted(object sender, DataRowChangeEventArgs e) =>
    Console.WriteLine("Row_Deleted Event: name={0}; action={1}",
        e.Row["name", DataRowVersion.Original], e.Action);

static void Row_Deleting(object sender,
DataRowChangeEventArgs e) =>
    Console.WriteLine("Row_Deleting Event: name={0}; action={1}",
        e.Row["name"], e.Action);

static void Column_Changed(object sender, DataColumnChangeEventArgs e) =>
    Console.WriteLine("Column_Changed Event: ColumnName={0}; RowState={1}",
        e.Column.ColumnName, e.Row.RowState);

static void Column_Changing(object sender, DataColumnChangeEventArgs e) =>
    Console.WriteLine("Column_Changing Event: ColumnName={0}; RowState={1}",
        e.Column.ColumnName, e.Row.RowState);

static void Table_NewRow(object sender,
    DataTableNewRowEventArgs e) =>
    Console.WriteLine("Table_NewRow Event: RowState={0}",
        e.Row.RowState.ToString());

static void Table_Cleared(object sender, DataTableClearEventArgs e) =>
    Console.WriteLine("Table_Cleared Event: TableName={0}; Rows={1}",
        e.TableName, e.Table.Rows.Count.ToString());

static void Table_Clearing(object sender, DataTableClearEventArgs e) =>
    Console.WriteLine("Table_Clearing Event: TableName={0}; Rows={1}",
        e.TableName, e.Table.Rows.Count.ToString());

Private Sub DataTableEvents()

    Dim table As New DataTable("Customers")
    ' Add two columns, id and name.
    table.Columns.Add("id", Type.GetType("System.Int32"))
    table.Columns.Add("name", Type.GetType("System.String"))

    ' Set the primary key.
    table.Columns("id").Unique = True
    table.PrimaryKey = New DataColumn() {table.Columns("id")}

    ' Add a RowChanged event handler.
    AddHandler table.RowChanged, _
           New DataRowChangeEventHandler(AddressOf Row_Changed)

    ' Add a RowChanging event handler.
    AddHandler table.RowChanging, _
           New DataRowChangeEventHandler(AddressOf Row_Changing)

    ' Add a RowDeleted event handler.
    AddHandler table.RowDeleted, New _
           DataRowChangeEventHandler(AddressOf Row_Deleted)

    ' Add a RowDeleting event handler.
    AddHandler table.RowDeleting, New _
           DataRowChangeEventHandler(AddressOf Row_Deleting)

    ' Add a ColumnChanged event handler.
    AddHandler table.ColumnChanged, _
           New DataColumnChangeEventHandler(AddressOf Column_Changed)

    ' Add a ColumnChanging event handler for the table.
    AddHandler table.ColumnChanging, New _
           DataColumnChangeEventHandler(AddressOf Column_Changing)

    ' Add a TableNewRow event handler.
    AddHandler table.TableNewRow, New _
           DataTableNewRowEventHandler(AddressOf Table_NewRow)

    ' Add a TableCleared event handler.
    AddHandler table.TableCleared, New _
           DataTableClearEventHandler(AddressOf Table_Cleared)

    ' Add a TableClearing event handler.
    AddHandler table.TableClearing, New _
           DataTableClearEventHandler(AddressOf Table_Clearing)

    ' Add a customer.
    Dim row As DataRow = table.NewRow()
    row("id") = 1
    row("name") = "Customer1"
    table.Rows.Add(row)

    table.AcceptChanges()

    ' Change the customer name.
    table.Rows(0).Item("name") = "ChangedCustomer1"

    ' Delete the row.
    table.Rows(0).Delete()

    ' Clear the table.
    table.Clear()
End Sub


Private Sub Row_Changed(ByVal sender As Object, _
    ByVal e As DataRowChangeEventArgs)
    Console.WriteLine("Row_Changed Event: name={0}; action={1}", _
     e.Row("name"), e.Action)
End Sub

Private Sub Row_Changing(ByVal sender As Object, _
    ByVal e As DataRowChangeEventArgs)
    Console.WriteLine("Row_Changing Event: name={0}; action={1}", _
     e.Row("name"), e.Action)
End Sub

Private Sub Row_Deleted(ByVal sender As Object, _
    ByVal e As DataRowChangeEventArgs)
    Console.WriteLine("Row_Deleted Event: name={0}; action={1}", _
     e.Row("name", DataRowVersion.Original), e.Action)
End Sub

Private Sub Row_Deleting(ByVal sender As Object, _
    ByVal e As DataRowChangeEventArgs)
    Console.WriteLine("Row_Deleting Event: name={0}; action={1}", _
       e.Row("name"), e.Action)
End Sub

Private Sub Column_Changed(ByVal sender As Object, _
    ByVal e As DataColumnChangeEventArgs)
    Console.WriteLine("Column_Changed Event: ColumnName={0}; RowState={1}", _
       e.Column.ColumnName, e.Row.RowState)
End Sub

Private Sub Column_Changing(ByVal sender As Object, _
    ByVal e As DataColumnChangeEventArgs)
    Console.WriteLine("Column_Changing Event: ColumnName={0}; RowState={1}", _
       e.Column.ColumnName, e.Row.RowState)
End Sub

Private Sub Table_NewRow(ByVal sender As Object, _
ByVal e As DataTableNewRowEventArgs)
    Console.WriteLine("Table_NewRow Event: RowState={0}", _
       e.Row.RowState.ToString())
End Sub

Private Sub Table_Cleared(ByVal sender As Object, _
    ByVal e As DataTableClearEventArgs)
    Console.WriteLine("Table_Cleared Event: TableName={0}; Rows={1}", _
       e.TableName, e.Table.Rows.Count.ToString())
End Sub

Private Sub Table_Clearing(ByVal sender As Object, _
    ByVal e As DataTableClearEventArgs)
    Console.WriteLine("Table_Clearing Event: TableName={0}; Rows={1}", _
       e.TableName, e.Table.Rows.Count.ToString())
End Sub

Consulte também

• Manipulando dados em uma DataTable
• Manipulando eventos DataAdapter
• Manipulando eventos de conjunto de dados
• Visão geral ADO.NET