Obsługa zdarzeń elementu DataTableHandling DataTable Events

DataTable Obiekt zawiera serię zdarzeń, które mogą być przetwarzane przez aplikację.The DataTable object provides a series of events that can be processed by an application. W poniższej tabeli opisano DataTable zdarzenia.The following table describes DataTable events.

ZdarzenieEvent OpisDescription
Initialized Występuje po EndInit wywołaniu metody DataTable klasy.Occurs after the EndInit method of a DataTable is called. To zdarzenie jest przeznaczone głównie do obsługi scenariuszy czasu projektowania.This event is intended primarily to support design-time scenarios.
ColumnChanged Występuje po pomyślnej zmianie wartości w DataColumn.Occurs after a value has been successfully changed in a DataColumn.
ColumnChanging Występuje, gdy wartość zostanie przesłana dla elementu DataColumn.Occurs when a value has been submitted for a DataColumn.
RowChanged Występuje po DataColumn pomyślnym zmianie RowState wartości lub DataRow elementu w DataTable .Occurs after a DataColumn value or the RowState of a DataRow in the DataTable has been changed successfully.
RowChanging Występuje, gdy DataColumn została przesłana zmiana dotycząca wartości RowState lub z DataRow w DataTable.Occurs when a change has been submitted for a DataColumn value or the RowState of a DataRow in the DataTable.
RowDeleted Występuje po oznaczeniu DataRow elementu DataTable w elemencie jako Deleted.Occurs after a DataRow in the DataTable has been marked as Deleted.
RowDeleting Występuje przed oznaczeniem DataRow DataTable elementu w Deleted.Occurs before a DataRow in the DataTable is marked as Deleted.
TableCleared Występuje po pomyślnym wyczyszczeniu Clear DataRowwywołania metody DataTable .Occurs after a call to the Clear method of the DataTable has successfully cleared every DataRow.
TableClearing Występuje po wywołaniu Clear metody, ale Clear przed rozpoczęciem operacji.Occurs after the Clear method is called but before the Clear operation begins.
TableNewRow Występuje po utworzeniu nowej DataRow przez wywołanie NewRow metody DataTable.Occurs after a new DataRow is created by a call to the NewRow method of the DataTable.
Disposed Występuje, DataTable gdy jest Disposed.Occurs when the DataTable is Disposed. Dziedziczone z MarshalByValueComponent.Inherited from MarshalByValueComponent.

Uwaga

Większość operacji, które dodają lub usuwają wiersze, ColumnChanged nie ColumnChanging powodują zdarzeń i.Most operations that add or delete rows do not raise the ColumnChanged and ColumnChanging events. ColumnChanged ColumnChanging Auto DiffGram DiffGramJednak metoda wykonuje podnoszenieXmlReadMode i zdarzenia, chyba że jest ustawiona na lub jest ustawiona na, gdy dokument XML jest odczytywany. ReadXmlHowever, 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.

Ostrzeżenie

Uszkodzenie danych może wystąpić, DataSet RowChanged Jeśli dane są modyfikowane w przypadku, gdy zdarzenie jest zgłaszane.Data corruption can occur if data is modified in a DataSet from which the RowChanged event is raised. Wyjątek nie zostanie zgłoszony, jeśli wystąpi takie uszkodzenie danych.No exception will be raised if such data corruption occurs.

Constraints WłaściwośćConstraintCollection przechowuje wystąpienie.The Constraints property holds a ConstraintCollection instance. ConstraintCollection KlasaCollectionChanged ujawnia zdarzenie.The ConstraintCollection class exposes a CollectionChanged event. To zdarzenie jest wyzwalane, gdy ograniczenie zostanie dodane, zmodyfikowane lub usunięte z ConstraintCollection.This event fires when a constraint is added, modified, or removed from the ConstraintCollection.

Columns WłaściwośćDataColumnCollection przechowuje wystąpienie.The Columns property holds a DataColumnCollection instance. DataColumnCollection KlasaCollectionChanged ujawnia zdarzenie.The DataColumnCollection class exposes a CollectionChanged event. To zdarzenie jest wyzwalane DataColumn , gdy element jest dodawany, modyfikowany lub DataColumnCollectionusuwany z.This event fires when a DataColumn is added, modified, or removed from the DataColumnCollection. Modyfikacje, które powodują pożar zdarzenia, obejmują zmiany nazwy, typu, wyrażenia lub liczby porządkowej kolumny.Modifications that cause the event to fire include changes to the name, type, expression or ordinal position of a column.

Tables Właściwość obiektuDataTableCollection zawiera wystąpienie. DataSetThe Tables property of a DataSet holds a DataTableCollection instance. Klasa uwidacznia CollectionChanging zarówno zdarzenie CollectionChanged DataTableCollection , jak i.The DataTableCollection class exposes both a CollectionChanged and a CollectionChanging event. Te zdarzenia DataTable są wyzwalane po dodaniu lub usunięciu DataSetz.These events fire when a DataTable is added to or removed from the DataSet.

Zmiany w DataRows usłudze mogą również wyzwalać zdarzenia dla DataViewskojarzonego elementu.Changes to DataRows can also trigger events for an associated DataView. DataView Klasa uwidaczniaDataColumn zdarzenie, które jest wyzwalane, gdy wartość ulegnie zmianie lub gdy zmieni się kompozycja lub porządek sortowania widoku. ListChangedThe DataView class exposes a ListChanged event that fires when a DataColumn value changes or when the composition or sort order of the view changes. Klasa uwidacznia zdarzenie, które jest wyzwalane, gdy DataColumn zostanie zmieniona skojarzona wartość. PropertyChanged DataRowViewThe DataRowView class exposes a PropertyChanged event that fires when an associated DataColumn value changes.

Sekwencja operacjiSequence of Operations

Oto sekwencja operacji, które wystąpiły po DataRow dodaniu, zmodyfikowaniu lub usunięciu:Here is the sequence of operations that occur when a DataRow is added, modified, or deleted:

  1. Utwórz proponowany rekord i Zastosuj wszelkie zmiany.Create the proposed record and apply any changes.

  2. Ograniczenia check dla kolumn niebędących wyrażeniami wyrażeń.Check constraints for non-expression columns.

  3. Zgłoś odpowiednie zdarzenia RowDeletinglub. RowChangingRaise the RowChanging or RowDeleting events as applicable.

  4. Ustaw proponowany rekord jako bieżący rekord.Set the proposed record to be the current record.

  5. Aktualizowanie wszystkich skojarzonych indeksów.Update any associated indexes.

  6. Zgłoś ListChanged zdarzenia dla skojarzonych DataView obiektów i PropertyChanged zdarzeń dla skojarzonych DataRowView obiektów.Raise ListChanged events for associated DataView objects and PropertyChanged events for associated DataRowView objects.

  7. Oceń wszystkie kolumny wyrażeń, ale Opóźnij sprawdzanie ograniczeń dotyczących tych kolumn.Evaluate all expression columns, but delay checking any constraints on these columns.

  8. Wywołaj ListChanged zdarzenia dla DataView skojarzonych obiektów PropertyChanged i zdarzeń dla DataRowView skojarzonych obiektów, na które mają wpływ oceny kolumn wyrażeń.Raise ListChanged events for associated DataView objects and PropertyChanged events for associated DataRowView objects affected by the expression column evaluations.

  9. RowChanged Podnieś RowDeleted lub zgłoś odpowiednie zdarzenia.Raise RowChanged or RowDeleted events as applicable.

  10. Ograniczenia check dla kolumn wyrażeń.Check constraints on expression columns.

Uwaga

Zmiany w kolumnach wyrażeń nigdy nie DataTable powodują zdarzeń.Changes to expression columns never raise DataTable events. Zmiany w kolumnach wyrażeń powodują DataView podnoszenie DataRowView i zdarzenia.Changes to expression columns only raise DataView and DataRowView events. Kolumny wyrażeń mogą mieć zależności dla wielu innych kolumn i mogą być oceniane wiele razy podczas jednej DataRow operacji.Expression columns can have dependencies on multiple other columns, and can be evaluated multiple times during a single DataRow operation. Każde obliczenie wyrażenia wywołuje zdarzenia, a pojedyncza DataRow operacja może spowodować wygenerowanie PropertyChanged wielu ListChanged i zdarzeń w przypadku, gdy dotyczy kolumn wyrażeń, może także uwzględniać wiele zdarzeń dla tej samej kolumny wyrażenia.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.

Ostrzeżenie

Nie NullReferenceException zgłaszaj RowChanged w ramach procedury obsługi zdarzeń.Do not throw a NullReferenceException within the RowChanged event handler. Jeśli jest zgłaszany RowChanged w ramach zdarzenia DataTable, DataTable zostanie uszkodzona. NullReferenceExceptionIf a NullReferenceException is thrown within the RowChanged event of a DataTable, then the DataTable will be corrupted.

PrzykładExample

Poniższy RowChangedprzykład ilustruje sposób tworzenia obsługi zdarzeń dla zdarzeń ColumnChanged RowDeleting RowDeleted RowChanging ,ColumnChanging,,,,,, i TableClearing. TableNewRow TableClearedThe following example demonstrates how to create event handlers for the RowChanged, RowChanging, RowDeleted, RowDeleting, ColumnChanged, ColumnChanging, TableNewRow, TableCleared, and TableClearing events. Każdy program obsługi zdarzeń wyświetla dane wyjściowe w oknie konsoli, gdy jest on uruchamiany.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

Zobacz takżeSee also