Udostępnij za pośrednictwem

Obsługa zdarzeń tabeli danych

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

Zdarzenie Opis
Initialized Występuje po wywołaniu metody EndInit w DataTable. To zdarzenie ma na celu wspieranie przede wszystkim scenariuszy podczas projektowania.
ColumnChanged Występuje po pomyślnej zmianie wartości w obiekcie DataColumn.
ColumnChanging Występuje, gdy wartość została przesłana dla elementu DataColumn.
RowChanged Pojawia się po pomyślnej zmianie wartości DataColumn lub RowState elementu DataRow w obiekcie DataTable.
RowChanging Występuje, gdy zmiana została przesłana dla wartości DataColumn lub RowState elementu DataRow w DataTable.
RowDeleted Występuje po tym, jak element DataRow w obiekcie DataTable został oznaczony jako Deleted.
RowDeleting Występuje przed oznaczeniem DataRow w DataTable jako Deleted.
TableCleared Występuje po wywołaniu metody Clear na DataTable, gdy każda DataRow została pomyślnie wyczyszczona.
TableClearing Występuje po wywołaniu Clear metody , ale przed rozpoczęciem Clear operacji.
TableNewRow Występuje po utworzeniu nowego DataRow przez wywołanie metody NewRow z DataTable.
Disposed Występuje, gdy DataTable jest Disposed. Dziedziczone z MarshalByValueComponent.

Uwaga

Większość operacji, które dodają lub usuwają wiersze, nie zgłaszają zdarzeń ColumnChanged i ColumnChanging . Jednak metoda ReadXml zgłasza zdarzenia ColumnChanged i ColumnChanging, chyba że parametr XmlReadMode jest ustawiony na DiffGram lub jest ustawiony na Auto, 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 zdarzenie RowChanged jest zgłaszane. W przypadku wystąpienia takiego uszkodzenia danych nie zostanie zgłoszony żaden wyjątek.

Właściwość Constraints zawiera instancję ConstraintCollection. Klasa ConstraintCollection uwidacznia CollectionChanged zdarzenie. To zdarzenie jest wyzwalane po dodaniu, zmodyfikowaniu lub usunięciu ograniczenia z ConstraintCollection.

Właściwość Columns zawiera instancję DataColumnCollection. Klasa DataColumnCollection uwidacznia CollectionChanged zdarzenie. To zdarzenie jest uruchamiane, gdy DataColumn jest dodany, zmodyfikowany lub usunięty z DataColumnCollection. Modyfikacje, które powodują wywołanie zdarzenia, obejmują zmiany nazwy, typu, wyrażenia lub porządkowej pozycji kolumny.

Właściwość Tables obiektu DataSet przechowuje instancję DataTableCollection. Klasa DataTableCollection uwidacznia zarówno zdarzenie CollectionChanged, jak i zdarzenie CollectionChanging. Te zdarzenia są wyzwalane, gdy DataTable zostanie dodane do lub usunięte z DataSet.

Zmiany w DataRows mogą również wyzwalać zdarzenia dla skojarzonego DataView. 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. Zgłoś zdarzenia RowChanging lub RowDeleting w razie potrzeby.

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

  5. Zaktualizuj wszystkie skojarzone indeksy.

  6. Zgłaszaj ListChanged zdarzenia dla skojarzonych DataView obiektów oraz PropertyChanged zdarzenia dla 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 oraz DataView zdarzenia dla skojarzonych obiektów PropertyChanged, których dotyczy ocena kolumn wyrażeń.

  9. Zgłaszaj zdarzenia RowChanged lub RowDeleted w zależności od potrzeb.

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

Uwaga

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

Ostrzeżenie

Nie rzucaj NullReferenceException w programie obsługi zdarzeń RowChanged. Jeśli NullReferenceException jest wyrzucany podczas zdarzenia RowChanged w DataTable, to DataTable zostanie uszkodzony.

Przykład

W poniższym przykładzie pokazano, jak utworzyć programy obsługi zdarzeń dla RowChanged, RowChanging, RowDeleted, RowDeleting, ColumnChanged, ColumnChanging, TableNewRow, TableCleared i 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 = [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={e.Row["name"]}; action={e.Action}");

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

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

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

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

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

static void Table_NewRow(object sender,
    DataTableNewRowEventArgs e) =>
    Console.WriteLine($"Table_NewRow Event: RowState={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ż

  • Last updated on