19.3 Classes ADO.NET pour l’accès aux données.
La classe DataSet a déjà été évoquée. Elle est au centre de la plupart des opérations que vous entreprendrez avec ADO.NET. Elle ne fonctionne pas seule, toutefois. Dans cette section, nous vous présentons quelques classes, y compris DataSet, qui mettent à disposition les bases de la fonctionnalité d’ ADO.NET. La plupart des classes de Visual Basic .NET en relation avec les données font partie de l’espace de noms System.Data.
Les Classes SqlConnection et OleDbConnection
Avant de pouvoir faire quoi que ce soit avec une source de données, vous devez établir une connexion avec elle. C’est le rôle des classes SqlConnection et OleDbConnection. Les deux effectuent la même tâche avec la différence suivante :
- La classe SqlConnection est utilisée pour créer une connexion à des bases de données Microsoft SQL Server (version 7 et ultérieure). Elle fait partie de l’espace de noms System.Data.SqlClient.
- La classe OleDbConnection est utilisée pour créer une connexion à des bases de données prises en charge par la technologie OLE DB En font partie les bases de données Microsoft Access, Oracle, des produits SQL de tiers et les serveurs SQL version 6.5 et antérieurs.
Dans bien des cas, la source de données que vous utilisez dictera le choix entre l’une ou l’autre classe. Dans certains cas, la source de données prend en charge les deux classes et le choix dépendra de certains facteurs qui ne sont plus du ressort de cet ouvrage. Vous trouverez des informations dans la documentation .NET.
Au cœur de la mise en œuvre de l’un ou l’autre de ces types de connexion se trouve la chaîne de connexion, une propriété texte qui spécifie tous les aspects de la connexion, y compris la source de données et d’autres détails tels que les informations de sécurité, le mot de passe (si nécessaire) et le nom du serveur. La chaîne de connexion est souvent passée au constructeur comme ci-après :
Dim sqlCon As New SqlConnection(ConString)
L’instance peut aussi être créée séparément, le chaîne de connexion étant passée à la propriété ConnectionString :
Dim sqlCon As New SqlConnection() …
sqlCon.ConnectionString = ConString
La syntaxe est la même pour la classe OleDbConnection. Lorsque la chaîne de connexion a été définie, l’étape suivante est l’appel de la méthode Open(), qui ouvre la connexion. Il n’y a pas de valeur renvoyée pour cette méthode. Tout problème survenant à l’ouverture de la connexion est signalé au moyen d’une exception InvalidOperationException ou SqlException (ou LoeDbException, pour la classe OleDbConnection).
Si vous n’utilisez plus la connexion, elle doit être fermée à l’aide de la méthode Close(). C’est important pour bénéficier de l’avantage de l’architecture déconnectée d’ADO .NET. Le fait
que la référence à la connexion sorte de la portée ne signifie pas qu’elle soit fermée automatiquement. Vous devez la fermer explicitement dans le code. Voici un exemple concret de création, d’ouverture et de fermeture d’une connexion :
Dim conStr As String
ConStr = « data source=BETA-BOX ; initial catalog=Northwind ; » ConStr &= “user id=sa;password=redwine;”
Dim sqlCon As New SqlConnection(ConStr) sqlCon.Open()
‘
‘ Code à utiliser dans la connexion. ‘
sqlCon.Close()
CREER DES CHAINES DE CONNEXION
Créer une connexion semble très facile jusqu’à présent. La difficulté réside dans la création d’une chaîne de connexion adaptée précisément à votre situation. Il n’est malheureusement pas possible d’expliquer tous les détails concernant les chaînes de connexion, car les situations possibles sont innombrables puisqu’elles dépendent à la fois des possibilités de la source de données utilisée, de la sécurité et des besoins de votre application. La chaîne de connexion utilisée dans l’exemple précédent est assez simple. Elle comporte quatre parties : data source=BETA-BOX ;
Cette partie de la chaîne de connexion identifie le serveur SQL auquel le programme sera connecté. Dans ce cas, il est identifié par le nom de l’ordinateur sur lequel il s’exécute, BETA-BOX.
initial catalog=Northwind ;
Cette section identifie la base de données spécifique à utiliser. Plusieurs sources de données peuvent en effet être actives au même moment sur le serveur SQL, et il est donc nécessaire de préciser à laquelle vous souhaitez vous connecter.
user id=sa ;
Cette partie de la chaîne de connexion identifie l’utilisateur dont le compte sera utilisé pour la connexion au serveur.
password=victoria ;
Cette dernière partie spécifie le mot de passe de l’utilisateur sa. En fonction du paramétrage du serveur, un mot de passe sera requis à cet endroit ou devra être saisi à un autre moment (ailleurs que dans la chaîne de connexion).
Il y a trois approches différentes lorsqu’il s’agit de créer une chaîne de connexion pour votre application :
- Si la source de données est une de celles avec lesquelles vous avez déjà travaillé ou si vous êtes impliqué dans son administration, vous possédez probablement déjà toutes les informations nécessaires pour créer la chaîne de connexion.
- Si vous n’êtes pas impliqué dans l’administration de la source de données, trouvez une des personnes qui est chargée de cette tâche et demandez-lui les infos dont vous avez besoin.
- Vous pouvez recourir aux outils de Visual Studio pour créer des connexions à des bases de données, comme cela est décrit plus loin dans ce chapitre.
Les Classes SqlAdapter et OleDbAdapter
Que faire après que vous avez créée une connexion à votre source de données ? Pour garnie un DataSet avec les données requises, vous utiliserez une carte (un adaptateur) de données. Il existe pour cela deux classes : SqlDataAdapter à utiliser avec des objets SqlConnection et OleDbDataAdapter à utiliser avec des objets OleDbConnection. Représentez-vous une carte de données comme une passerelle entre la source de données (la connexion) et votre DataSet. Cette construction est illustrée par la figure suivante :
DataSet---Carte de données---Connexion aux données
Fig 19.3 : Une carte de données sert de passerelle entre une connexion et un objet DataSet Pour utiliser une carte de données, créez une instruction SQL (Structured Query Language) décrivant les données souhaitées (SQL sera expliqué plus loin dans ce chapitre). Après avoir instancié la carte de données, passez-lui une commande qui identifie la connexion à utiliser, ainsi que l’instruction SQL à appliquer. La commande est encapsulée dans un objet SqlCommand, comme ci-après :
Dim myCmd As New SqlCommand(sql, connection)
sql est l’instruction SQL et connection est une référence à l’objet connexion à utiliser . L’objet SqlCommand est associé avec la carte de données par le biais de la propriété SelectCommand.
Dim adap As New SqlDataAdapter() adap.SelectCommand = myCmd
La syntaxe est la même pour la classe OleDbDataAdapter. Habituellement, les deux étapes sont contractées en une seule, comme ci-après :
adap.SelectCommand = New SqlCommand(sql, connection)
Appelez ensuite la méthode Fill() dela carte de données en lui passant une référence à l’objet DataSet où vous voulez placer les données. La méthode Fill() reçoit également un argument facultatif de type chaîne de caractères spécifiant le nom qui sera affecté à la nouvelle table dans le DataSet. Si cet argument est omis, un nom par défaut sera utilisé. Le fragment de code
suivant montre l’ensemble de ces étapes. Nous supposons que sqlCon est une référence à un objet SqlConnection déjà ouvert.
sqlAdapter = New SqlDataAdapter()
sqlAdapter.SelectCommand = New SqlCommand (“ select* from customers”,sqlCon) ‘ créer un dataset appelé Customers.
ds = New DataSet(« Customer
‘ Remplir le dataset, en affectant le nom ‘ My Customers à la nouvelle table. sqlAdapter.Fill(ds, «My Customers »)
Après l’exécution de ce code, le DataSet ds contient les données de la source de données affectée à sqlCon, qui correspondent à l’intruction select * from customers. Vous pourriez répéter ce processus et ajouter d’autres données ) l’objet DataSet. Chaque opération Fill crée une autre table dans le DataSet. Vous pouvez également définir des relations entre les tables, comme nous le verrons plus tard dans ce chapitre.
La classe DataSet
Un objet Dataset met à disposition une copie en mémoire des données extraites de la source de données. Dans le cas de figure le plus simple, comme celui que nous avons vu jusqu’à présent, un DataSet contient une seule table. La classe DataSet peut cependant contenir aussi des tables multiples, ainsi que les définitions de relations entre ces tables. Quel que soit le cas de figure, comment travailler avec les données, une fois que vous avez créé le DataSet contenant celles dont votre programme a besoin ?
Les tables dans le DataSet sont contenues dans une collection à laquelle vous accédez par la propriété Tables. Utilisez la propriété Tables.Count pour déterminer le nombre de tables contenues dans le DataSet. Ensuite, utilisez la méthode Tables.Item() pour obtenir une référence à une table spécifique.
ds.Tables.Item(table)
Table est une valeur entière indiquant la position de la table (numérotées à partir de 0) dans la collection ou une chaîne de caractères spécifiant le nom de la table. La méthode renvoie une valeur nulle si la table demandée n’existe pas. Vous pouvez également parcourir toutes les tables dans la collection à l’aide d’une boucle For Each…Next. Chaque table dans un DataSet est représentée par un objet DataTable. Ce code montre comment obtenir une référence à la table nommée Sales dans le DataSet ds :
Dim dt As DataTable
dt = ds.Tables.Item(« Sales ») INFO
La propriété Item en tant qu’indexeur.
Un grand nombre des classes ADO possèdent la propriété Item, qui permet de retrouver un élément spécifique dans une collection en fonction de sa position ou, dans certains cas, de son nom. Tables.Item() en est un exemple. Dans presque tous les cas, la propriété Item est l’indexeur de la collection. Cela signifie que le nom de la propriété peut être omis. Ainsi, cette ligne de code
ds.Tables.Item(« Sales ») est équivalente à celle-ci : ds.Tables(« Sales »)
Cela rapelle le fonctionnement des propriétés par défaut des précédentes versions de Visual Basic. Dans les exemples de code de ce chapitre, nous spécifions toujours explicitement le nom,de la propriété par souci de clarté, mais si vous rencontrez du code où le nom de propriété est absent, vous comprendrez désormais pourquoi.
Ce code parcourt toutes les tables dans le DataSet ds : Dim dt As DataTable
For Each dt In ds.Tables
‘Faire quelques chose avec chaque table, ici. Next
Chaque table se compose de lignes (les enregistrements dans la table) et de colonnes (les champs). Pour une table donnée, vous accédez aux lignes et colonnes au moyen des collections Rows et Columns.
- La propriété Columns renvoie un type DataColumnCollection qui, à son tour, contient un type DataColumn pour chaque colonne de la table.
- La propriété Rows renvoie un type DataRowCollection qui, à son tour, contient un type DataRow pour chaque ligne de la table.
INFO
Contraintes et relations
Outre les lignes et colonnes, un DataSet peut contenir des contraintes et des relations. Une contrainte est associée avec une table spécifique et définit une règle ou restriction pour les données dans une colonne particulière, par exemple pour imposer que la colonne Prix contienne une valeur supérieure à 0 ou que la colonne Code postal contienne une chaîne de caractères de cinq caractères exactement. Une relation définit les liens entre deux tables dans le DataSet, par exemple pour spécifier que la table des articles en stock et la table des fabricants sont liées par le champ Nom du fabricant. Les relations parents et enfants sont toutes deux prises en charge.
La structure d’un objet DataSet est représentée sur la figure suivante. Le tableau ci-après montre quelques façons d’utiliser ces références pour travailler avec les lignes et les colonnes. Dans ce tableau, dt représente une référence à un objet DataSet.
Fig 19.4 : Structure d’un objet DataSet – Les ellipses représentent des collections et les rectangles des objets
DataSet Tables Tables de données Lignes Ligne de données Colonnes Colonnes de données Contraintes Contrainte Relations
Relations entre les données
TAB 19.1 : Utilisation des collections Columns et Rows dans l’objet DataTable Syntaxe Description
dt.Columns.Count Renvoie le nombre de colonnes ou lignes d’une table dt.Rows.Count
dt.Columns.Item(col) Renvoie une type DataColumn pour la colonne spécifiée, col est un entier spécifiant la position (numérotée à partir de 0) de la colonne ou une chaîne de caractères indiquant le nom de la colonne. La méthode renvoie une valeur nulle si la colonne n’existe pas.
dt.Rows.Item(row) Renvoie une type DataRow pour la ligne spécifiée, row est une valeur entière spécifiant la position (numérotée à partir de 0) de la ligne ou une chaîne de caractères indiquant le nom de la ligne. La méthode renvoie une valeur nulle si la ligne n’existe pas.
dt.Rows.Contains Renvoie True si une ligne de la table contient la valeur val dans un (val) champ de clé primaire.
dt.Rows.Find(val) Renvoie une référence à un objet DataRow contenant la valeur de clé primaire val ou une référence nulle (Nothing) si aucune ligne
correspondante n’est trouvée.
La classe DataSet et ses classes liées DataColumn et DataRow sont très flexibles et puissantes. Elles sont donc inévitablement assez complexes, avec une longue liste de propriétés et méthodes. Plutôt que de remplir le chapitre avec des tableaux de références, nous avons préféré opter pour une approche centrée sur les tâches. Nous ne vous présenterons donc pas tous les membres de cette classe, mais nous vous montrerons comment effectuer un certain nombre de tâches de base avec un objet DataSet.
LIRE DES DONNEES DANS UN CHAMP
Une donnée isolée dans une table, par exemple le numéro de téléphone d’une personne dans un carnet d’adresses, est contenue à la fois dans une ligne (enregistrement) et dans une colonne (champ) spécifiques. Pour accéder à cette donnée, vous devez donc identifier sa ligne
et sa colonne. Pour cela, vous devez obtenir d’abord une référence à la ligne, puis spécifier la colonne. Utilisez la propriété Item() de l’objet DataRow à cet effet. Il existe plusieurs surcharges pour cette propriété (dr est une référence à la ligne) :
dr.Item(name) ‘ name est le nom de la colonne.
dr.Item(index) ‘index est la position (à partir de 0) dans la colonne.
dr.Item(DC) ‘ DC est un type DataColumn référençant la colonne.
Le type renvoyé par cette propriété est Object. Il permet de gérer tout type de donnée pouvant être stocké dans la table. Voici quelques exemples. Pour le premier échantillon de code, ds est une référence à un objet DataSet qui contient une table nommée MyClients. Cette table contient des colonnes nommées CompanyName et ContactName. Ce code parcourt toutes les lignes de la table, extrait les données dans ces deux colonnes et les combine en une chaîne de caractères qui est finalement affichée dans un contrôle TextBox.
Dim dr As DataRow Dim buf As String
For Each dr In ds.Tables(“MyClients”).Rows
buf &= dr.Item(“CompanyName”) & “:”& dr.Item(“ContactName”) _ & ControlChars.CrLF
Next
TextBox1.Text = buf
L’exemple suivant montre comment parcourir à l’aide d’une boucle toutes les lignes et colonnes d’une table.
Dim dr As DataRow Dim dc As DataColumn
For Each dr In ds.Tables(“MyClients”).Rows
For Each dc In ds.Tables(“MyClients”).Columns
‘A chaque répétition de la boucle, dr.Item(dc) renvoie la donnée continue dans la colonne et dans la ligne en cours.
Next Next
MODIFIER DES DONNEES DANS UN CHAMP
Modifier des données est quasiment l’inverse de la lecture de données. Vous devez localiser la ligne et la colonne dont les données doivent être modifiées, puis définir la valeur. Lorsque vous modifiez des données dans un DataSet, les modifications sont prises en compte dans le DataSet, mais elles ne sont pas transférées automatiquement dans la source de données. Pour enregistrer les modifications durablement, suivez les consignes de la section « Enregistrer les modifications » plus loin dans ce chapitre.
Nous vous montrerons un exemple de code servant à modifier des données dans la section suivante.
RECHERCHER DES ENREGISTREMENTS
Pour un nombre important d’opérations que vous aurez à effectuer avec des bases de données, vous devrez d’abord sélectionner ou localiser des enregistrements spécifiques dans la base de données. Pour une liste de diffusion de courrier électronique, par exemple, vous voudrez éventuellement extraire toutes les adresses en France pour un envoi spécifique. Dans un catalogue de produits, vous pouvez mettre à jour le prix d’un article. Dans une base de données d’employés, vous pouvez modifier l’adresse d’un collaborateur. Toutes ces tâches impliquent que vous trouviez le ou les enregistrements concernés avant d’intervenir sur leur contenu.
Souvent, la recherche d’enregistrements spécifiques se fait à un stade intérieur, lors de la création du DataSet. Lorsque vous définissez la carte de données qui sert à transférer les données de la source vers le DataSet, vous pouvez rédiger votre instruction SQL de manière à extraire uniquement les enregistrements dont vous avez besoin.
Il arrivera cependant que le DataSet ne contienne pas que les seules données qui vous intéressent. Dans ce cas, vous devez trouver par vous-même ces enregistrements. Si vous cherchez un enregistrement en fonction de la valeur de son champ de clé primaire, vous pouvez utiliser la méthode Find() de la collection Rows avec la syntaxe suivante (dt est une référence à l’objet DataTable dans lequel s’effectue la recherche) :
dt.Rows.Find(val)
val est la valeur recherchée. Cette méthode renvoie une référence à la ligne correspondante ou Nothing si aucune correspondance ne peut être trouvée. Etant donné que la méthode recherche dans le champ de clé primaire, vous êtes sûr qu’il y aura une correspondance au maximum. Si la talbe dans laquelle vous effectuez la recherche ne comporte pas de clé primaire, une exception System.Data.MissingPrimaryKeyException est générée.
Le code suivant montre comment rechercher un enregistrement dans la table MyCustomers dont la clé primaire est BERGS. Si l’enregistrement est trouvé, la donnée contenue dans le champ CompanyName est affichée. Si aucun enregistrement correspondant ne peut être trouvé, c’est un message approprié qui s’affiche.
Dim dr As DataRow
dr = ds.Tables(« MyCustomers »).Rows.Find(« BERGS ») If dr Is Nothing Then
MsgBox(“L’enregistrement demandé n’a pas pu être trouvé”) Else
MsgBox(« Le nom de la compagnie est « & dr.Item(« CompanyName »)) End If
Il vous arrivera cependant aussi de rechercher des données qui ne sont pas dans le champ de clé primaire. Dans ce cas, vous devez parcourir tous les enregistrements de la table et examiner chacun pour vérifier s’il correspond au critère de recherche. Le code ci-après recherche un enregistrement dans la table dans lequel le champ CompanyName a la valeur « Consolidated Holdings ». Si l’enregistrement est trouvé, la valeur du champ ContactName de cet enregistrement est remplacé par « Mary Anderson ».
Dim dr As DataRow Dim ToBeFound As String Dim Found As Boolean = False
ToBeFound = “Consolidated Holdings”
For Each dr In ds.Tables(“MyCustomers”).Rows If dr.Item(“CompanyName”) = ToBeFound Then Found = True
dr.Item(“ContactName”) = “Mary Anderson” Exit For
End If Next
If found Then
MsgBox(“Le nom du contact chez “& ToBeFound &” a été mis à jour ») Else
MsgBox(« La compagnie “& ToBeFound &” n’a pas été trouvée ») End If
Lorsque vous cherchez des données dans des champs qui ne sont pas des clés primaires, vous devez prendre en compte le fait que ces données peuvent exister en plusieurs exemplaires. Selon la conception de la base de données, des champs peuvent en effet accepter ou non des doublons. Dans le présent exemple, il est possible que la table contienne plusieurs enregistrements, dans lesquels le champ CompanyName a la valeur “Consolidated Holdings”. SUPPRIMER DES LIGNES
Pour supprimer une ligne entière d’une table, procurez-vous d’abord une référence à la ligne, puis appelez la méthode Delete(). Le code suivant parcourt la table MyCustomers et supprime l’enregistrement dans lequel le champ CompanyName a la valeur « Ajax Widgets ».
Dim dr As DataRow Dim ToBeFound As String Dim Found As Boolean = False ToBeFound = “Ajax Widgets”
For Each dr In ds.Tables(“MyCustomers”).Rows If dr.Item(“CompanyName”) = ToBeFound Then dr.Delete()
Exit For End If Next
AJOUTER DES LIGNES
Pour créer une nouvelle ligne ayant le même schéma (les mêmes champs) que les lignes existantes de la table, appelez la méthode NewRow(). Cette méthode crée une nouvelle ligne
avec les mêmes champs que les autres lignes de la table et renvoie une référence à cette nouvelle ligne. Voici la syntaxe, dt étant une référence à la table :
Dim NewRow As DataRow
A ce stade, vous possédez une nouvelle ligne vide qui ne fait encore partie d’aucune table, mais qui existe de manière indépendante. Les étapes suivantes consistent à placer des données dans la ligne, puis à ajouter celle-ci à la table à l’aide de de la méthode Add() de la collection Rows. Supposons que le DataSet ds contienne une table nommée « MesAmis ». Cette table contient trois champs : Nom, Téléphone et Email. Le code suivant crée une nouvelle ligne avec ces trois champs, y place des données et ajoute cette ligne à la table :
Dim dt As DataTable Dim NewRow As Datarow dt = ds.Tables(“MesAmis”) NewRow = dt.NewRow()
NewRow.Item(“Nom”) = “Al Capone”
NewRow.Item(“Téléphone”) = “222-333-444” NewRow.Item(“Email”) = al@catraz.gov dt.Rows.Add(NewRow)
Différents incidents peuvent se produire lorsque vous appelez la méthode Add(). Les exceptions correspondantes sont listées dans le tableau suivant avec leurs explications. Tout code ajoutant de nouvelles lignes dans une table doit être protégé à l’intérieur d’un bloc Try… Catch.
Tab 19.2 : Les exceptions qui peuvent être générées par la méthode Add() Exception Survient si
ArgumentNullException La ligne que vous ajoutez est nulle
ArgumentException La ligne appartient déjà à cette table ou à une autre ConstraintException Les données dans la nouvelle ligne ne respectent pas les
contraintes de la table
NoNullAllowedException La nouvelle ligne contient la valeur Null dans un champ dont la propriété AllowDbNull a la valeur False
ENREGISTRER DES MODIFICATIONS
Si vous modifiez une table – modification de données existantes, suppression ou ajout de lignes – ces modifications sont temporaires. Vous devez demander explicitement à les rendre permanentes. Il y a deux niveaux d’enregistrement de modifications. Le premier est en relation avec la table spécifique avec laquelle vous travaillez. Lorsque vous modifiez une table, les modifications sont enregistrées, mais elles ne sont pas permanentes. Vous pouvez gérer ces modifications à l’aide des méthodes du tableau ci-après :
Tab 19.3 : Méthodes permettant d’intervenir sur les modifications effectuées dans une table Méthode Description
AcceptChanges() Valide toutes les modifications effectuées dans la table depuis sa Création ou depuis le dernier appel de AcceptChanges().
GetChanges() Fournit une copie de la table contenant toutes les modifications effectuées depuis sa création ou depuis le dernier appel de AcceptChanges(). RejectChanges() Rejette toutes les modifications effectuées dans la table depuis
sa création ou depuis le dernier appel de AcceptChanges(). La possibilité d’accepter ou de rejeter des modifications est importante lorsque vous devez gérer des modifications effectuées par lots. Si un utilisateur effectue des modifications dans l’inventaire du stock d’une compagnie, il est important que touts les changements soient validés avant d’utiliser la table pour d’autres opérations. Une table dont les changements ne seraient que partiellement validés causerait inévitablement des problèmes. Pour prévenir les effets d’une coupure de courant ou d’une interruption de la part de l’opérateur, le programme n’appelle pas AcceptChanges() avant d’être sûr que toutes les modifications souhaitées sont saisies.
Le deuxième niveau d’enregistrement est celui qui rend les modifications durables dans la source de données. Rappelez-vous que le DataSet n’est qu’une copie en mémoire de données dont l’original se trouve dans la source de données. Ces données ont été copiées depuis la source de données vers le DataSet par une carte de données. Pour copier les données modifiées depuis le DataSet vers la source de données – et rendre les modifications permanentes – utilisez la méthode Update() de la carte de données. Cela doit être fait avant d’accepter ou de rejeter les modifications dans le DataSet comme cela a été décrit précédemment. Cette méthode s’applique aux deux types de carte de données, c’est-à-dire à la classe SqlDataAdapter et à la classe OleDbAdapter. Vous pouvez appeler cette méthode de la façon suivante pour pérenniser toutes les modifications apportées dans le DataSet :
adap.Update(ds)
adapt est une référence à la carte de données et ds une référence au DataSet. Vous pouvez aussi enregistrer uniquement les modifications effectuées dans une table donnée référencée par dt :
adap.Update(dt)
Dans les deux cas, la méthode renvoie le nombre de lignes mises à jour avec succès. Si vous passez un objet DataTable à la méthode Update(), vous pouvez passer la table d’origine dans laquelle vous avez effectué les modifications ou créer un nouvel objet DataTable contenant uniquement les modifications, en appelant la méthode GetChanges() de la table originale. C’est ce que démontre l’exemple de code ci-après.
Pour que la méthode Update() fonctionne proprement, la carte de données doit disposer de la commande SQL de mise à jour appropriée. Cela peut être fait manuellement, mais c’est bien
plus facile en utilisant un command builder à associer avec la carte de données. Il y a deux types de command builder : SqlCommandBuilder à employer avec SqlDataAdapter et OleDbCommandBuilder à employer avec OleDbDataAdapter. En créant un command builder et en l’associant avec votre carte de données, vous faites en sorte que la commande SQL requise soit générée automatiquement. Ainsi, si sqlAdapt est une référence à votre instance de SqlDataAdapter, vous pouvez écrire la ligne suivante :
