Zpracování událostí datové tabulky

Objekt DataTable poskytuje řadu událostí, které lze zpracovat aplikací. Následující tabulka popisuje DataTable události.

Událost	Popis
Initialized	Nastane po zavolání metody EndInit objektu DataTable. Tato událost je určená především pro podporu scénářů v době návrhu.
ColumnChanged	Nastane poté, co byla úspěšně změněna hodnota v DataColumn.
ColumnChanging	Dochází k tomu, když je odeslána hodnota pro DataColumn.
RowChanged	Dojde k tomu po úspěšné změně hodnoty DataColumn nebo RowState u DataRow v DataTable.
RowChanging	Dochází k tomu, když je změna odeslána pro hodnotu DataColumn nebo RowState u DataRow v DataTable.
RowDeleted	Nastane poté, co byl DataRow v DataTable označen jako Deleted.
RowDeleting	Nastane před DataRow v DataTable, který je označen jako Deleted.
TableCleared	Po úspěšném vymazání všech Clearpo zavolání metody DataTable z DataRow nastane tato událost.
TableClearing	Nastane po zavolání metody Clear, ale před zahájením operace Clear.
TableNewRow	Nastane po vytvoření nového DataRow voláním metody NewRow objektu DataTable.
Disposed	Nastane, když je DataTableDisposed. Zděděno z MarshalByValueComponent.

Poznámka:

Většina operací, které přidávají nebo odstraňují řádky, nespouští události ColumnChanged a ColumnChanging. Metoda ReadXml však vyvolává ColumnChanged a ColumnChanging události, pokud není XmlReadMode nastavena na DiffGram nebo na Auto při čtení dokumentu XML, který je DiffGram.

Varování

K poškození dat může dojít v případě, že dojde k úpravě dat v DataSet, ze kterého je vyvolána událost RowChanged. Pokud dojde k poškození těchto dat, nevyvolá se žádná výjimka.

Další související události

Vlastnost Constraints obsahuje instanci ConstraintCollection. Třída ConstraintCollection zpřístupňuje událost CollectionChanged. Tato událost se aktivuje při přidání, změně nebo odebrání omezení z ConstraintCollection.

Vlastnost Columns obsahuje instanci DataColumnCollection. Třída DataColumnCollection zpřístupňuje událost CollectionChanged. Tato událost se aktivuje při přidání, změně nebo odebrání DataColumn z DataColumnCollection. Změny, které způsobí, že událost se aktivuje, zahrnují změny názvu, typu, výrazu nebo pořadového umístění sloupce.

Vlastnost Tables objektu DataSet obsahuje instanci DataTableCollection. Třída DataTableCollection zveřejňuje událost CollectionChanged i událost CollectionChanging. Tyto události se aktivují při přidání nebo odebrání DataTable z DataSet.

Změny prvku DataRows mohou také aktivovat události pro příslušný prvek DataView. Třída DataView zveřejňuje událost ListChanged, která se aktivuje, když se změní hodnota DataColumn nebo když se změní pořadí složení nebo řazení zobrazení. Třída DataRowView zveřejňuje událost PropertyChanged, která se aktivuje, když se změní přidružená hodnota DataColumn.

Posloupnost operací

Tady je posloupnost operací, ke kterým dochází při přidání, změně nebo odstranění DataRow:

1. Vytvořte navrhovaný záznam a použijte všechny změny.

2. Zkontrolujte omezení nevýrazových sloupců.

3. Podle potřeby vyvolejte události RowChanging nebo RowDeleting.

4. Nastavte navrhovaný záznam jako aktuální záznam.

5. Aktualizujte všechny přidružené indexy.

6. Vyvolejte ListChanged události pro přidružené objekty DataView a PropertyChanged události pro přidružené objekty DataRowView.

7. Vyhodnoťte všechny sloupce výrazů, ale pozdržte kontrolu všech omezení těchto sloupců.

8. Vyvolání událostí ListChanged pro objekty přidružené DataView a událostí PropertyChanged pro objekty přidružené DataRowView, které jsou ovlivněny vyhodnocením sloupců výrazu.

9. Vyvolání událostí RowChanged nebo RowDeleted podle potřeby

10. Zkontrolujte omezení výrazových sloupců.

Poznámka:

Změny ve sloupcích výrazů nikdy nevyvolají události DataTable. Změny sloupců výrazů vyvolávají pouze události DataView a DataRowView. Sloupce výrazů můžou mít závislosti na několika dalších sloupcích a je možné je vyhodnotit vícekrát během jedné operace DataRow. Každé vyhodnocení výrazu vyvolává události a jedna operace DataRow může vyvolat více ListChanged a PropertyChanged událostí, pokud jsou ovlivněny sloupce výrazů, pravděpodobně včetně více událostí pro stejný sloupec výrazu.

Varování

V obslužné rutině události NullReferenceException nevyvoláte RowChanged. Pokud je NullReferenceException vyvolán během události RowChanged objektu DataTable, bude DataTable poškozen.

Příklad

Následující příklad ukazuje, jak vytvořit obslužné rutiny událostí pro RowChanged, RowChanging, RowDeleted, RowDeleting, ColumnChanged, ColumnChanging, TableNewRow, TableCleareda TableClearing události. Každá obslužná rutina události při spuštění zobrazí výstup v okně konzoly.

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

Viz také

• manipulace s daty v datové tabulce
• Zpracování událostí datového adaptéru
• zpracování událostí datové sady
• Přehled ADO.NET