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 EndInit zavolání metody.DataTable Tato událost je určená především pro podporu scénářů návrhu.
ColumnChanged	Nastane po úspěšné změně hodnoty v souboru DataColumn.
ColumnChanging	Nastane, když byla hodnota odeslána pro .DataColumn
RowChanged	Nastane po DataColumn úspěšné změně hodnoty nebo RowState DataRow hodnoty v souboru DataTable .
RowChanging	Nastane, když byla změna odeslána pro DataColumn hodnotu nebo RowState hodnotu DataRow v sadě DataTable.
RowDeleted	Nastane po označení DataRow v DataTable Deletedsouboru .
RowDeleting	Nastane před značkou DataRow in the DataTable je označen jako Deleted.
TableCleared	Nastane po volání Clear metody DataTable úspěšně vymazat každý DataRow.
TableClearing	Nastane po zavolání Clear metody, ale před zahájením Clear operace.
TableNewRow	Nastane po vytvoření nové DataRow NewRow volání metody DataTable.
Disposed	Nastane, když DataTable je Disposed. Zděděno z MarshalByValueComponent.

Poznámka:

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

Upozorňující

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

Další související události

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

Vlastnost Columns obsahuje DataColumnCollection instanci. Třída DataColumnCollection zveřejňuje CollectionChanged událost. Tato událost se aktivuje při DataColumn přidání, změně nebo odebrání z objektu 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 DataSet obsahuje DataTableCollection instanci. Třída DataTableCollection zveřejňuje událost CollectionChanged i CollectionChanging událost. Tyto události se aktivují při DataTable přidání nebo odebrání z objektu DataSet.

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

Posloupnost operací

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

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

2. Zkontrolujte omezení sloupců, které nejsou výrazy.

3. Vyvolání RowChanging událostí nebo RowDeleting událostí podle potřeby

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

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

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

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

8. Vyvolává ListChanged události pro přidružené DataView objekty a PropertyChanged události pro přidružené DataRowView objekty ovlivněné vyhodnocením sloupců výrazů.

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

10. Zkontrolujte omezení sloupců výrazů.

Poznámka:

Změny sloupců výrazů nikdy nevyvolají DataTable události. Změny sloupců výrazů pouze vyvolávají DataView a DataRowView události. 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é DataRow operace. Každé vyhodnocení výrazu vyvolává události a jedna DataRow operace může vyvolat více ListChanged událostí, PropertyChanged pokud jsou ovlivněny sloupce výrazů, případně i více událostí pro stejný sloupec výrazu.

Upozorňující

Nevolejte v obslužné NullReferenceException rutině RowChanged události. NullReferenceException Pokud je vyvolána v rámci RowChanged události DataTable, pak DataTable bude poškozena.

Příklad

Následující příklad ukazuje, jak vytvořit obslužné rutiny událostí pro , , , , , ColumnChangingColumnChanged, TableNewRow, TableCleared, a TableClearing události. RowDeletingRowDeletedRowChangingRowChanged 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 = 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

Viz také

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