Gegevenstabel-gebeurtenissen verwerken

Het DataTable object biedt een reeks gebeurtenissen die door een toepassing kunnen worden verwerkt. In de volgende tabel worden gebeurtenissen beschreven DataTable .

Gebeurtenis	Beschrijving
Initialized	Vindt plaats nadat de EndInit methode van een DataTable aangeroepen methode is aangeroepen. Deze gebeurtenis is voornamelijk bedoeld ter ondersteuning van ontwerpscenario's.
ColumnChanged	Vindt plaats nadat een waarde is gewijzigd in een DataColumn.
ColumnChanging	Treedt op wanneer een waarde is verzonden voor een DataColumn.
RowChanged	Vindt plaats nadat een DataColumn waarde of de RowState waarde van een DataRow in de waarde DataTable is gewijzigd.
RowChanging	Treedt op wanneer een wijziging is ingediend voor een DataColumn waarde of de RowState waarde van een DataRow in de DataTable.
RowDeleted	Treedt op nadat een DataRow in de DataTable markering is gemarkeerd als Deleted.
RowDeleting	Vindt plaats voordat een DataRow in de DataTable markering is gemarkeerd als Deleted.
TableCleared	Treedt op nadat een aanroep van de Clear methode van de heeft DataTable alle DataRow.
TableClearing	Vindt plaats nadat de Clear methode is aangeroepen, maar voordat de Clear bewerking begint.
TableNewRow	Treedt op nadat een nieuwe DataRow is gemaakt door een aanroep naar de NewRow methode van de DataTable.
Disposed	Treedt op wanneer het DataTable is Disposed. Overgenomen van MarshalByValueComponent.

Notitie

Bij de meeste bewerkingen waarmee rijen worden toegevoegd of verwijderd, worden de ColumnChanged en ColumnChanging gebeurtenissen niet gegenereerd. De ReadXml methode genereert ColumnChanged echter wel gebeurtenissen ColumnChanging , tenzij de XmlReadMode methode is ingesteld op of is ingesteld DiffGram op Auto wanneer het XML-document dat wordt gelezen een DiffGram.

Waarschuwing

Gegevensbeschadiging kan optreden als gegevens worden gewijzigd in een DataSet gebeurtenis van waaruit de RowChanged gebeurtenis wordt gegenereerd. Er wordt geen uitzondering gegenereerd als dergelijke gegevensbeschadiging optreedt.

Aanvullende gerelateerde gebeurtenissen

De Constraints eigenschap bevat een ConstraintCollection exemplaar. In de ConstraintCollection klasse wordt een CollectionChanged gebeurtenis weergegeven. Deze gebeurtenis wordt geactiveerd wanneer een beperking wordt toegevoegd, gewijzigd of verwijderd uit de ConstraintCollection.

De Columns eigenschap bevat een DataColumnCollection exemplaar. In de DataColumnCollection klasse wordt een CollectionChanged gebeurtenis weergegeven. Deze gebeurtenis wordt geactiveerd wanneer een DataColumn wordt toegevoegd, gewijzigd of verwijderd uit de DataColumnCollection. Wijzigingen die ervoor zorgen dat de gebeurtenis wordt geactiveerd, bevatten wijzigingen in de naam, het type, de expressie of de rangschikking van een kolom.

De Tables eigenschap van een DataSet instantie.DataTableCollection De DataTableCollection klasse toont zowel een als CollectionChanged een CollectionChanging gebeurtenis. Deze gebeurtenissen worden geactiveerd wanneer een DataTable wordt toegevoegd aan of verwijderd uit de DataSet.

Wijzigingen in DataRows kunnen ook gebeurtenissen activeren voor een gekoppelde DataView. De DataView klasse toont een ListChanged gebeurtenis die wordt geactiveerd wanneer een DataColumn waarde verandert of wanneer de samenstelling of sorteervolgorde van de weergave verandert. De DataRowView klasse toont een PropertyChanged gebeurtenis die wordt geactiveerd wanneer een gekoppelde DataColumn waarde verandert.

Sequence of Operations (volgorde van bewerkingen)

Dit is de volgorde van bewerkingen die optreden wanneer een DataRow bewerking wordt toegevoegd, gewijzigd of verwijderd:

1. Maak de voorgestelde record en pas eventuele wijzigingen toe.

2. Controleer de beperkingen voor niet-expressiekolommen.

3. Verhef de RowChanging of RowDeleting gebeurtenissen indien van toepassing.

4. Stel de voorgestelde record in op de huidige record.

5. Werk alle bijbehorende indexen bij.

6. Gebeurtenissen genereren ListChanged voor gekoppelde DataView objecten en PropertyChanged gebeurtenissen voor gekoppelde DataRowView objecten.

7. Evalueer alle expressiekolommen, maar vertraging bij het controleren van eventuele beperkingen voor deze kolommen.

8. Gebeurtenissen genereren ListChanged voor gekoppelde DataView objecten en PropertyChanged gebeurtenissen voor gekoppelde DataRowView objecten die worden beïnvloed door de evaluaties van de expressiekolom.

9. Verheffen RowChanged of RowDeleted gebeurtenissen indien van toepassing.

10. Controleer de beperkingen voor expressiekolommen.

Notitie

Wijzigingen in expressiekolommen genereren DataTable nooit gebeurtenissen. Wijzigingen in expressiekolommen worden alleen gegenereerd DataView en DataRowView gebeurtenissen. Expressiekolommen kunnen afhankelijk zijn van meerdere andere kolommen en kunnen meerdere keren worden geëvalueerd tijdens één DataRow bewerking. Elke expressie-evaluatie genereert gebeurtenissen en één DataRow bewerking kan meerdere ListChanged en PropertyChanged gebeurtenissen genereren wanneer expressiekolommen worden beïnvloed, inclusief meerdere gebeurtenissen voor dezelfde expressiekolom.

Waarschuwing

Gooi geen binnen NullReferenceException de RowChanged gebeurtenis-handler. Als er een NullReferenceException wordt gegenereerd in het RowChanged geval van een DataTable, dan zal het DataTable beschadigd zijn.

Opmerking

In het volgende voorbeeld ziet u hoe u gebeurtenis-handlers maakt voor de RowChangedgebeurtenissen , , TableNewRowRowDeletingColumnChangingRowDeletedColumnChangedRowChanging, en TableClearedTableClearing gebeurtenissen. Elke gebeurtenis-handler geeft uitvoer weer in het consolevenster wanneer deze wordt geactiveerd.

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

Zie ook

• Gegevens bewerken in een gegevenstabel
• DataAdapter-gebeurtenissen verwerken
• Gegevensset-gebeurtenissen verwerken
• overzicht van ADO.NET