Partager via

Gestion des événements DataTable

L’objet DataTable fournit une série d’événements qui peuvent être traités par une application. Le tableau suivant décrit les DataTable événements.

Événement Descriptif
Initialized Se produit après que la méthode EndInit d'un DataTable a été appelée. Cet événement est destiné principalement à prendre en charge les scénarios pendant la phase de conception.
ColumnChanged Se produit une fois qu’une valeur a été modifiée avec succès dans un DataColumn.
ColumnChanging Se produit lorsqu’une valeur a été envoyée pour un DataColumn.
RowChanged Se produit après qu'une valeur DataColumn ou le RowState d'un DataRow ont été modifiés avec succès dans le DataTable.
RowChanging Se produit quand une modification a été proposée pour une valeur DataColumn ou le RowState d'un DataRow dans le DataTable.
RowDeleted Se produit après qu’un DataRow dans le fichier DataTable a été marqué comme Deleted.
RowDeleting Se produit avant qu’un DataRow dans DataTable soit marqué comme Deleted.
TableCleared Se produit après qu'un appel à la méthode Clear du DataTable a effacé avec succès chaque DataRow.
TableClearing Se produit après l’appel de la Clear méthode, mais avant le début de l’opération Clear .
TableNewRow Se produit après qu’un nouvel DataRow est créé par un appel à la méthode NewRow du DataTable.
Disposed Se produit lorsque l’objet DataTable est Disposed. Hérité de MarshalByValueComponent.

Remarque

La plupart des opérations qui ajoutent ou suppriment des lignes ne déclenchent pas les événements ColumnChanged et ColumnChanging. Toutefois, la méthode ReadXml déclenche les événements ColumnChanged et ColumnChanging, à moins que XmlReadMode ait la valeur DiffGram ou Auto lorsque le document XML lu est un DiffGram.

Avertissement

L’altération des données peut se produire si les données sont modifiées dans un DataSet, à partir duquel l’événement RowChanged est déclenché. Aucune exception n’est levée si une telle altération des données se produit.

La Constraints propriété contient une ConstraintCollection instance. La ConstraintCollection classe expose un CollectionChanged événement. Cet événement se déclenche lorsqu’une contrainte est ajoutée, modifiée ou supprimée du ConstraintCollection.

La Columns propriété contient une DataColumnCollection instance. La DataColumnCollection classe expose un CollectionChanged événement. Cet événement se déclenche lorsqu’un DataColumn est ajouté, modifié ou supprimé du DataColumnCollection. Les modifications qui provoquent le déclenchement de l’événement incluent les modifications apportées au nom, au type, à l’expression ou à la position ordinale d’une colonne.

La propriété Tables d’un DataSet détient une instance de DataTableCollection. La DataTableCollection classe expose à la fois un CollectionChanged et un événement CollectionChanging. Ces événements se déclenchent lorsqu'un DataTable est ajouté à ou supprimé du DataSet.

Les modifications de DataRows peuvent également déclencher des événements pour un élément associé à DataView. La DataView classe expose un ListChanged événement qui se déclenche lorsqu’une DataColumn valeur change ou lorsque la composition ou l’ordre de tri de l’affichage change. La DataRowView classe expose un PropertyChanged événement qui se déclenche lorsqu’une valeur associée DataColumn change.

Séquence d’opérations

Voici la séquence d’opérations qui se produisent lorsqu’une DataRow opération est ajoutée, modifiée ou supprimée :

  1. Créez l’enregistrement proposé et appliquez les modifications.

  2. Vérifiez les contraintes pour les colonnes sans expression.

  3. Déclenchez les événements RowChanging ou RowDeleting selon les besoins.

  4. Définissez l’enregistrement proposé comme enregistrement actif.

  5. Mettez à jour tous les index associés.

  6. Déclenchez des événements ListChanged pour les objets associés DataView et des événements PropertyChanged pour les objets associés DataRowView.

  7. Évaluez toutes les colonnes d’expression, mais retardez la vérification des contraintes sur ces colonnes.

  8. Déclenchez des événements ListChanged pour les objets associés DataView et des événements PropertyChanged pour les objets associés DataRowView qui sont affectés par les évaluations des colonnes d'expression.

  9. Déclenchez les événements RowChanged ou RowDeleted selon les besoins.

  10. Vérifiez les contraintes sur les colonnes d’expression.

Remarque

Les modifications apportées aux colonnes d’expression ne déclenchent DataTable jamais d’événements. Les modifications apportées aux colonnes d’expression ne déclenchent que les événements DataView et DataRowView. Les colonnes d’expression peuvent avoir des dépendances sur plusieurs autres colonnes et peuvent être évaluées plusieurs fois pendant une seule DataRow opération. Chaque évaluation d’expression déclenche des événements et une seule DataRow opération peut déclencher plusieurs ListChanged événements et PropertyChanged événements lorsque les colonnes d’expression sont affectées, y compris éventuellement plusieurs événements pour la même colonne d’expression.

Avertissement

Ne levez pas de NullReferenceException à l'intérieur du gestionnaire d'événements RowChanged. Si une NullReferenceException est levée à l'intérieur de l'événement RowChanged d'une DataTable, DataTable sera corrompue.

Exemple :

L’exemple suivant montre comment créer des gestionnaires d’événements pour les événements RowChanged, RowChanging, RowDeleted, RowDeleting, ColumnChanged, ColumnChanging, TableNewRow, TableCleared et TableClearing. Chaque gestionnaire d’événements affiche la sortie dans la fenêtre de console lorsqu’il est déclenché.

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

Voir aussi