Partager via

Valider les données dans les jeux de données dans les applications .NET Framework

Remarque

La DataSet classe et les classes associées sont des technologies .NET Framework héritées du début des années 2000 qui 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. Les technologies sont particulièrement utiles pour les applications qui permettent aux utilisateurs de modifier les données et de conserver les modifications apportées à la base de données. Bien que les jeux de données soient une technologie éprouvée, l’approche recommandée pour les nouvelles applications .NET consiste à utiliser Entity Framework Core. Entity Framework offre un moyen plus naturel d’utiliser des données tabulaires en tant que modèles objet et dispose d’une interface de programmation plus simple.

La validation des données est le processus de confirmation que les valeurs entrées dans des objets de données sont conformes aux contraintes dans le schéma d’un jeu de données. Le processus de validation confirme également que ces valeurs suivent les règles établies pour votre application. Il est recommandé de valider les données avant d’envoyer des mises à jour à la base de données sous-jacente. Cela réduit les erreurs ainsi que le nombre potentiel d’allers-retours entre une application et la base de données.

Vous pouvez confirmer que les données écrites dans un jeu de données sont valides en créant des vérifications de validation dans le jeu de données lui-même. Le jeu de données peut vérifier les données, quelle que soit la façon dont la mise à jour est effectuée, que ce soit directement par des contrôles dans un formulaire, dans un composant ou d’une autre manière. Étant donné que le jeu de données fait partie de votre application (contrairement au back-end de base de données), il s’agit d’un emplacement logique pour générer une validation spécifique à l’application.

Le meilleur endroit pour ajouter la validation à votre application se trouve dans le fichier de classe partielle du jeu de données. Dans Visual Basic ou Visual C#, ouvrez le Concepteur de jeux de données et double-cliquez sur la colonne ou la table pour laquelle vous souhaitez créer la validation. Cette action ouvre le fichier de code, où vous pouvez créer un ColumnChanging ou RowChanging gestionnaire d’événements.

private static void OnColumnChanging(object sender, DataColumnChangeEventArgs e)
{

}

Valider des données

La validation au sein d’un jeu de données s’effectue de la manière suivante :

Plusieurs événements sont déclenchés par l’objet DataTable lorsqu’une modification se produit dans un enregistrement :

  • Les événements ColumnChanging et ColumnChanged sont déclenchés pendant et après chaque modification de chaque colonne individuelle. L’événement ColumnChanging est utile lorsque vous souhaitez valider les modifications dans des colonnes spécifiques. Les informations sur la modification proposée sont passées en argument de l’événement.
  • Les événements RowChanging et RowChanged sont déclenchés pendant et après chaque modification de ligne. L’événement RowChanging est plus général. Elle indique qu’une modification se produit quelque part dans la ligne, mais que vous ne savez pas quelle colonne a changé.

Par défaut, chaque modification apportée à une colonne déclenche quatre événements. Le premier événement est celui des ColumnChanging et ColumnChanged, qui concernent la colonne spécifique en cours de modification. Ensuite, voici les événements RowChanging et RowChanged. Si plusieurs modifications sont apportées à la ligne, les événements sont déclenchés pour chacune d’elles.

Remarque

La méthode BeginEdit de la ligne de données désactive les événements RowChanging et RowChanged après chaque modification de colonne. Dans ce cas, l’événement n’est pas déclenché tant que la méthode EndEdit n’a pas été appelée, lorsque les événements RowChanging et RowChanged ne sont déclenchés qu’une seule fois. Pour plus d’informations, consultez Désactiver les contraintes lors du remplissage d’un jeu de données.

L’événement que vous choisissez dépend de la précision à laquelle vous souhaitez que la validation soit. S’il est important que vous interceptiez une erreur immédiatement lorsqu’une colonne change, générez la validation à l’aide de l’événement ColumnChanging . Sinon, utilisez l’événement RowChanging , ce qui peut entraîner l’interception de plusieurs erreurs à la fois. En outre, si vos données sont structurées afin que la valeur d’une colonne soit validée en fonction du contenu d’une autre colonne, effectuez votre validation pendant l’événement RowChanging .

Lorsque des enregistrements sont mis à jour, l’objet DataTable déclenche des événements auxquels vous pouvez répondre à mesure que des modifications se produisent et une fois les modifications effectuées.

Si votre application utilise un jeu de données typé, vous pouvez créer des gestionnaires d’événements fortement typés. Cela ajoute quatre événements typés supplémentaires pour lesquels vous pouvez créer des gestionnaires : dataTableNameRowChanging, , dataTableNameRowChanged, dataTableNameRowDeletinget dataTableNameRowDeleted. Ces gestionnaires d’événements typés passent un argument qui inclut les noms de colonnes de votre table qui facilitent l’écriture et la lecture du code.

Événements de mise à jour des données

Événement Descriptif
ColumnChanging La valeur d’une colonne est modifiée. L’événement vous transmet la ligne et la colonne, ainsi que la nouvelle valeur proposée.
ColumnChanged La valeur d’une colonne a été modifiée. L’événement vous transmet la ligne et la colonne, ainsi que la valeur proposée.
RowChanging Les modifications apportées à un DataRow objet sont sur le point d’être validées dans le jeu de données. Si vous n’avez pas appelé la BeginEdit méthode, l’événement RowChanging est déclenché pour chaque modification apportée à une colonne immédiatement une fois l’événement ColumnChanging déclenché. Si vous avez appelé BeginEdit avant d’apporter des modifications, l’événement RowChanging est déclenché uniquement lorsque vous appelez la EndEdit méthode.

L’événement vous transmet la ligne, ainsi qu’une valeur indiquant le type d’action (modification, insertion, etc.) en cours d’exécution.
RowChanged Une ligne a été modifiée. L'événement vous transmet la ligne, ainsi qu'une valeur indiquant le type d'action (modification, insertion, etc.) qui est effectuée.
RowDeleting Une ligne est supprimée. L’événement vous transmet la ligne, ainsi qu’une valeur indiquant le type d’action (suppression) en cours d’exécution.
RowDeleted Une ligne a été supprimée. L’événement vous transmet la ligne, ainsi qu’une valeur indiquant le type d’action (suppression) en cours d’exécution.

Les événements ColumnChanging, RowChanging et RowDeleting sont déclenchés pendant le processus de mise à jour. Vous pouvez utiliser ces événements pour valider les données ou effectuer d’autres types de traitement. Étant donné que la mise à jour est en cours pendant ces événements, vous pouvez l’annuler en levant une exception, ce qui empêche la mise à jour de se terminer.

Les événements ColumnChanged, RowChanged et RowDeleted sont des événements de notification déclenchés lorsque la mise à jour a réussi. Ces événements sont utiles lorsque vous souhaitez effectuer d’autres actions en fonction d’une mise à jour réussie.

Valider les données pendant les modifications de colonne

Remarque

Le Concepteur de jeux de données crée une classe partielle dans laquelle la logique de validation peut être ajoutée à un jeu de données. Le jeu de données généré par le concepteur ne supprime ni ne modifie aucun code dans la classe partielle.

Vous pouvez valider les données lorsque la valeur d’une colonne de données change en répondant à l’événement ColumnChanging . Lorsqu’il est déclenché, cet événement transmet un argument d’événement (ProposedValue) qui contient la valeur proposée pour la colonne active. En fonction du contenu de e.ProposedValue, vous pouvez :

  • Acceptez la valeur proposée en ne faisant rien.

  • Refusez la valeur proposée en définissant l’erreur de colonne (SetColumnError) à partir du gestionnaire d’événements à modification de colonne.

  • Utilisez éventuellement un ErrorProvider contrôle pour afficher un message d’erreur à l’utilisateur. Pour plus d’informations, consultez ErrorProvider, composant.

La validation peut également être effectuée pendant l’événement RowChanging .

Valider les données pendant les modifications de ligne

Vous pouvez écrire du code pour vérifier que chaque colonne que vous souhaitez valider contient des données répondant aux exigences de votre application. Pour ce faire, définissez la colonne pour indiquer qu’elle contient une erreur si une valeur proposée est inacceptable. Les exemples suivants définissent une erreur de colonne lorsque la Quantity colonne est de 0 ou moins. Les gestionnaires d’événements de modification de ligne se présentent comme dans les exemples suivants.

Pour valider les données lorsqu’une ligne change (Visual Basic)

  1. Ouvrez votre jeu de données dans le concepteur de jeux de données . Pour plus d’informations, consultez Procédure pas à pas : création d’un jeu de données dans le Concepteur de jeux de données.

  2. Double-cliquez sur la barre de titre de la table à valider. Cette action crée automatiquement le RowChanging gestionnaire d’événements du DataTable fichier de classe partielle du jeu de données.

    Conseil / Astuce

    Double-cliquez à gauche du nom de la table pour créer le gestionnaire d’événements à modification de ligne. Si vous double-cliquez sur le nom de la table, vous pouvez le modifier.

    Private Sub Order_DetailsDataTable_Order_DetailsRowChanging(
    ByVal sender As System.Object, 
    ByVal e As Order_DetailsRowChangeEvent
  ) Handles Me.Order_DetailsRowChanging

    If CType(e.Row.Quantity, Short) <= 0 Then
        e.Row.SetColumnError("Quantity", "Quantity must be greater than 0")
    Else
        e.Row.SetColumnError("Quantity", "")
    End If
End Sub

Pour valider les données lorsqu’une ligne change (C#)

  1. Ouvrez votre jeu de données dans le concepteur de jeux de données . Pour plus d’informations, consultez Procédure pas à pas : création d’un jeu de données dans le Concepteur de jeux de données.

  2. Double-cliquez sur la barre de titre de la table à valider. Cette action crée un fichier de classe partielle pour le DataTable.

    Remarque

    Le Concepteur de jeux de données ne crée pas automatiquement un gestionnaire d’événements pour l’événement RowChanging . Vous devez créer une méthode pour gérer l’événement RowChanging et exécuter du code pour raccorder l’événement dans la méthode d’initialisation de la table.

  3. Copiez le code suivant dans la classe partielle :

    public override void EndInit()
{
    base.EndInit();
    Order_DetailsRowChanging += TestRowChangeEvent;
}

public void TestRowChangeEvent(object sender, Order_DetailsRowChangeEvent e)
{
    if ((short)e.Row.Quantity <= 0)
    {
        e.Row.SetColumnError("Quantity", "Quantity must be greater than 0");
    }
    else
    {
        e.Row.SetColumnError("Quantity", "");
    }
}

Récupération des lignes modifiées

Chaque ligne d’une table de données a une RowState propriété qui effectue le suivi de l’état actuel de cette ligne à l’aide des valeurs de l’énumération DataRowState . Vous pouvez extraire des lignes modifiées à partir d’un jeu de données ou d’une table de données en appelant la méthode GetChanges d’un DataSet ou d’un DataTable. Vous pouvez vérifier que les modifications existent avant l’appel GetChanges en appelant la HasChanges méthode d’un jeu de données.

Remarque

Une fois que vous avez validée les modifications apportées à un jeu de données ou à une table de données (en appelant la AcceptChanges méthode), la GetChanges méthode ne retourne aucune donnée. Si votre application doit traiter les lignes modifiées, vous devez traiter les modifications avant d’appeler la AcceptChanges méthode.

L’appel de la GetChanges méthode d’un jeu de données ou d’une table de données retourne un nouveau jeu de données ou une table de données qui contient uniquement les enregistrements qui ont été modifiés. Si vous souhaitez obtenir des enregistrements spécifiques ( par exemple, seuls les nouveaux enregistrements ou seuls les enregistrements modifiés) vous pouvez transmettre une valeur de l’énumération DataRowState en tant que paramètre à la GetChanges méthode.

Utilisez l’énumération DataRowVersion pour accéder aux différentes versions d’une ligne (par exemple, les valeurs d’origine qui se trouvaient dans une ligne avant de le traiter).

Pour obtenir tous les enregistrements modifiés d’un jeu de données

  • Appelez la GetChanges méthode d’un jeu de données.

    L’exemple suivant crée un jeu de données appelé changedRecords et le remplit avec tous les enregistrements modifiés d’un autre jeu de données appelé dataSet1.

    DataSet changedRecords = dataSet1.GetChanges();

Pour obtenir tous les enregistrements modifiés d’une table de données

  • Appelez la GetChanges méthode d’un DataTable.

    L’exemple suivant crée une table de données appelée changedRecordsTable et la remplit avec tous les enregistrements modifiés d’une autre table de données appelée dataTable1.

    DataTable changedRecordsTable = dataTable1.GetChanges();

Pour obtenir tous les enregistrements qui ont un état de ligne spécifique

  • Appelez la GetChanges méthode d’un jeu de données ou d’une table de données et transmettez une DataRowState valeur d’énumération en tant qu’argument.

    L’exemple suivant montre comment créer un jeu de données appelé addedRecords et le remplir uniquement avec les enregistrements qui ont été ajoutés au dataSet1 jeu de données.

    DataSet addedRecords = dataSet1.GetChanges(DataRowState.Added);

    L’exemple suivant montre comment retourner tous les enregistrements récemment ajoutés à la Customers table :

    private NorthwindDataSet.CustomersDataTable GetNewRecords()
{
    return (NorthwindDataSet.CustomersDataTable)
        northwindDataSet1.Customers.GetChanges(DataRowState.Added);
}

Accéder à la version d’origine d’un DataRow

Lorsque des modifications sont apportées aux lignes de données, le jeu de données conserve les versions d’origine (Original) et nouvelles (Current) de la ligne. Par exemple, avant d’appeler la AcceptChanges méthode, votre application peut accéder aux différentes versions d’un enregistrement (comme défini dans l’énumération DataRowVersion ) et traiter les modifications en conséquence.

Remarque

Différentes versions d’une ligne n’existent qu’une fois qu’elle a été modifiée et avant que la AcceptChanges méthode ait été appelée. Une fois la AcceptChanges méthode appelée, les versions actuelles et d’origine sont identiques.

La transmission de la DataRowVersion valeur avec l’index de colonne (ou le nom de colonne sous forme de chaîne) retourne la valeur de la version de ligne particulière de cette colonne. La colonne modifiée est identifiée pendant l'événement ColumnChanging et l'événement ColumnChanged. C'est un bon moment pour examiner les différentes versions de ligne à des fins de validation. Toutefois, si vous avez suspendu temporairement des contraintes, ces événements ne seront pas déclenchés et vous devrez identifier par programmation les colonnes qui ont changé. Pour ce faire, effectuez une itération dans la Columns collection et comparez les différentes DataRowVersion valeurs.

Pour obtenir la version d’origine d’un enregistrement

  • Accédez à la valeur d’une colonne en transmettant la DataRowVersion de la ligne que vous souhaitez retourner.

    L’exemple suivant montre comment utiliser une DataRowVersion valeur pour obtenir la valeur d’origine d’un CompanyName champ dans un DataRow:

    string originalCompanyName;
originalCompanyName = northwindDataSet1.Customers[0]
    ["CompanyName", DataRowVersion.Original].ToString();

Accéder à la version actuelle d’un DataRow

Pour obtenir la version actuelle d’un enregistrement

  • Accédez à la valeur d’une colonne, puis ajoutez un paramètre à l’index qui indique la version d’une ligne à retourner.

    L’exemple suivant montre comment utiliser une DataRowVersion valeur pour obtenir la valeur actuelle d’un CompanyName champ dans un DataRow:

    string currentCompanyName;
currentCompanyName = northwindDataSet1.Customers[0]
    ["CompanyName", DataRowVersion.Current].ToString();

Contenu connexe

  • Last updated on