Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
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.
Événements connexes supplémentaires
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 :
Créez l’enregistrement proposé et appliquez les modifications.
Vérifiez les contraintes pour les colonnes sans expression.
Déclenchez les événements
RowChanging
ouRowDeleting
selon les besoins.Définissez l’enregistrement proposé comme enregistrement actif.
Mettez à jour tous les index associés.
Déclenchez des événements
ListChanged
pour les objets associésDataView
et des événementsPropertyChanged
pour les objets associésDataRowView
.Évaluez toutes les colonnes d’expression, mais retardez la vérification des contraintes sur ces colonnes.
Déclenchez des événements
ListChanged
pour les objets associésDataView
et des événementsPropertyChanged
pour les objets associésDataRowView
qui sont affectés par les évaluations des colonnes d'expression.Déclenchez les événements
RowChanged
ouRowDeleted
selon les besoins.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