Gestione degli eventi DataTable

Articolo
04/04/2025

L'oggetto DataTable fornisce una serie di eventi che possono essere elaborati da un'applicazione. Nella tabella seguente vengono descritti DataTable eventi.

Evento	Descrizione
Initialized	Si verifica dopo che il metodo EndInit di un `DataTable` è stato chiamato. Questo evento è destinato principalmente al supporto di scenari in fase di progettazione.
ColumnChanged	Si verifica dopo che un valore è stato modificato correttamente in un DataColumn.
ColumnChanging	Si verifica quando un valore è stato inviato per un `DataColumn`.
RowChanged	Si verifica dopo che un valore `DataColumn` o il RowState di un DataRow nel `DataTable` è stato modificato correttamente.
RowChanging	Si verifica quando viene inviata una modifica per un `DataColumn` valore o il `RowState` di un `DataRow` nel `DataTable`.
RowDeleted	Si verifica dopo che un `DataRow` è stato contrassegnato come `Deleted` nel `DataTable`.
RowDeleting	Si verifica prima che un `DataRow` nel `DataTable` sia contrassegnato come `Deleted`.
TableCleared	Si verifica dopo che una chiamata al metodo Clear del `DataTable` ha eliminato con successo tutti i `DataRow`.
TableClearing	Si verifica dopo la chiamata del metodo #D0 ma prima dell'inizio dell'operazione di #D1.
TableNewRow	La creazione di un nuovo #D0 si verifica a seguito di una chiamata al metodo #D1 del #B2.
Disposed	Si verifica quando il `DataTable` è `Disposed`. Ereditato da MarshalByValueComponent.

Nota

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

Avvertimento

Il danneggiamento dei dati può verificarsi se i dati vengono modificati in un #D0 da cui viene generato l'evento #D1. Se si verifica un danneggiamento di tali dati, non verrà generata alcuna eccezione.

La proprietà Constraints contiene un'istanza ConstraintCollection. La ConstraintCollection classe rende disponibile un CollectionChanged evento. Questo evento viene generato quando un vincolo viene aggiunto, modificato o rimosso dal ConstraintCollection.

La proprietà Columns contiene un'istanza DataColumnCollection. La classe DataColumnCollection espone un evento CollectionChanged. L'evento si attiva quando un DataColumn viene aggiunto, modificato o rimosso dal DataColumnCollection. Le modifiche che causano la generazione dell'evento includono modifiche al nome, al tipo, all'espressione o alla posizione ordinale di una colonna.

La proprietà Tables di un DataSet contiene un'istanza DataTableCollection. La classe DataTableCollection espone sia un evento CollectionChanged che un evento CollectionChanging. Questi eventi si attivano quando un #D0 viene aggiunto o rimosso dal #B1.

Le modifiche a DataRows possono anche attivare eventi per l'DataView associato. La classe #D0 espone un evento #D1 che viene generato quando un valore #D2 cambia o quando cambia la composizione o l'ordinamento della visualizzazione. La classe #D0 espone un evento #D1 che viene generato quando viene modificato un valore #D2 associato.

Sequenza di operazioni

Ecco la sequenza di operazioni che si verificano quando viene aggiunto, modificato o eliminato un #D0:

Creare il record proposto e applicare eventuali modifiche.
Controllare i vincoli per le colonne non di espressione.
Attivare gli eventi RowChanging o RowDeleting come applicabile.
Impostare il record proposto come record corrente.
Aggiornare gli indici associati.
Generare eventi ListChanged per gli oggetti DataView associati e gli eventi PropertyChanged per gli oggetti DataRowView associati.
Valutare tutte le colonne di espressione, ma ritardare il controllo di eventuali vincoli per queste colonne.
Generare eventi ListChanged per gli oggetti DataView associati e eventi PropertyChanged per gli oggetti DataRowView influenzati dalle valutazioni delle colonne di espressione.
Attivare eventi RowChanged o RowDeleted dove applicabile.
Verifica i vincoli sulle colonne delle espressioni.

Nota

Le modifiche apportate alle colonne delle espressioni non generano mai eventi DataTable. Modifiche alle colonne d'espressione generano solo eventi DataView e DataRowView. Le colonne di espressione possono avere dipendenze da più colonne e possono essere valutate più volte durante una singola operazione di DataRow. Ogni valutazione dell'espressione genera eventi, e una singola operazione DataRow può generare più eventi ListChanged e PropertyChanged quando le colonne di espressione sono interessate, possibilmente includendo più eventi per la stessa colonna di espressione.

Avvertimento

Non generare un NullReferenceException all'interno del gestore eventi RowChanged. Se una NullReferenceException viene lanciata all'interno dell'evento RowChanged di un DataTable, allora il DataTable verrà danneggiato.

Esempio

Nell'esempio seguente viene illustrato come creare gestori eventi per gli eventi #B0 , #B1 , #B2 , #B3 , #B4 , #B5 , #B6 , #B7 e #D8 . Ogni gestore eventi visualizza l'output nella finestra della console quando viene attivato.

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

Vedere anche

#B0 La manipolazione dei dati in un #C1 DataTable
#B0 Gestione degli eventi DataAdapter #C1
gestione degli eventi del DataSet
Panoramica di ADO.NET

Condividi tramite

Gestione degli eventi DataTable

Sequenza di operazioni

Esempio

Vedere anche

Risorse aggiuntive

Condividi tramite

Gestione degli eventi DataTable

Eventi correlati aggiuntivi

Sequenza di operazioni

Esempio

Vedere anche

Risorse aggiuntive