Modifier des données dans des jeux de données en utilisant .NET Framework
Remarque
Les jeux de données et les classes associées sont des technologies .NET Framework héritées qui datent du début des années 2000. Elles permettent aux applications d’utiliser des données en mémoire pendant que les applications sont déconnectées de la base de données. Ces technologies sont particulièrement utiles aux applications qui permettent aux utilisateurs de modifier des données, et de rendre ces changements persistants dans la base de données. Même si les jeux de données sont une technologie très efficace, nous vous recommandons d’utiliser Entity Framework Core pour les nouvelles applications .NET. Entity Framework offre un moyen plus naturel d’utiliser des données tabulaires en tant que modèles objet. De plus, il présente une interface de programmation plus simple.
La modification des données s’effectue de la même façon pour une table de données que pour une table située dans n’importe quelle base de données. Le processus peut consister à insérer, à mettre à jour et à supprimer des enregistrements dans la table. Dans un formulaire lié aux données, vous pouvez spécifier les champs modifiables par l’utilisateur. L’infrastructure de liaison de données gère dans ce cas tout le suivi des modifications afin que celles-ci puissent être renvoyées ultérieurement à la base de données. Si vous modifiez programmatiquement les données et que vous envisagez de renvoyer ces changements à la base de données, vous devez utiliser les objets et méthodes qui effectuent automatiquement le suivi des modifications.
En plus de modifier les données réelles, vous pouvez interroger une DataTable pour retourner des lignes de données spécifiques, par exemple des lignes individuelles, des versions spécifiques de lignes (d’origine et proposées), des lignes modifiées ou des lignes comportant des erreurs.
Modification des lignes dans un jeu de données
Pour modifier une ligne existante dans une DataTable, vous devez localiser la DataRow concernée, puis attribuer les valeurs mises à jour aux colonnes souhaitées.
Si vous ne connaissez pas l’index de la ligne à modifier, utilisez la méthode FindBy pour effectuer une recherche par clé primaire :
NorthwindDataSet.CustomersRow customersRow =
northwindDataSet1.Customers.FindByCustomerID("ALFKI");
customersRow.CompanyName = "Updated Company Name";
customersRow.City = "Seattle";
Si vous connaissez l’index de ligne, procédez comme suit pour accéder à la ligne et la modifier :
northwindDataSet1.Customers[4].CompanyName = "Updated Company Name";
northwindDataSet1.Customers[4].City = "Seattle";
Insertion de nouvelles lignes dans un jeu de données
Les applications qui utilisent des contrôles liés aux données ajoutent généralement de nouveaux enregistrements à l’aide du bouton Ajouter sur un contrôle BindingNavigator.
Pour ajouter manuellement de nouveaux enregistrements à un jeu de données, créez une ligne de données en appelant la méthode sur la table de données. Ensuite, ajoutez cette ligne à la collection DataRow (Rows) de la DataTable :
NorthwindDataSet.CustomersRow newCustomersRow =
northwindDataSet1.Customers.NewCustomersRow();
newCustomersRow.CustomerID = "ALFKI";
newCustomersRow.CompanyName = "Alfreds Futterkiste";
northwindDataSet1.Customers.Rows.Add(newCustomersRow);
Dans le but de conserver les informations dont le jeu de données a besoin pour envoyer des mises à jour à la source de données, utilisez la méthode Delete pour supprimer des lignes dans une table de données. Par exemple, si votre application utilise un adaptateur de table (ou DataAdapter), la méthode Update de l’adaptateur de table supprime les lignes de la base de données dont la valeur RowState est Deleted.
Si votre application n’a pas besoin de renvoyer les mises à jour à une source de données, il est possible de supprimer des enregistrements en accédant directement à la collection de lignes de données (Remove).
Suppression des enregistrements d’une table de données
Appelez la méthode Delete d’une DataRow.
Cette méthode ne supprime pas physiquement l’enregistrement. Elle le marque simplement comme devant être supprimé.
Notes
Si vous récupérez la propriété Count d’une DataRowCollection, le nombre résultant inclut les enregistrements qui ont été marqués comme devant être supprimés. Pour obtenir un nombre précis d’enregistrements sans marque de suppression, vous pouvez boucler dans la collection en examinant la propriété RowState de chaque enregistrement (les enregistrements marqués pour suppression ont un RowState de valeur Deleted). Il est également possible de créer une vue de données d’un jeu de données qui filtre les lignes en fonction de leur état, puis de récupérer la propriété Count à partir de là.
L’exemple suivant montre comment appeler la méthode Delete pour marquer la première ligne de la table Customers comme supprimée :
Vérification de la présence de lignes modifiées
Lorsque des modifications sont apportées aux enregistrements d’un jeu de données, les informations relatives à ces modifications sont stockées jusqu’à ce qu’elles soient validées. Vous validez les modifications lorsque vous appelez la méthode AcceptChanges d’un jeu de données ou d’une table de données, ou bien la méthode Update d’un adaptateur de table ou de données.
Le suivi des modifications s’effectue de deux façons sur chaque ligne de données :
Chaque ligne de données contient des informations relatives à son RowState (par exemple Added, Modified, Deleted ou Unchanged).
Chaque ligne de données modifiée contient plusieurs versions (DataRowVersion) : la version d’origine (avant les modifications) et la version actuelle (après les modifications). Pendant la période où une modification est en attente (le moment où vous pouvez répondre à l’événement RowChanging), une troisième version (la version proposée) est également disponible.
La méthode HasChanges d’un jeu de données retourne true si des modifications ont été apportées au jeu de données. Une fois que vous avez déterminé qu’il existe des lignes modifiées, vous pouvez appeler la méthode GetChanges d’un DataSet ou d’une DataTable pour retourner l’ensemble des lignes modifiées.
Vérification de la présence de modifications apportées à des lignes
- Appelez la méthode HasChanges d’un jeu de données pour vérifier si des lignes ont été modifiées.
L’exemple suivant montre comment vérifier la valeur de retour de la méthode HasChanges pour détecter si des lignes ont été modifiées dans un jeu de données nommé NorthwindDataset1 :
if (northwindDataSet1.HasChanges())
{
// Changed rows were detected, add appropriate code.
}
else
{
// No changed rows were detected, add appropriate code.
}
Identification du type de modifications
Vous pouvez également vérifier le type de modifications apportées à un jeu de données en passant une valeur de l’énumération DataRowState à la méthode HasChanges.
Identification du type de modifications apportées à une ligne
- Passez une valeur DataRowState à la méthode HasChanges.
L'exemple suivant montre comment vérifier un jeu de données nommé NorthwindDataset1 pour déterminer si de nouvelles lignes y ont été ajoutées :
if (northwindDataSet1.HasChanges(DataRowState.Added))
{
// New rows have been added to the dataset, add appropriate code.
}
else
{
// No new rows have been added to the dataset, add appropriate code.
}
Localisation des lignes comportant des erreurs
Lorsque vous utilisez des colonnes et des lignes de données individuelles, il se peut que vous rencontriez des erreurs. Vérifiez la propriété HasErrors pour déterminer s'il existe des erreurs dans un DataSet, une DataTable ou une DataRow.
Vérifiez la propriété
HasErrorspour voir s'il existe des erreurs dans le jeu de données.Si la propriété
HasErrorsa la valeurtrue, bouclez sur les collections de tables, puis sur les lignes, pour rechercher la ligne comportant l’erreur.
private void FindErrors()
{
if (dataSet1.HasErrors)
{
foreach (DataTable table in dataSet1.Tables)
{
if (table.HasErrors)
{
foreach (DataRow row in table.Rows)
{
if (row.HasErrors)
{
// Process error here.
}
}
}
}
}
}