Gestione degli eventi di DataTable (ADO.NET)

Nell'oggetto DataTable sono disponibili diversi eventi che possono essere elaborati da un'applicazione.Nella tabella seguente vengono descritti gli eventi di DataTable.

Nota
La maggior parte delle operazioni che aggiungono o eliminano righe non generano gli eventi ColumnChanged e ColumnChanging.Tuttavia, il metodo ReadXml genera gli eventi ColumnChanged e ColumnChanging, a meno che XmlReadMode non sia impostato su DiffGram o su Auto quando il documento XML da leggere è un DiffGram.

Attenzione
I dati possono venire danneggiati se vengono modificati in un oggetto DataSet da cui viene generato l'evento RowChanged.In caso di danneggiamento dei dati, non viene generata alcuna eccezione.

Eventi correlati aggiuntivi

La proprietà Constraints contiene un'istanza di ConstraintCollection.La classe ConstraintCollection espone un evento CollectionChanged.Questo evento viene attivato quando un vincolo viene aggiunto, modificato o rimosso da ConstraintCollection.

La proprietà Columns contiene un'istanza di DataColumnCollection.La classe DataColumnCollection espone un evento CollectionChanged.Questo evento viene attivato quando una DataColumn viene aggiunta, modificata o rimossa da DataColumnCollection.Le modifiche che causano l'attivazione dell'evento includono le modifiche al nome, tipo, espressione o posizione ordinale di una colonna.

La proprietà Tables di DataSet contiene un'istanza di DataTableCollection.La classe DataTableCollection espone sia un evento CollectionChanged sia un evento CollectionChanging.Questi eventi vengono attivati quando una DataTable viene aggiunta, modificata o rimossa dal DataSet.

Le modifiche a DataRows possono attivare anche eventi per un oggetto DataView associato.La classe DataView espone un evento ListChanged che viene attivato quando viene modificato un valore DataColumn oppure la composizione o l'ordine della visualizzazione.La classe DataRowView espone un evento PropertyChanged che viene attivato quando viene modificato valore DataColumn associato.

Sequenza delle operazioni

Di seguito è riportata la sequenza delle operazioni che si verificano quando una DataRow viene aggiunta, modificata o eliminata:

1. Creare il record proposto e applicare eventuali modifiche.

2. Verificare i vincoli per le colonne non espressioni.

3. Generare gli eventi RowChanging o RowDeleting come applicabile.

4. Impostare il record proposto come record corrente.

5. Aggiornare gli eventuali indici associati.

6. Generare gli eventi ListChanged per gli oggetti DataView associati e gli eventi PropertyChanged per gli oggetti DataRowView associati.

7. Valutare tutte le colonne espressioni, ma rimandare la verifica della presenza di vincoli su queste colonne.

8. Generare gli eventi ListChanged per gli oggetti DataView associati e gli eventi PropertyChanged per gli oggetti DataRowView associati interessati dalle valutazioni delle colonne espressioni.

9. Generare gli eventi RowChanged o RowDeleted come applicabile.

10. Verificare i vincoli per le colonne espressioni.

Nota

Le modifiche alle colonne espressioni non generano mai eventi DataTable,ma generano solo eventi DataView e DataRowView,Le colonne espressioni possono avere dipendenze su molte altre colonne e possono essere valutate più volte durante una singola operazione DataRow.Ogni valutazione di espressione genera eventi e una singola operazione DataRow può generare più eventi ListChanged e PropertyChanged quando sono interessate colonne espressioni, magari con più eventi per la stessa colonna espressioni.

Attenzione
Non generare un'eccezione NullReferenceException all'interno del gestore eventi RowChanged.Se viene generata un'eccezione NullReferenceException all'interno dell'evento RowChanged di un oggetto DataTable, quest'ultimo sarà danneggiato.

Esempio

Nell'esempio seguente viene illustrato come creare gestori per gli eventi RowChanged, RowChanging, RowDeleted, RowDeleting, ColumnChanged, ColumnChanging, TableNewRow, TableCleared e TableClearing.Ogni gestore evento visualizza l'output nella finestra della console quando viene attivato.

Private Sub DataTableEvents()

    Dim table As DataTable = 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

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());
}

Vedere anche

Concetti

Gestione degli eventi di DataAdapter (ADO.NET)

Gestione degli eventi di DataSet (ADO.NET)

Altre risorse

Modifica dei dati in una DataTable