Behandeln von DataTable-EreignissenHandling DataTable Events

Das DataTable-Objekt stellt eine Reihe von Ereignissen bereit, die von einer Anwendung verarbeitet werden können.The DataTable object provides a series of events that can be processed by an application. Eine Beschreibung dieser DataTable-Ereignisse finden Sie in der folgenden Tabelle:The following table describes DataTable events.

eventEvent BeschreibungDescription
Initialized Tritt ein, nachdem die EndInit-Methode einer DataTable aufgerufen wurde.Occurs after the EndInit method of a DataTable is called. Dieses Ereignis ist hauptsächlich zur Unterstützung von Szenarien zur Entwurfszeit gedacht.This event is intended primarily to support design-time scenarios.
ColumnChanged Tritt ein, nachdem ein Wert in einer DataColumn erfolgreich geändert wurde.Occurs after a value has been successfully changed in a DataColumn.
ColumnChanging Tritt ein, wenn ein Wert für eine DataColumn übermittelt wurde.Occurs when a value has been submitted for a DataColumn.
RowChanged Tritt ein, nachdem ein DataColumn-Wert oder der RowState einer DataRow in der DataTable erfolgreich geändert wurde.Occurs after a DataColumn value or the RowState of a DataRow in the DataTable has been changed successfully.
RowChanging Tritt ein, wenn eine Änderung für einen DataColumn-Wert oder für den RowState einer DataRow in der DataTable übermittelt wurde.Occurs when a change has been submitted for a DataColumn value or the RowState of a DataRow in the DataTable.
RowDeleted Tritt ein, nachdem eine DataRow in der DataTable als Deleted gekennzeichnet wurde.Occurs after a DataRow in the DataTable has been marked as Deleted.
RowDeleting Tritt ein, bevor eine DataRow in der DataTable als Deleted gekennzeichnet wird.Occurs before a DataRow in the DataTable is marked as Deleted.
TableCleared Tritt ein, nachdem ein Aufruf der Clear-Methode der DataTable jede DataRow erfolgreich gelöscht hat.Occurs after a call to the Clear method of the DataTable has successfully cleared every DataRow.
TableClearing Tritt ein, nachdem die Clear-Methode aufgerufen wurde, aber bevor der Clear-Vorgang beginnt.Occurs after the Clear method is called but before the Clear operation begins.
TableNewRow Tritt ein, nachdem durch einen Aufruf der DataRow-Methode der NewRow eine neue DataTable erstellt wurde.Occurs after a new DataRow is created by a call to the NewRow method of the DataTable.
Disposed Tritt ein, wenn die DataTable in den Disposed-Status versetzt wurde.Occurs when the DataTable is Disposed. Wird von MarshalByValueComponent geerbt.Inherited from MarshalByValueComponent.

Hinweis

Die meisten Operationen, die Zeilen hinzufügen oder löschen, führen nicht zum Auslösen der Ereignisse ColumnChanged und ColumnChanging.Most operations that add or delete rows do not raise the ColumnChanged and ColumnChanging events. Die ReadXml-Methode löst jedoch weiterhin das ColumnChanged-Ereignis und das ColumnChanging-Ereignis aus, bis XmlReadMode auf DiffGram oder auf Auto festgelegt ist, wenn das gelesene XML-Dokument ein DiffGram ist.However, the ReadXml method does raise ColumnChanged and ColumnChanging events, unless the XmlReadMode is set to DiffGram or is set to Auto when the XML document being read is a DiffGram.

Warnung

Wenn Daten in einem DataSet geändert werden, über das das RowChanged-Ereignis ausgelöst wird, können Daten beschädigt werden.Data corruption can occur if data is modified in a DataSet from which the RowChanged event is raised. Bei einer solchen Datenbeschädigung wird keine Ausnahme ausgelöst.No exception will be raised if such data corruption occurs.

Die Constraints-Eigenschaft enthält eine ConstraintCollection-Instanz.The Constraints property holds a ConstraintCollection instance. Die ConstraintCollection-Klasse macht ein CollectionChanged-Ereignis verfügbar.The ConstraintCollection class exposes a CollectionChanged event. Dieses Ereignis wird ausgelöst, wenn eine Einschränkung hinzugefügt, geändert oder aus der ConstraintCollection entfernt wird.This event fires when a constraint is added, modified, or removed from the ConstraintCollection.

Die Columns-Eigenschaft enthält eine DataColumnCollection-Instanz.The Columns property holds a DataColumnCollection instance. Die DataColumnCollection-Klasse macht ein CollectionChanged-Ereignis verfügbar.The DataColumnCollection class exposes a CollectionChanged event. Dieses Ereignis wird ausgelöst, wenn eine DataColumn hinzugefügt, geändert oder aus der DataColumnCollection entfernt wird.This event fires when a DataColumn is added, modified, or removed from the DataColumnCollection. Zu den Änderungen, die das Ereignis auslösen, gehören Änderungen des Namens, des Typs, des Ausdrucks oder der Ordinalposition einer Spalte.Modifications that cause the event to fire include changes to the name, type, expression or ordinal position of a column.

Die Tables-Eigenschaft eines DataSet enthält eine DataTableCollection-Instanz.The Tables property of a DataSet holds a DataTableCollection instance. Die DataTableCollection-Klasse macht sowohl ein CollectionChanged-Ereignis als auch ein CollectionChanging-Ereignis verfügbar.The DataTableCollection class exposes both a CollectionChanged and a CollectionChanging event. Diese Ereignisse werden ausgelöst, wenn eine DataTable hinzugefügt oder aus dem DataSet entfernt wird.These events fire when a DataTable is added to or removed from the DataSet.

Änderungen an DataRows können auch Ereignisse für eine verknüpfte DataView auslösen.Changes to DataRows can also trigger events for an associated DataView. Die DataView-Klasse macht ein ListChanged-Ereignis verfügbar, das ausgelöst wird, wenn sich ein DataColumn-Wert ändert oder wenn sich die Zusammensetzung oder Sortierreihenfolge der Ansicht ändert.The DataView class exposes a ListChanged event that fires when a DataColumn value changes or when the composition or sort order of the view changes. Die DataRowView-Klasse macht ein PropertyChanged-Ereignis verfügbar, das ausgelöst wird, wenn sich ein verknüpfter DataColumn-Wert ändert.The DataRowView class exposes a PropertyChanged event that fires when an associated DataColumn value changes.

Abfolge der VorgängeSequence of Operations

Beim Hinzufügen, Ändern oder Löschen einer DataRow laufen die Vorgänge in der folgenden Reihenfolge ab:Here is the sequence of operations that occur when a DataRow is added, modified, or deleted:

  1. Der vorgeschlagene Datensatz wird erstellt, und alle Änderungen werden übernommen.Create the proposed record and apply any changes.

  2. Die Einschränkungen für Nicht-Ausdruck-Spalten werden überprüft.Check constraints for non-expression columns.

  3. Das RowChanging-Ereignis oder das RowDeleting-Ereignis wird ausgelöst.Raise the RowChanging or RowDeleting events as applicable.

  4. Der vorgeschlagene Datensatz wird als aktueller Datensatz festgelegt.Set the proposed record to be the current record.

  5. Alle zugeordneten Indizes werden aktualisiert.Update any associated indexes.

  6. Die ListChanged-Ereignisse für zugeordnete DataView-Objekte und die PropertyChanged-Ereignisse für zugeordnete DataRowView-Objekte werden ausgelöst.Raise ListChanged events for associated DataView objects and PropertyChanged events for associated DataRowView objects.

  7. Alle Ausdrucksspalten werden ausgewertet, wobei aber die Überprüfung der Einschränkungen für diese Spalten verzögert wird.Evaluate all expression columns, but delay checking any constraints on these columns.

  8. Die ListChanged-Ereignisse für die zugeordneten DataView-Objekte und die PropertyChanged-Ereignisse für die zugeordneten DataRowView-Objekte, auf die sich die Auswertung der Ausdrucksspalten auswirkt, werden ausgelöst.Raise ListChanged events for associated DataView objects and PropertyChanged events for associated DataRowView objects affected by the expression column evaluations.

  9. Das RowChanged-Ereignis oder das RowDeleted-Ereignis wird ausgelöst.Raise RowChanged or RowDeleted events as applicable.

  10. Die Einschränkungen für Ausdrucksspalten werden überprüft.Check constraints on expression columns.

Hinweis

Änderungen an Ausdrucksspalten führen nie dazu, dass DataTable-Ereignisse ausgelöst werden.Changes to expression columns never raise DataTable events. Änderungen an Ausdrucksspalten lösen lediglich die Ereignisse DataView und DataRowView aus.Changes to expression columns only raise DataView and DataRowView events. Ausdrucksspalten können Abhängigkeiten von mehreren anderen Spalten besitzen und während eines einzelnen DataRow-Vorgangs mehrmals ausgewertet werden.Expression columns can have dependencies on multiple other columns, and can be evaluated multiple times during a single DataRow operation. Jede Ausdrucksauswertung löst Ereignisse aus, und ein einzelner DataRow-Vorgang kann mehrere ListChanged- und PropertyChanged-Ereignisse auslösen, sofern Ausdrucksspalten betroffen sind. Dabei ist es auch möglich, dass für ein und dieselbe Ausdrucksspalte mehrere Ereignisse ausgelöst werden.Each expression evaluation raises events, and a single DataRow operation can raise multiple ListChanged and PropertyChanged events when expression columns are affected, possibly including multiple events for the same expression column.

Warnung

Lösen Sie keine NullReferenceException im RowChanged-Ereignishandler aus.Do not throw a NullReferenceException within the RowChanged event handler. Wenn eine NullReferenceException im RowChanged-Ereignis einer DataTable ausgelöst wird, führt dies zur Beschädigung der DataTable.If a NullReferenceException is thrown within the RowChanged event of a DataTable, then the DataTable will be corrupted.

BeispielExample

Das folgende Beispiel zeigt, wie Ereignishandler für die Ereignisse RowChanged, RowChanging, RowDeleted, RowDeleting, ColumnChanged, ColumnChanging, TableNewRow, TableCleared und TableClearing erstellt werden können.The following example demonstrates how to create event handlers for the RowChanged, RowChanging, RowDeleted, RowDeleting, ColumnChanged, ColumnChanging, TableNewRow, TableCleared, and TableClearing events. Jeder Ereignishandler zeigt die Ausgabe beim Auslösen der Ereignisse im Konsolenfenster an.Each event handler displays output in the console window when it is fired.

static void DataTableEvents()
{
    DataTable table = new DataTable("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 += new DataRowChangeEventHandler(Row_Changed);

    // Add a RowChanging event handler.
    table.RowChanging += new DataRowChangeEventHandler(Row_Changing);

    // Add a RowDeleted event handler.
    table.RowDeleted += new DataRowChangeEventHandler(Row_Deleted);

    // Add a RowDeleting event handler.
    table.RowDeleting += new DataRowChangeEventHandler(Row_Deleting);

    // Add a ColumnChanged event handler.
    table.ColumnChanged += new
        DataColumnChangeEventHandler(Column_Changed);

    // Add a ColumnChanging event handler.
    table.ColumnChanging += new
        DataColumnChangeEventHandler(Column_Changing);

    // Add a TableNewRow event handler.
    table.TableNewRow += new
        DataTableNewRowEventHandler(Table_NewRow);

    // Add a TableCleared event handler.
    table.TableCleared += new
        DataTableClearEventHandler(Table_Cleared);

    // Add a TableClearing event handler.
    table.TableClearing += new
        DataTableClearEventHandler(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();
}


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

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

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

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

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

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

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

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

private 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

Siehe auchSee also