Obsługa zdarzeń elementu DataTable

Obiekt DataTable zawiera serię zdarzeń, które mogą być przetwarzane przez aplikację. W poniższej tabeli opisano DataTable zdarzenia.

Wydarzenie	opis
Initialized	Występuje po wywołaniu EndInit metody DataTable . To zdarzenie jest przeznaczone głównie do obsługi scenariuszy czasu projektowania.
ColumnChanged	Występuje po pomyślnym zmianie wartości w obiekcie DataColumn.
ColumnChanging	Występuje, gdy wartość została przesłana dla elementu DataColumn.
RowChanged	Występuje po pomyślnym DataColumn zmianie wartości lub RowState wartości DataRow w obiekcie DataTable .
RowChanging	Występuje, gdy zmiana została przesłana dla DataColumn wartości lub RowState elementu DataRow w obiekcie DataTable.
RowDeleted	Występuje po tym, jak element DataRow w obiekcie DataTable został oznaczony jako Deleted.
RowDeleting	Występuje przed oznaczeniem w DataRow obiekcie DataTable jako Deleted.
TableCleared	Występuje po wywołaniu Clear metody DataTable metody pomyślnie wyczyszczonej co DataRow.
TableClearing	Występuje po wywołaniu Clear metody , ale przed rozpoczęciem Clear operacji.
TableNewRow	Występuje po utworzeniu nowego DataRow przez wywołanie NewRow metody .DataTable
Disposed	Występuje, gdy element ma wartość DataTableDisposed. Dziedziczone z MarshalByValueComponentelementu .

Uwaga

Większość operacji, które dodają lub usuwają wiersze, nie zgłaszają zdarzeń ColumnChanged i ColumnChanging . ReadXml Jednak metoda zgłasza zdarzenia ColumnChanged i ColumnChanging , chyba że XmlReadMode parametr jest ustawiony na DiffGram lub jest ustawionyAuto, gdy odczytywany dokument XML jest DiffGram.

Ostrzeżenie

Uszkodzenie danych może wystąpić, jeśli dane są modyfikowane w obiekcie DataSet , z którego RowChanged jest zgłaszane zdarzenie. W przypadku wystąpienia takiego uszkodzenia danych nie zostanie zgłoszony żaden wyjątek.

Dodatkowe powiązane zdarzenia

Właściwość Constraints zawiera ConstraintCollection wystąpienie. Klasa ConstraintCollection uwidacznia CollectionChanged zdarzenie. To zdarzenie jest uruchamiane po dodaniu, zmodyfikowaniu lub usunięciu ograniczenia z klasy ConstraintCollection.

Właściwość Columns zawiera DataColumnCollection wystąpienie. Klasa DataColumnCollection uwidacznia CollectionChanged zdarzenie. To zdarzenie jest uruchamiane po DataColumn dodaniu, zmodyfikowaniu lub usunięciu elementu z obiektu DataColumnCollection. Modyfikacje, które powodują wyzwolenie zdarzenia, obejmują zmiany nazwy, typu, wyrażenia lub porządkowej pozycji kolumny.

Właściwość Tables obiektu DataSet przechowuje DataTableCollection wystąpienie. Klasa DataTableCollection uwidacznia zarówno zdarzenie, jak CollectionChangedCollectionChanging i . Te zdarzenia są wyzwalane po dodaniu lub usunięciu elementu DataTable z klasy DataSet.

Zmiany, które DataRows mogą również wyzwalać zdarzenia dla skojarzonego DataViewelementu . Klasa DataView uwidacznia ListChanged zdarzenie, które jest uruchamiane, gdy DataColumn wartość zmienia się lub gdy zmienia się kompozycja lub kolejność sortowania widoku. Klasa DataRowView uwidacznia PropertyChanged zdarzenie, które jest uruchamiane po zmianie skojarzonej DataColumn wartości.

sekwencja operacji

Oto sekwencja operacji, które występują po DataRow dodaniu, zmodyfikowaniu lub usunięciu elementu:

1. Utwórz proponowany rekord i zastosuj wszelkie zmiany.

2. Sprawdź ograniczenia dla kolumn innych niż wyrażenia.

3. RowChanging W razie potrzeby zgłoś zdarzenia lub RowDeleting .

4. Ustaw proponowany rekord jako bieżący rekord.

5. Zaktualizuj wszystkie skojarzone indeksy.

6. Zgłaszaj ListChanged zdarzenia dla skojarzonych DataView obiektów i PropertyChanged zdarzeń skojarzonych DataRowView obiektów.

7. Oceń wszystkie kolumny wyrażeń, ale opóźnij sprawdzanie ograniczeń dotyczących tych kolumn.

8. Zgłaszaj ListChanged zdarzenia dla skojarzonych obiektów i PropertyChanged zdarzeń dla skojarzonych DataViewDataRowView obiektów, których dotyczy ocena kolumn wyrażeń.

9. W razie potrzeby zgłaszaj RowChanged zdarzenia lub RowDeleted zgłaszaj je.

10. Sprawdź ograniczenia dotyczące kolumn wyrażeń.

Uwaga

Zmiany w kolumnach wyrażeń nigdy nie zgłaszają DataTable zdarzeń. Zmiany w kolumnach wyrażeń są wywoływane DataView tylko i DataRowView zdarzenia. Kolumny wyrażeń mogą mieć zależności od wielu innych kolumn i można je wielokrotnie oceniać podczas jednej DataRow operacji. Każda ocena wyrażenia zgłasza zdarzenia, a pojedyncza DataRow operacja może zgłaszać wiele ListChanged zdarzeń, PropertyChanged gdy mają to wpływ na kolumny wyrażeń, w tym wiele zdarzeń dla tej samej kolumny wyrażeń.

Ostrzeżenie

Nie zgłaszaj NullReferenceException elementu w programie obsługi zdarzeń RowChanged . Jeśli element NullReferenceException jest zgłaszany w RowChanged ramach zdarzenia DataTable, DataTable element zostanie uszkodzony.

Przykład

W poniższym przykładzie pokazano, jak utworzyć programy obsługi zdarzeń dla RowChangedzdarzeń , , TableNewRowColumnChangedRowChangingRowDeletingColumnChangingRowDeletedTableClearedi .TableClearing Każdy program obsługi zdarzeń wyświetla dane wyjściowe w oknie konsoli po jego uruchomieniu.

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

Zobacz też

• Operowanie danymi w elemencie DataTable
• Obsługa zdarzeń elementu DataAdapter
• Obsługa zdarzeń elementu DataSet
• Omówienie ADO.NET