ADO .NET (Version C#)

ADO.
NET (version C#)

J-M Rabilloud S Curutchet
HTU www.developpez.com. Reproduction, copie, publication sur un UTH
autre site Web interdite sans l'autorisation des auteurs.
Remerciements
Nous adressons ici tous nos remerciements l'quipe de rdaction de "developpez.com" et tout
particulirement Etienne Bar, Emilie Guittier, Maxence Hubiche et David Pdehourcq pour le temps
qu'ils ont bien voulu passer la correction et l'amlioration de cet article.
INTRODUCTION ...........................................................................................................5
TU UT
PASSER D'ADO A ADO.NET .......................................................................................6

TU UT
Les limitations du modle ADO ............................................................................................................................... 6

TU UT
ADO.NET la rvolution ............................................................................................................................................ 6

TU UT
ADO.NET remplace compltement ADO .............................................................................................................. 6

TU UT
Il faut tout rapprendre pour passer d'ADO ADO.NET....................................................................................... 6

TU UT
ADO.NET une volution ncessaire ........................................................................................................................ 7

TU UT
Une nouvelle architecture ....................................................................................................................................... 9

TU UT
Le Dataset ................................................................................................................................................................ 11
TU UT
Dataset Vs Recordset............................................................................................................................................ 11
TU UT
Fournisseur manag ............................................................................................................................................... 13

TU UT
Objet Connection .................................................................................................................................................. 13

TU UT
Objet Command ................................................................................................................................................... 14

TU UT
Objet DataReader ................................................................................................................................................. 14

TU UT
L'objet DataAdapter ............................................................................................................................................. 15

TU UT
Intgration du XML ............................................................................................................................................... 15

TU UT
Document XML ................................................................................................................................................... 15

TU UT
XML Schema (XSD) ............................................................................................................................................ 16

TU UT
Utiliser ADO avec les langages DotNet ................................................................................................................. 17

TU UT
1/130
Pourquoi utiliser encore ADO ? ........................................................................................................................... 17
TU UT
Comment utiliser ADO ? ...................................................................................................................................... 19

TU UT
Considrations sur les performances .................................................................................................................... 21

TU UT
Informations de schma........................................................................................................................................ 21
TU UT
Cration ou excution ........................................................................................................................................... 21

TU UT
Programmation des SGBD administrs ................................................................................................................ 22

TU UT
Proprits des objets et login ................................................................................................................................ 22

TU UT
Requtes et procdures stockes........................................................................................................................... 22

TU UT
Considrations sur les procdures stockes .......................................................................................................... 23

TU UT
Gestion des erreurs du SGBD............................................................................................................................... 23

TU UT
LES CLASSES ADO.NET ...........................................................................................24

TU UT
Les espaces de nom dans DotNet ........................................................................................................................... 24

TU UT
La classe Dataset ..................................................................................................................................................... 25

TU UT
ExtendedProperties & PropertyCollection ........................................................................................................... 25

TU UT
Proprits .............................................................................................................................................................. 25
TU UT
Mthodes .............................................................................................................................................................. 26
TU UT
Proprits & mthodes lies au XML................................................................................................................... 29

TU UT
Evnements .......................................................................................................................................................... 32
TU UT
La classe DataTable ................................................................................................................................................ 32

TU UT
Construction d'une table par le code ..................................................................................................................... 32

TU UT
Mise jour des tables ........................................................................................................................................... 32

TU UT
Mthodes de DataTableCollection ....................................................................................................................... 33

TU UT
Proprits de DataTable ....................................................................................................................................... 34

TU UT
Mthodes de DataTable ........................................................................................................................................ 34

TU UT
Evnements de DataTable .................................................................................................................................... 36

TU UT
La classe DataColumn ............................................................................................................................................ 36

TU UT
Colonne auto-incrmente .................................................................................................................................... 37

TU UT
Type de donnes ................................................................................................................................................... 37

TU UT
Mthode Add de DataColumnCollection ............................................................................................................. 38

TU UT
Proprits de DataColumn .................................................................................................................................... 38

TU UT
La classe DataRow .................................................................................................................................................. 42

TU UT
Les valeurs de la ligne .......................................................................................................................................... 42

TU UT
L'tat d'une ligne................................................................................................................................................... 42

TU UT
Remonte des erreurs ........................................................................................................................................... 42

TU UT
Ajout et modification de ligne .............................................................................................................................. 43

TU UT
Mthode de DataRowCollection .......................................................................................................................... 43

TU UT
Proprits de l'objet DataRow .............................................................................................................................. 44

TU UT
Mthode de DataRow ........................................................................................................................................... 45

TU UT
La Classe Constraint .............................................................................................................................................. 47

TU UT
UniqueConstraint.................................................................................................................................................. 47
TU UT
ForeignKeyConstraint .......................................................................................................................................... 48
TU UT
La classe DataRelation ........................................................................................................................................... 49

TU UT
La collection DataRelationCollection................................................................................................................... 50
TU UT
Proprits de DataRelation ................................................................................................................................... 51

TU UT
Les classes DataView & DataViewManager ......................................................................................................... 52

TU UT
Proprits de DataView ........................................................................................................................................ 54

TU UT
Mthodes du DataView ........................................................................................................................................ 54

TU UT
DataRowView ...................................................................................................................................................... 54
TU UT
2/130
Manipulation des DataView ................................................................................................................................. 55
TU UT
DataViewManager................................................................................................................................................ 55
TU UT
Les fournisseurs manags ...................................................................................................................................... 56

TU UT
Lot de requtes ..................................................................................................................................................... 56

TU UT
Procdures stockes & Requtes stockes............................................................................................................ 56

TU UT
La connexion ........................................................................................................................................................... 56
TU UT
Regroupement de connexions............................................................................................................................... 56
TU UT
Proprits .............................................................................................................................................................. 57
TU UT
Mthodes .............................................................................................................................................................. 58
TU UT
Evnements .......................................................................................................................................................... 60
TU UT
Objet Transaction ................................................................................................................................................. 62

TU UT
Les commandes ....................................................................................................................................................... 62

TU UT
Proprits .............................................................................................................................................................. 63
TU UT
Retour de procdure stocke ................................................................................................................................ 64

TU UT
Mthodes .............................................................................................................................................................. 65
TU UT
Objet Parameter .................................................................................................................................................... 68

TU UT
La classe DataReader ............................................................................................................................................. 73

TU UT
Proprits .............................................................................................................................................................. 74
TU UT
Mthodes .............................................................................................................................................................. 74
TU UT
La classe DataAdapter............................................................................................................................................ 78
TU UT
Schma et Mappage.............................................................................................................................................. 78
TU UT
Proprits .............................................................................................................................................................. 79
TU UT
Mthodes .............................................................................................................................................................. 80
TU UT
Evnements .......................................................................................................................................................... 81
TU UT
Commandes du DataAdapter ................................................................................................................................ 82

TU UT
La classe CommandBuilder .................................................................................................................................. 83

TU UT
DISCUSSIONS ET EXEMPLES DE CODES ..............................................................84

TU UT
Utilisation de l'IDE ................................................................................................................................................. 84

TU UT
Concepts gnraux : Crer un Dataset ................................................................................................................. 87

TU UT
Discussion autour du schma ............................................................................................................................... 88

TU UT
Rcuprer le schma ............................................................................................................................................. 89

TU UT
Dataset fortement typ.......................................................................................................................................... 91

TU UT
Stratgies de mise jour ........................................................................................................................................ 95

TU UT
Rappels SQL......................................................................................................................................................... 95
TU UT
Choisir les restrictions du critre .......................................................................................................................... 96

TU UT
Etude des cas particuliers ..................................................................................................................................... 97

TU UT
Ecriture des commandes avec des requtes paramtres ...................................................................................... 98

TU UT
Ecriture des commandes avec des procdures stockes ..................................................................................... 103

TU UT
Gestion des modifications .................................................................................................................................. 108

TU UT
Rcupration des informations de mise jour .................................................................................................... 109

TU UT
Mettre jour le Dataset ...................................................................................................................................... 111

TU UT
Grer les checs .................................................................................................................................................. 115

TU UT
Mise jour relationnelle ..................................................................................................................................... 116

TU UT
Mise jour distante ............................................................................................................................................ 119

TU UT
Notions de liaisons de donnes ............................................................................................................................. 120

TU UT
Gnralits .......................................................................................................................................................... 120

TU UT
CurrencyManager ............................................................................................................................................... 121

TU UT
Navigation .......................................................................................................................................................... 122

TU UT
3/130
Gestion des exceptions .......................................................................................................................................... 123
TU UT
Exception du serveur .......................................................................................................................................... 124

TU UT
Exception Gnrale ............................................................................................................................................ 124

TU UT
Manipulation du Dataset ...................................................................................................................................... 124

TU UT
Utiliser une source non sure ............................................................................................................................... 124

TU UT
Transfrer une table ............................................................................................................................................ 126

TU UT
Un peu de XML ..................................................................................................................................................... 127

TU UT
Synchroniser ....................................................................................................................................................... 127

TU UT
Annoter le schma .............................................................................................................................................. 128

TU UT
Optimisation du code ............................................................................................................................................ 128

TU UT
Connexion .......................................................................................................................................................... 129

TU UT
Command ........................................................................................................................................................... 129

TU UT
DataReader ......................................................................................................................................................... 129

TU UT
DataAdapter et DataReader ................................................................................................................................ 130

TU UT
CONCLUSION ...........................................................................................................130
TU UT
4/130
Introduction
Avec la nouvelle plate-forme DotNet, Microsoft fournit une nouvelle architecture d'accs aux donnes
P P
appele ADO.NET. Comme notre habitude, nous allons visiter en dtail les objets la composant avec des
exemples d'utilisation. Cependant, dans la premire partie, nous allons voir ce qu'il en est pour le
dveloppeur ADO. Ce cours risque d'tre assez dense. La bonne comprhension de celui-ci suppose que vous
ayez assimil correctement les concepts fondamentaux d'ADO. Un certain nombre d'autres connaissances
vous seront ncessaires, mme si nous nous livrerons quelques sances de rappel dans ce cours.
Developpez.com met votre disposition de nombreux documents vous permettant de vous aider.
HTU UTH
ADO.NET
Les objets Connection, Command et Datareader dans ADO.NET
HTU UT UTH
Les objets DataAdapter et DataSet dans ADO.NET par Leduke

HTU UTH
SQL
Le site de rfrence de Frdric Brouard
HTU UTH
ADO
Utiliser les Recordset ADO
HTU UTH
VB-VBA : ADOX structure & scurit des donnes par moi-mme

HTU UTH
XML
Le Cours en Franais sur XML-XLS de Luc Van Lancker
HTU UTH
Le document de rfrence des spcifications XML

HTU UTH
Cette version de ce cours utiliseras le langage C# sur le Microsoft .NET FrameWork 1.1. P P
La plupart des exemples de ce cours vont utiliser les bases de donnes Pubs pour SQL-SERVER et
Biblio pour Access 2000.
Bonne lecture
5/130
Passer d'ADO ADO.NET
Les limitations du modle ADO
Tous les dveloppeurs ayant eu utiliser ADO en mode client et a fortiori en mode dconnect se sont
heurts aux limitations induites par le moteur de curseur client ADO. Il n'est pas possible de travailler, sauf
en utilisant une programmation extrmement lourde, sur un modle relationnel de donnes. La seule
technique acceptable consistait multiplier le nombre d'interventions directes sur la source de donnes ce qui
avait deux effets pervers :
Une certaine 'dconnexion' entre le Recordset et la source. En effet, l'action par le biais de commande
indpendante obligeait la synchronisation frquente du Recordset. Ceci impliquait une sollicitation
importante de la connexion, ce qui est le but inverse de la programmation ct client
La perte quasi-totale de la programmation gnrique. L'criture de commande SQL devait tenir compte
des spcificits SQL du fournisseur ce qui impliquait un code ddi pour le fournisseur et la perte d'un des
plus gros avantages d'ADO.
D'autres limitations, dues l'utilisation du modle COM, posaient aussi des problmes de conversion de
types ou de franchissement.
Dans le cadre d'un dveloppement WEB, o les ressources du serveur sont comptes, il est indispensable
d'avoir un mode de travail ct client beaucoup plus performant. Avec l'arrive des Web Forms de la plate-
forme DotNet, ADO ne pouvait pas suffire pour un travail dconnect performant.
ADO.NET la rvolution
Je prends ce titre provocateur pour tuer le mythe tout de suite. S'il y a une vritable rvolution entre VB6
et VB.NET il n'en est pas du tout de mme pour le passage vers ADO.NET.
Il existe de nombreux articles sur le NET traitant d'ADO et d'ADO.NET. Lors des recherches
prliminaires l'criture de ce cours j'en ai lu plusieurs tant en franais qu'en anglais, et il faut bien constater
qu'une grande quantit d'ides reues oscillant entre le mythe et l'ignorance hantent une grande partie de la
prose libre traitant de ce sujet. Nous allons tenter de rtablir ici une vision saine de la problmatique.
Attention, je ne vois pas d'intention malveillante derrire les ides reues vhicules dans ces articles, seule
la profonde mconnaissance d'ADO est mettre en cause. J'en veux pour preuve les interprtations varies
de ce qu'est un curseur ct serveur dans le modle ADO.
ADO.NET remplace compltement ADO

U
Cette vision est fausse et qui plus est dangereuse. ADO.NET de son premier nom ADO+ est une
extension d'ADO, et est annonce comme telle par Microsoft. Pour schmatiser, il s'agit d'une rvision des
P P
composants RDS et du travail sur les jeux de donnes dconnects. Cette remise plat tait d'ailleurs
ncessaire et l'approche ADO.NET est un indniable progrs.
Il faut tout rapprendre pour passer d'ADO ADO.NET

U
Voil srement le plus gros des serpents de mer. Il est amusant d'ailleurs de constater qu'il est
diversement employ selon que l'on sera attir ou repouss par ADO.NET. Bien que nombreuses, les
variations les plus communes sont les suivantes.
Dans ADO.NET les curseurs ont disparus
Puisque ADO.NET se centre sur la gestion des jeux de donnes client dconnects, il est bien certain
qu'il n'y a gure d'intrt grer les curseurs avec ADO.NET. La prsence du DataReader dans le modle
ADO.NET sert d'ailleurs d'argument massue dans ce contexte. Pourtant le DataReader, qui n'est rien d'autre
qu'un curseur serveur de type FireHose a sa raison d'tre dans une approche WEB qui est celle d'ADO.NET.
En effet pour les trs gros jeux d'enregistrements comme pour la rcupration d'une valeur unique
(ExecuteScalar) il fallait bien pouvoir utiliser autre chose qu'un DataSet.
6/130
Avec DotNet impossible de travailler en mode connect.
La c'est l'amalgame qui prime. Avec ADO.NET assurment non. Mais la plate-forme permet l'utilisation
d'ADO, cette utilisation tant documente par Microsoft. Nous reviendrons d'ailleurs en dtails sur le quand
P P
et le comment de l'emploi de cette solution.

Il faut choisir ADO ou ADO.NET
C'est tout fait faux. Il est tout fait possible d'employer les deux dans un mme projet, il est tout autant
possible de convertir un Dataset en Recordset et inversement. En fait tout est question de besoin.
La migration d'ADO vers ADO.NET est complexe
Toutes vos connaissances ADO vont continuer de vous tre indispensables pour utiliser ADO.NET et le
passage va se faire sans douleur. ADO.NET n'est pas un remplacement total d'ADO mais bien un
enrichissement de celui-ci. Ceci ne veut pas dire qu'il n'est pas possible d'apprendre utiliser ADO.NET sans
avoir pralablement appris utiliser ADO. Les concepts de fonctionnement sont exactement les mmes et
l'apprentissage de l'un permet un apprentissage ais de l'autre. Bien sur, il y aura une part non ngligeable de
rcriture de code comme nous le verrons un peu plus loin.
Nous allons maintenant voir ce qui a chang, quels sont ces nouveaux concepts tellement effroyables
qu'ils forcent le re codage de toutes vos applications, bref allons dcouvrir ensemble de quoi la bte est faite.
ADO.NET une volution ncessaire

Avec ADO il existe deux mthodes pour obtenir un jeu d'enregistrements dconnect, et deux formats
pour le manipuler. Pour obtenir un jeu d'enregistrements dconnect, on employait soit un composant RDS
(Remote Data Access) dans le cas des applications Web, soit un Recordset client dont on coupait la
connexion. Ces jeux d'enregistrements pouvaient tre rendu persistants soit dans un format propritaire
(Datagram ADTG) soit dans un format libre (Extensible Markup Language XML). Ceci tait certes
suffisant pour crire des applications simples en mode dconnect mais il subsistait des problmes
consquents. De plus, ADO est bas sur COM et en cela subit les problmes de communications inter-
process et de types.
Le schma d'une application simple ADO tait de la forme suivante.
Dans certains cas, tout se passe dans le mme process, dans d'autres la source de donnes se trouve dans
un autre process. Examinons notre bote ADO.
7/130
Dedans, outre mes classes standards, se trouvent quatre objets un peu particuliers, les fournisseurs de
service.
CCE (Client Cursor Engine Microsoft Cursor Service for OLE DB Moteur de curseur client)
C'est le plus connu des quatre, parfois mme le seul connu. Dans une base de donnes il n'y a pas de
notion d'ordre de ligne ou de colonne, donc pas de notion d'enregistrement en cours. ADO permet au
dveloppeur par le biais de ce fournisseur d'avoir accs une bibliothque minimum de curseurs ce que le
fournisseur ne peut garantir. De plus il permet l'accs des fonctionnalits supplmentaires et permet
toujours l'utilisation de la mise jour par lots.
D Shape (Microsoft Data Shaping Service for OLE DB Mise en forme des donnes)
Ce fournisseur permet la gestion de jeux de donnes hirarchiques. Il est forcment utilis en
conjonction avec un fournisseur de donnes qu'il supporte.
Persist (Microsoft OLE DB Persistence Provider Fournisseur de persistance)
Ce fournisseur permet de stocker un Recordset comme un fichier. L'ensemble des donnes et mta-
donnes tant sauvegard, il est possible de le re connecter plus tard. Deux formats de fichier sont grs,
ADTG et XML.
Remote (Microsoft OLE DB Remoting Provider Accs distance)
Le plus mconnu des fournisseurs de service, c'est celui qui permet d'aller utiliser les fournisseurs de
donnes d'une machine distante.
Trs souvent dans le modle au-dessus, la connexion n'est jamais ferme tant que l'application utilise des
donnes. Il faut dire que dans le cas d'une application locale utilisant des donnes locales, la fermeture de la
connexion ne prsente que peu d'intrt. Dans ce type de schma on travaille d'ailleurs presque
exclusivement ct serveur et c'est pour cela que l'on dit qu'ADO est un modle fortement li la connexion.
Cette analyse est pourtant audacieuse. Car ds lors que l'on travaille sur une source distante ou en utilisant
une architecture 3+-tiers, le schma change fortement.
Dans ce type d'architecture, on duplique fortement les objets mis en uvre. De plus on engendre
forcment des oprations de marshalling COM. Et encore, dans ce cas je n'ai rendu ni mon Recordset
persistant, ni hirarchique. Le modle ADO est donc fortement contraignant dans ce type d'application.
U
8/130
Une nouvelle architecture
Fort de cette constatation Microsoft a donc tendu son modle avec ADO.NET.
L'architecture d'ADO.NET est, elle, trs oriente vers les architectures rseaux. De plus, nous allons
pouvoir nous affranchir du modle COM. Pour cela ADO.NET utilise un nouveau concept, les fournisseurs
manags. Pour schmatiser on peut dire qu'il y a dconnexion du modle. Toutes les classes pouvant
communiquer avec la source de donnes sont regroupes dans le fournisseur manag, toutes celles lies au
jeu d'enregistrements tant regroupes dans le Dataset.
Le fournisseur manag utilise en gnral un fournisseur OLE DB pour communiquer avec la source de
donnes sauf dans le cas de SQL-Server ou le protocole TDS (Tabular Data Stream) est employ.
L'architecture gnrale est la suivante :
Comme nous le voyons, il n'y a plus de relation directe entre le jeu d'enregistrements et la source de
donnes. Ce terme de jeu d'enregistrements n'est d'ailleurs pas trs appropri. En effet un Dataset n'est que
peu comparable avec un Recordset, du fait de la dconnexion et de leurs diffrences de concepts, mais nous
y reviendrons un peu plus loin.
9/130
Ds lors mon architecture n-tiers devient beaucoup plus simple.
Il n'y a plus de franchissement COM prvoir. De plus le fait qu'il s'agisse alors d'un transfert permet de
franchir les Firewall ce que le modle ADO ne pouvait pas faire aisment.
10/130
Le Dataset
C'est probablement la classe qui perturbe le plus le dveloppeur ADO qui dcouvre ADO.NET. Nous
allons l'examiner sur un plan assez thorique dans cette partie, nous apprendrons son fonctionnement dtaill
dans la suite de l'article.
TablesColl
Data
ColumnsCollect
RowsCollection
ContraintsColle
RelationsColle
Rela
Dataset Vs Recordset
U
L'erreur ne pas faire si on dsire apprhender correctement le Dataset est de le comparer stricto sensu
l'objet Recordset ADO. Un Recordset ADO est sensiblement l'quivalent d'une vue SQL, c'est dire une
table produite par une requte 'SELECT' avec ou sans jointure. L'utilisation du Data Shape Provider sur ce
point n'est rien d'autre qu'une prsentation hirarchise de la mme vue. Le Recordset contient aussi un
certain nombre d'informations de schma, plus ou moins juste selon la nature du curseur. Toutes les
contraintes existantes dans le Recordset, ainsi que les index et les cls existent dans la source de donnes. Le
jeu d'enregistrements est enfin pilot par un service de moteur de curseur qui rgit :
La notion d'enregistrement en cours Dans une source de donnes cette notion n'existe jamais.
Dans ADO elle est diffrente selon la position du curseur. Dans le cadre de la lecture d'un
enregistrement, la position du curseur n'intervient pas, mais ds lors qu'on souhaite modifier les
donnes, le fonctionnement diffre. Dans le cas des curseurs clients qui nous intresse ici, cet
enregistrement ne peut pas tre retrouv dans la source de donnes s'il n'est pas unique.
Le dplacement dans le jeu Dans ADO certains curseurs ont un mode de dfilement obligatoire
vers l'avant, les autres tant bidirectionnels. Pour ceux-ci, il est alors possible de connatre le nombre
d'enregistrements rapatris par la requte ainsi que la position de l'enregistrement en cours dans le
jeu.
La sensibilit aux modifications de la source Les curseurs non statiques peuvent, dans une
certaine mesure, reflter dynamiquement les modifications de la source de donnes du fait d'autres
'utilisateurs'.
Avec les Dataset, rien de tout cela. Il faut voir le Dataset comme une base de donnes relationnelle,
locale votre application. Celle-ci peut tre la copie conforme ou tronque d'une base existante, la rsultante
de donnes provenant de multiples sources, voire entirement cre dans votre application. Un Dataset se
compose, tout comme une base de donnes, de tables et de relations. Ces tables sont similaires des tables
de SGBD avec la gestion de lignes (les enregistrements), de colonnes (les champs) et de contraintes (la
limitation des oprations utilisables). Les relations permettent de lier les tables entre-elles. Du fait de la
dconnexion totale du Dataset, vous pouvez parfaitement modifier tous ces objets mme lorsqu'ils sont issus
d'une base existante.
11/130
Un Dataset n'est donc pas un jeu d'enregistrements mais un ensemble de collections reprsentant une
base de donnes, stock dans un fichier XML. En cela, la notion de dplacement ou d'enregistrement en
cours doit tre vu diffremment, la sensibilit aux donnes n'existant plus du fait de la dconnexion.
Donc notre Dataset est un conteneur de collection comme nous pouvons le voir dans le schma ci-
dessous :
L'apport d'un tel modle par rapport au Recordset tant en souplesse qu'en fonctionnalit engendre toute
une diffrence de philosophie dans l'approche du dveloppeur. Dans le modle ADO, on programme avec les
limitations induites par l'objet Recordset, avec ADO.NET, on peut se concentrer plus sur les 'points
techniques' de l'application (conomie de bande passante, tudes des points de concurrence, etc).
Il est pourtant faux de croire que la programmation ADO.NET est plus simple car elle demande une
meilleure connaissance du fonctionnement d'un SGBD et de bonnes bases de SQL. Ceci s'entend au terme de
la comprhension, car l'environnement de dveloppement va travailler beaucoup plus que nous quant
l'criture du code.
Par de nombreux aspects cependant, la programmation d'ADO et d'ADO.NET est similaire. Vous allez
voir tout au long de ce cours que nous allons manipuler des concepts relativement simples ; les seules
vritables difficults tant dues la programmation des bases de donnes.
12/130
Fournisseur manag
C'est le deuxime concept amen

par ADO.NET. Ceci consiste regrouper dans un fournisseur suivant les rgles du FrameWork l'ensemble
des classes pouvant communiquer avec la source de donnes. L encore si vous avez bien saisi le
fonctionnement d'ADO, vous allez voir que le terrain est connu.
Objet Connection
U
Sensiblement identique une connexion ADO. Pour ouvrir la connexion on passe une chane de
connexion l'objet Connection puis on ouvre celui-ci.
Par exemple pour ouvrir une connexion SQL-Server
String strConn = "packet size=4096;user id=sa;data source=NOM-
SZ71L7KTH17\\TUTO;persist security info=False;initial
catalog=northwind;password=monpasse";
System.Data.SqlClient.SqlConnection MaConn = New
System.Data.SqlClient.SqlConnection(strConn);
MaConn.Open();
Pour une base Access il faut utiliser le fournisseur manag pour OLE DB
string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data
source=C:\\tutoriel\\dotnet\\biblio.mdb";
OleDbConnection conn = new OleDbConnection(strConn);
try
{ Conn.Open();}
catch(Exception ex)
{ MessageBox.Show(ex.Message);}
finally
{ Conn.Close();}
Si vous regardez dans la documentation les proprits / mthodes de la classe vous allez voir qu'il s'agit de la
mme connexion qu'ADO, ceci prs qu'il existe un objet Connection diffrent par fournisseurs manags.
U
13/130
Objet Command
Le mme que pour ADO. Gre les paramtres comme son homonyme et s'utilise de la mme faon. Il
possde quatre mthodes Execute selon qu'il devra crer un objet DataReader, un objet XMLReader,
rcuprer une valeur ou ne rien rcuprer. Il est noter que l'apparition de la mthode ExecuteScalar est
vraiment un plus notable. En effet dans ADO, pour rcuprer la valeur renvoye par la requte :
SELECT Count(Description) AS NbDesc FROM Catgories;
Il fallait crer un Recordset pour aller lire la valeur, avec tout ce que cela implique. Maintenant un appel
la mthode ExecuteScalar suffit.
Notons que la gestion des paramtres est elle aussi identique. Par exemple, le code ci dessous est du C#
utilisant ADO.NET
String strConn = "packet size=4096;user id=sa;data source=NOM-
SqlConnection MaConn = New SqlConnection(strConn);
MaConn.Open();
SqlCommand cmd = New SqlCommand("byroyalty", MaConn);
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter par = New SqlParameter("@percentage", SqlDbType.Int);
par.Direction = ParameterDirection.Input;
par.Value = 15;
cmd.Parameters.Add(par);
SqlDataReader dr = cmd.ExecuteReader()
Avouons qu'il y a presque de quoi se tromper.
Objet DataReader
U
Bien que semblant nouveau, tous les dveloppeurs ADO l'ont utilis de nombreuses fois. En effet il ne
s'agit de rien d'autre que du FireHose Cursor, le curseur par dfaut d'ADO.
C'est le seul objet 'connect' fourni par ADO.NET. Comme il s'agit d'un curseur parfaitement connu je
ne vais pas m'tendre dessus, toutefois je vous rappelle qu'il a pour proprits :
Lecture seule
En avant seulement
Un enregistrement la fois
Exclusif sur sa connexion
{
string strConn = "packet size=4096;user id=sa;data source=NOM-
SqlConnection MaConn = New SqlConnection(strConn);
MaConn.Open();
SqlCommand cd = New SqlCommand("select * from authors", MaConn);
SqlDataReader rd = cd.ExecuteReader();
while (rd.Read())
{Console.WriteLine(rd("au_lname"));}
rd.Close();
MaConn.Close();
}
Comme cela il est plus facile reconnatre. Vous noterez au passage que l'on utilise plus la mthode
MoveNext pour naviguer l'intrieur mais la mthode Read (celle-ci revient une equivalence de
MoveNext et EOF).
U
14/130
L'objet DataAdapter
Voil par contre un petit nouveau, du moins en apparence. En fait c'est une autre vision de notre vieil
ami le moteur de curseur client. Je m'explique.
Dans ADO, lorsqu'on travaille sur un Recordset, on utilise une commande, explicite ou non pour obtenir
les enregistrements. Pour transmettre les modifications apportes au Recordset vers la source, le moteur de
curseur gnre les commandes SQL quivalentes (ou du moins essaye-t-il). Lorsqu'on travaille en mode par
lots, il parcours toutes les lignes modifies et gnre l'ensemble des requtes ncessaires. L'objet
DataAdapter regroupe les fonctionnalits de la commande de cration et des modifications vers la source.
Par contre la stratgie de modification des donnes a t toffe.
Vous avez maintenant le choix entre laisser le DataAdapter gnrer seul les commandes par le biais de
son CommandBuilder, ou vous pouvez crire des commandes gnriques pour les requtes actions de
modification. Comme nous allons y revenir longuement dans la troisime partie je ne vais pas m'tendre ici
sur le sujet. Nanmoins il faut bien voir qu'il y a l une petite rvolution.
Avec ADO, le moteur de curseur client tait rarement capable de gnrer des modifications sur plusieurs
tables. En crivant le code gnrique de la commande vous pouvez aisment contourner cette limitation, pour
peu que vos notions de SQL ne soit pas trop limites.
Le couplage DataAdapter / Dataset donne un environnement de dveloppement cohrent et performant.
Nanmoins c'est principalement dans le paramtrage de cet ensemble que l'on peut crer une application
vritablement adapte. Sauf dans le cas d'application basique, il y a encore ncessit de parfaitement dfinir
les besoins afin d'obtenir les meilleures performances.
Il ne nous reste plus qu' voir l'intgration du XML dans ADO.NET, et nous avons fini de dissquer la
crature. Comme je vous l'avais dit, rien de bien spectaculaire. Par contre nous disposons maintenant d'un
ensemble de classes robustes pour le travail sur des donnes dconnectes.
Intgration du XML
Le XML (Extensible Markup Language) est un langage de mta-balise qui constitue un format pour
dcrire des donnes structures. XML est en train de devenir le langage universel pour les donnes sur le
Web. XML permet aux dveloppeurs de gnrer des donnes structures partir d'un grand nombre
d'applications directement sur le poste de travail comme sur le WEB.
Document XML
U
Un DataSet est donc utilis comme une base de donnes 'en mmoire'. Cette base de donnes, donc notre
DataSet, peut tre rendue persistante sous forme fichier XML en utilisant les drives de la classe
XMLDocument. Je ne vais pas dans le cadre de ce cours aller trs loin dans la manipulation des documents
XML, nanmoins il est ncessaire d'avoir un minimum de connaissances pour comprendre les exemples que
nous serons amens manipuler.
La partie qui va nous intresser plus particulirement dans ADO.NET est la classe XMLDataDocument.
NB : On trouve facilement sur le Web les spcifications compltes du XML.
15/130
XMLDataDocument
XMLDataDocument drive de XMLDocument. C'est une liaison entre un Document XML et un
Dataset. Dans l'absolu, le document XML et le Dataset vont reprsenter les mmes donnes, mme s'il va y
avoir des diffrences dans la faon de les prsenter, c'est dire des diffrences de vue entre des donnes
relationnelles et des donnes hirarchiques. Si vous avez utilis le fournisseur DataShape dans ADO, vous
avez rencontr le mme problme. Dans une vision hirarchique on raisonne vis--vis du parent. C'est
similaire au parcours d'un arbre. Pour retrouver les donnes d'un enfant il est ncessaire de redescendre la
hirarchie des parents. Le modle relationnel est quand lui beaucoup plus plat. Les enfants sont
accessibles et contiennent les informations de leurs parents qui dans une certaine mesure sont dupliques. Un
document XML tend donner une vision hirarchique des donnes, tandis qu'un Dataset prsente une vue
relationnelle. Un document XMLData tend supprimer cette diffrence de vue entre les deux, on peut dire
qu'il s'agit d'un document XML sachant exposer ses donnes dans un Dataset.
Un document XMLData peut tre converti vers ou partir d'un DataSet directement. Il est possible de
synchroniser les deux pour que toutes modifications de l'un se rpercutent vers l'autre.
Conversion XMLDocument XMLDataDocument

La conversion vers un XMLDataDocument ne pose pas de problme majeur. En fait, il y a conversion
directe sachant que les donnes non relationnelles risquent d'tre supprimes. La conversion dans l'autre sens
est un plus complexe et fait appel des notions de feuille de style (XSL). Je ne l'utiliserais pas dans le
prsent cours.
Nous verrons dans la troisime partie comment manipuler ces documents XML avec des DataSet.
XML Schema (XSD)

U
Pour pouvoir passer aisment des donnes d'un Dataset celle d'un document XML, vous devez pouvoir
transmettre des informations de schma. Pour cela on utilise le langage XSD (XML Schema Definition). Du
fait de la complexit possible d'un schma de donnes dans un Dataset, il peut tre trs complexe d'crire le
schma. A voir ainsi, cela semble assez abscons mais du fait de la forte intgration des deux modles c'est
trs simple utiliser. En effet vous n'aurez jamais besoin de travailler en profondeur sur ces modles objets.
ADO.NET implmente toutes les mthodes ncessaires pour travailler simultanment sur des documents /
schmas XML et sur vos DataSet, ainsi que toutes les mthodes ncessaires pour passer de l'un l'autre.
Un mme Dataset peut donner plusieurs schma diffrents selon son paramtrage, il peut tre alors
interessant de communiquer le schma avant ou sans les donnes selon les cas.
16/130
Utiliser ADO avec les langages DotNet
Pour tordre le cou une des lgendes souvent cites, nous allons voir dans le petit exemple suivant
comment utiliser ADO pour gnrer un Recordset et transformer celui-ci en Dataset. Ceci nous permettra de
discuter dans ce chapitre sur l'intrt de continuer d'utiliser ADO avec C# et de quand et comment le grer.
Pour faire fonctionner cet exemple, vous devez intgrer une rfrence ADODB dans l'onglet COM.
{
String MaConn="PROVIDER=SQLOLEDB;user id=sa;data source=NOM-
ADODB.Recordset MonRst=new ADODB.Recordset();
MonRst.CursorLocation=ADODB.CursorLocationEnum.adUseClient;
MonRst.Open("SELECT * FROM produits",
MaConn,ADODB.CursorTypeEnum.adOpenStatic,ADODB.LockTypeEnum.adLockBatchOp
timistic,0);
OleDbDataAdapter MonDtaAdapter = new OleDbDataAdapter();
DataSet MonDataset = new DataSet();
MonDtaAdapter.Fill(MonDataset, MonRst, "produits");
dataGrid1.DataSource=MonDataset.Tables[0].DefaultView;
}
Comme vous le voyez il s'agit d'une programmation triviale. Dans ce cadre elle est en plus inutile car
utiliser ADO pour gnrer un Recordset dconnect lorsqu'on peut utiliser ADO.NET c'est du vice.
Pourquoi utiliser encore ADO ?

U
Comme nous l'avons vu, ADO.NET est une extension d'ADO. Cette extension pour but de grer une
partie par trop limite du modle ADO. Nanmoins, il existe un domaine ou ADO.NET ne peut pas tre
utilis, le travail ct serveur. Comme nous l'avons vu, ADO.NET ne met notre disposition qu'un seul
curseur serveur, le DataReader. Si ces avantages en terme de performances sont vidents, ses limitations le
sont tout aussi. Impossible de verrouiller un enregistrement puisque le curseur est en lecture seule et pas de
sensibilit aux donnes sur les enregistrements dj lus.
Les limitations de la concurrence optimiste
Pour avoir une vue de plusieurs enregistrements dans ADO.NET, pas d'autres choix que le Dataset.
Rappelons-nous bien que celui-ci est un curseur statique, optimiste par lot, ct client. Il est d'autant plus
statique qu'il est dconnect. Il serait techniquement possible d'envisager un rafrachissement priodique d'un
Dataset en le remplissant rgulirement mais le cot en temps/ressources rend cette hypothse inabordable.
Lorsqu'un Dataset est modifi et qu'on lui demande de rpercuter ses modifications vers la source de
donnes, celui-ci gre la concurrence par un verrouillage optimiste.
Par dfinition le verrouillage optimiste n'est pas un verrou mais une comparaison de valeurs. Il existe
grosso modo deux gestions possibles.
Rcupration d'une valeur de version : Ceci consiste utiliser une donne qui est intrinsque la ligne
mais qui n'est pas une donne de l'enregistrement. Par exemple une valeur TimeStamp de la dernire
modification. Lors de l'appel de la mise jour, il y a comparaison de la valeur de l'enregistrement et de celle
stocke dans le Dataset. Si elles sont diffrentes, c'est dire si un autre utilisateur a modifi l'enregistrement,
il y a conflit de la concurrence optimiste, une exception est gnre et la mise jour est refuse. Ce mode est
gr par SQL-Server par exemple.
Comparaison des enregistrements : C'est le principe utilis par le moteur de curseur client. Elle consiste
comparer les valeurs des champs trouves dans le Dataset celles prsentes dans la source. Elle ne porte
pas forcment sur l'ensemble des valeurs. Le principe rel est simple on excute une requte action contenant
dans la clause WHERE les valeurs de champs prsentes dans le Dataset, et on rcupre le nombre
d'enregistrements modifis. Si celui-ci est nul, c'est que l'enregistrement a t modifi et qu'il y a
concurrence optimiste. Cette technique peut tre prilleuse si on n'utilise pas tous les champs dans la
requte, mais c'est une question de choix.
17/130
Il existe aussi une mthode de barbare que les anglophones nomment 'last in win' qui consiste ne pas
grer la concurrence et toujours craser l'enregistrement par les dernires modifications arrivant. Je vous
laisse concevoir quels peuvent tre les effets de ce genre de stratgie.
Ds lors qu'il y a concurrence optimiste, il y a globalement deux rponses possibles. On travaille dans
une logique de transaction, comme une modification ne peut avoir lieu, toutes les modifications doivent tre
rejetes, et on fait alors un RollBack de la transaction. On travaille en mode 'sans unit' et on valide les
modifications qui sont acceptes. Libre ensuite de reprendre ou non aprs un traitement sur les
enregistrements refuss pour tenter de leur adapter une nouvelle modification.
La stratgie que l'on applique pour la concurrence doit tre dfinie en toute connaissance de cause. En
choisir une au hasard revient ne pas grer la concurrence.
Il est souvent prfrable de travailler sur des oprations de petites tailles et cohrentes. En effet
l'approche transactionnelle est beaucoup plus fiable et facile grer que l'acceptation partielle avec
traitement des erreurs.
Enfin ayez bien l'esprit que la simple gestion de la concurrence ne suffit pas garantir l'intgrit des
donnes. Dans notre cas par exemple vous voyez bien qu'il n'y a pas de scurit au niveau de la concurrence
stricto sensu pour l'ajout d'une nouvelle ligne.
Je vous donne ici le schma gnrique de fonctionnement.
18/130
Ce que nous voyons bien avec ce type de verrouillage est la limitation du modle. A aucun moment je
n'ai un vritable contrle sur ce que sera ma mise jour. Soit j'utilise une transaction, et l'chec d'une
modification entranera l'chec de toute la transaction, soit je gre moi-mme le comportement en cas
d'erreur sachant qu'il y aura peut-tre alors des modifications rejetes.
La seule faon de pouvoir exercer un contrle strict sur mes donnes consiste donc utiliser un curseur
serveur.
Les contraintes d'ADO
Le choix d'ADO ne peut tre fait que si le modle COM est support par toutes les parties. De plus, il
n'est raliste que dans une application de type client / Serveur. Dans les langages DotNet les performances
vont en prendre un coup du fait de l'utilisation de l'interop. Enfin et surtout n'oubliez pas que l'utilisation ct
serveur est consommatrice de ressources serveur et qu'il faut que celui-ci puisse tenir la charge. Ce type
d'applications n'est pas frquente, on le retrouve en gnral dans deux grandes familles :
Les applications concurrence leve : C'est le cas des applications ou l'accs aux donnes est
extrmement frquent et ou la conception de la source fait que le risque de point de concurrence a une forte
probabilit. Il faut avant tout valuer si le cot, dans le sens large du terme, rend rentable d'utiliser un curseur
serveur plutt que de faire des RollBack sur de nombreuses transactions.
Les applications affichage dynamique : Ce sont celles qui demandent que les contrles consommateurs
refltent toujours l'tat rel des donnes. Ce genre d'application demande une criture particulirement
soigne afin que le serveur puisse supporter la charge.
Comment utiliser ADO ?

U
L'opration est assez simple. Tout d'abord on slectionne le menu "projet-Ajouter une rfrence" pour
ajouter une rfrence ADODB (Microsoft ActiveX Data Object 2.7 +). Celle-ci se trouve dans l'onglet
P P
COM.
Dans le menu projet, allez dans les proprits du projet et importez l'espace de nom System.Data.
private void WinForm_Load(object sender, System.EventArgs e)
{
String MaConn="PROVIDER=SQLOLEDB;user id=sa;data source=NOM-
ADODB.Recordset MonRst=new ADODB.Recordset();
MonRst.CursorLocation=ADODB.CursorLocationEnum.adUseClient;
MonRst.Open("SELECT * FROM produits",
MaConn,ADODB.CursorTypeEnum.adOpenStatic,ADODB.LockTypeEnum.adLockBatchOp
timistic,0);
OleDbDataAdapter MonDtaAdapter = new OleDbDataAdapter();
MonDtaAdapter.Fill(MonDataset, MonRst, "produits");
dataGrid1.DataSource=MonDataset.Tables[0].DefaultView;
}
Dans ce cas j'utilise un Datagrid. Ceci pose un problme vident. En effet, l'utilisation de ce contrle me
force convertir mon Recordset en Dataset, ceci me faisant perdre l'actualisation des donnes. Pour ne pas
rencontrer ce problme, je dois construire un formulaire diffrent et lier mes donnes dynamiquement.
Il va tre important de rgler une taille de cache assez petite, puisque lors des rafrachissements du
curseur, les enregistrements prsents dans le cache ne sont jamais rafrachis.
19/130
Dans cet exemple nous allons faire une visionneuse d'enregistrements.
private void WinForm_Load(object sender, System.EventArgs e)
{
string MaConn = "Provider=Microsoft.Jet.OLEDB.4.0;User
ID=Admin;Data Source=C:\\tutoriel\\biblio.mdb;";
MonRst.Open("SELECT * FROM Authors", MaConn,
ADODB.CursorTypeEnum.adOpenStatic,
ADODB.LockTypeEnum.adLockBatchOptimistic, 0);
txtId.Text = Convert.ToString(MonRst.Fields[0].Value);
txtAut.Text = Convert.ToString(MonRst.Fields[1].Value);
txtYear.Text = Convert.ToString(MonRst.Fields[2].Value);
}
void MonRst_MoveComplete(ADODB.EventReasonEnum a, ADODB.Error b, ref

ADODB.EventStatusEnum c, ADODB.Recordset d)
{
txtId.Text = Convert.ToString(MonRst.Fields[0].Value);
txtAut.Text = Convert.ToString(MonRst.Fields[1].Value);
txtYear.Text = Convert.ToString(MonRst.Fields[2].Value);
}
private void cmdFirst_Click(object sender, System.EventArgs e)

{
MonRst.MoveFirst;
}
private void cmdNext_Click(object sender, System.EventArgs e)

{
MonRst.MoveNext;
}
private void cmdPrev_Click(object sender, System.EventArgs e)

{
MonRst.MovePrevious;
}
private void cmdLast_Click(object sender, System.EventArgs e)

{
MonRst.MoveLast;
}
Cette simple visionneuse me permet aussi de modifier les valeurs de mes enregistrements.
Comme nous le voyons cela se programme trs facilement, et nous avons construit une application
connecte, visualisant les modifications des autres utilisateurs et grant des verrous physiques.
20/130
Considrations sur les performances
Vous allez trouver de nombreux comparatifs sur les performances entre ADO et ADO.NET. Ces 'tests'
montrent trs souvent des diffrences colossales. Il est certes facile de produire ces diffrences, mais trs
souvent on omet d'en donner les raisons, ce qui fait que l'intrt de ces tests n'est pas bien grand. Cela est
d'autant plus vrai que l'on peut produire les mmes diffrences entre deux applications utilisant ADO.NET.
Informations de schma
U
Lorsqu'on travaille avec ADO, on dlgue un certain nombre de taches aux divers fournisseurs de
services. C'est la puissance de ceux-ci qui permettent une programmation trs simple mais il y a un cot en
terme de performance. Lorsqu'on cre un Recordset ct client, le moteur de curseur gre la rcupration des
informations de schma. Globalement cela permet une programmation plus gnrique et limite les
connaissances ncessaires en programmation des SGBD. Malheureusement cette rcupration se produit
l'excution et se produit pour chaque objet Recordset. Plus le schma est complexe, plus les oprations sont
lourdes et il n'est plus possible d'optimiser pass un certain point.
Cration ou excution
U
Si avec ADO il n'y a pas de gain de temps notable lorsqu'on connat la source la cration, avec
ADO.NET cela peut changer normment la faon d'aborder la programmation. On peut dcider, en change
d'un travail la cration de lier son application la source afin d'conomiser du temps d'excution. Bien sur
cela n'a pas lieu d'tre lors de la fabrication d'une application gnrique, mais dans la plupart des applications
cela peut augmenter fortement les performances.
Rcupration du schma l'excution
La rcupration des informations de schma est coteuse lorsqu'elle est dynamique. Dans ADO.NET, il
y a plusieurs faon de grer les mta-donnes de la source. La mthode FillSchema du DataAdapter est
dynamique mais nuit aux performances, utiliser des schmas XSD est un meilleur compromis. Travailler sur
un schma dfini la conception permet un gain de performance contre une perte de souplesse.
Dataset fortement typ
Il s'agit de crer une classe drive du Dataset autour d'un schma dfini. Vous pouvez soit partir de
l'utilitaire xsd.exe et d'un fichier de schma XSD, soit utiliser l'environnement de dveloppement, soit
gnrer vous-mme la classe. Ce type de Dataset perd une grande part de sa souplesse puisqu'il est construit
autour d'une source dfinie. Toute modification de structure l'excution induit un travail important de
rgnration. Par contre, il y a un gain important dans la qualit du code dvelopp en utilisant de tels
Dataset. Le gain en terme de performances est quant lui du l'utilisation de DataColumn plutt que de nom
de champs, ce qui fait qu'il n'est pas ncessaire d'utiliser un Dataset fortement typ pour obtenir de bonnes
performances. Nous verrons un exemple de ces Dataset dans l'exemple "Une base de donne locale".
Dsactivation des contraintes
Quel que soit le cas, votre Dataset possde gnralement des contraintes, souvent rcupres de la
source de donnes, dans certains cas cres par vous. Lors du remplissage du Dataset par les donnes de la
source, vous devez veiller dsactiver les contraintes importes de la source. En effet, chaque contrainte
induit une vrification de l'enregistrement import. Cette vrification coteuse en performances est inutile
puisque les donnes de la source respectent dj ces contraintes. Il existe plusieurs techniques que nous
tudierons pour viter cette redondance du contrle.
Vous ne pouvez pas procder ainsi pour les contraintes que vous avez ajoutes.
21/130
Gestion des noms de champs
Il s'agit l d'un problme assez similaire l'utilisation des objets Fields dans ADO. Il existe trois
mthodes pour dsigner un champ dans un enregistrement.
Par le nom du champ :
txtAuthor.Text = MonDs.Tables[0].Rows[0]["Author"];
Cela donne un code lisible et assez polyvalent mais de trs mauvaises performances.
Par la position ordinale
txtAuthor.Text = MonDs.Tables[0].Rows[0][1];
Les performances sont bien meilleures, mais la position ordinale dpend du texte de la requte et la
lisibilit du code est mdiocre.
Par l'objet DataColumn
txtAuthor.Text =
MonDs.Tables[0].Rows[0](MonDs.Tables[0].Columns["Author"]);
La notation est plus lourde mais les performances sont excellentes.
L'utilisation de la premire syntaxe devrait tre bannie de vos applications car elle n'est jamais rentable.
Je vous montrerai plus loin comment utiliser des codes mariant performances et lisibilit.
Programmation des SGBD administrs

Nous allons ici envisager un cas qui devrait tre le cas gnral, bien que ce soit loin d'tre encore le cas.
Il y a deux grandes familles de SGBD dont on ne parle jamais, celle que vous administrez et celle qui est
administre par quelqu'un d'autre.
Administrer une base de donnes est un mtier et de nombreux dveloppeurs ignorent les rudiments de
cette profession. Cela tend les faire dchanter lorsqu'ils doivent programmer une base de donnes qu'ils
n'ont pas cre.
Je vais donc parler ici des rgles couramment admises dans le dveloppement d'applications autour de
SGBD administrs, en esprant que cela vous donnera les ides claires quand il vous faudra aller ngocier
avec l'administrateur.
Proprits des objets et login

U
La plupart des SGBD dfinissent un propritaire pour les tables, requtes, vues, etc..
Ce propritaire possde les droits de modification et de suppression pour ses objets. Habituellement,
l'administrateur est le propritaire des principaux objets. Il restreint aussi la possibilit de crer des objets et /
ou d'y accder.
Comme les restrictions peuvent tre plus ou moins importantes, c'est par l'utilisation du Login qu'il
dfinit les droits de chaque utilisateur. Il vous faut donc tudier les droits vritablement ncessaires votre
application avant de ngocier la cration d'un login adapt votre application. Il est de toute faon peu
probable que tout les droits vous seront attribus, il convient donc d'analyser correctement le besoin.
Requtes et procdures stockes

U
Dans la plupart des cas, seules les requtes SELECT sont autorises librement. L'ensemble des requtes
actions est gnralement interdit par un appel SQL direct, et l'administrateur vous demandera d'agir sur la
base soit par l'appel de procdures et/ou de requtes stockes existantes, soit en lui fournissant la liste des
procdures / requtes que vous voulez qu'il ajoute dans la source.
Dans certains cas, mme la liste des vues est restreinte.
Si cette dmarche est tout fait lgitime de la part de l'administrateur cela peut vous causer des
problmes lors du dveloppement de vos applications. La grande majorit des administrateurs sont des gens
intelligents, commencez donc par aller discuter avec eux afin de connatre les rgles qu'ils souhaitent voir
appliques ainsi que les contraintes qu'il vous semble impossible de respecter.
Lorsqu'il ne s'agit que d'utiliser des requtes stockes, les contraintes ne sont pas bien grandes, par
contre il peut en aller tout autrement pour les procdures stockes.
U
22/130
Considrations sur les procdures stockes
Une procdure stocke est une suite de commandes crites dans un langage support par le SGBD. Cette
srie d'instructions peut tre vue comme plusieurs ordres SQL conscutifs du ct du programmeur. Sachez
que tous les SGBD ne supportent pas les mmes fonctionnalits, ds lors votre codage peut tre diffrent
selon la source de donnes.
Il n'est pas raliste d'utiliser une procdure stocke sans l'avoir lue et correctement comprise.
Globalement voil les problmes que l'on peut rencontrer.
Valeurs de compteur non retournes
Certaines tables utilisent un champ dit 'auto-incrment' pour gnrer la valeur de la cl primaire. Cette
valeur est fournie par le SGBD. Vous avez besoin de cette valeur pour crer des enregistrements lis.
Habituellement un paramtre de sortie renvoie cette valeur, mais certains administrateurs prfrent renvoyer
la ligne insre. Il est aussi possible que la procdure soit mal rdige et que la valeur ne soit pas renvoye.
Nombre de lignes modifies faux
On utilise ce nombre pour savoir la porte de la procdure. Il arrive qu'une procdure mal crite ne
renvoie pas le nombres de lignes affectes. Il arrive parfois aussi que le compte intgre les lignes cres pour
l'administration.
Mise jour diffre
Dans quelques rares cas, les modifications attendent une validation de l'administrateur avant d'tre
vritablement accepte par la source. Ceci peut tre transparent si le systme est bien gr, mais peut aussi
engendrer des problmes quasiment insurmontables. Il convient alors de voir avec l'administrateur les point
de blocage que vous rencontrez.
Lot de requtes
Certains SGBD renvoient des lots de requtes. Ceux-ci vont vous forcer une gestion particulire dans
votre code afin de ne pas polluer votre Dataset et votre code dcisionnel.
Gestion des erreurs du SGBD

U
Votre application ne pourra jamais faire de l'administration. Il faut clairement comprendre que les
erreurs que votre code peut rcuprer sont des erreurs vnielles pour le SGBD. Si celui rencontre de graves
erreurs il fermera votre connexion. Ce cas doit tre envisag mais il est sans solution dans le cadre d'une
application cliente.
Les erreurs engendres par votre code sont trs faciles corriger sur un SGBD administr. Elles peuvent
l'tre beaucoup moins si vous administrez vous-mme la base de donnes et si vous ne fixez aucune rgle.
Voil pourquoi je vous ai dit au dbut que vous devriez procder de faon identique avec vos propres bases
en tant un administrateur consciencieux pour vos propres sources de donnes.
N'oubliez jamais que l'intgrit des donnes est la seule rgle avec laquelle vous ne pouvez pas transiger.
23/130
Les classes ADO.NET
Comme chaque fois, nous allons visiter en dtail les classes fournis par ADO.NET. Dans ce cours je
travaillerais principalement autour de la base exemple 'Biblio.mdb' pour Access 2000 et donc avec les classes
de l'espace de nom System.Data.OleDB. Je vais privilgier ce fournisseur pour obtenir un code relativement
gnrique. Du fait des limitations d'Access et de la spcificit du fournisseur SQL-Server, un certains
nombre d'exemple utiliseront le fournisseur manag SQL-Server et la base exemple 'Pubs'
(System.Data.SqlClient).
Comme dans mes autres cours, la liste suivante n'est pas exhaustive, elle n'indique que les proprits /
mthodes utilises dans une programmation 'standard'. Les proprits videntes comme le nom des objets ou
les proprits / mthodes du l'hritage de la programmation des objets ne seront pas abords.
Les espaces de nom dans DotNet

Un espace de nom dans DotNet est une organisation de classes connexes. Il s'agit en fait d'une
modification de la notion de porte. Dans DotNet chaque objet possde un nom qui appartient un espace de
nom, le nom devant tre unique dans l'espace. Il est donc possible d'utiliser deux objets ayant le mme nom
dans un mme assembly pour peu que l'espace de nom soit donn avant l'objet. En gnral, on ne met qu'un
espace de nom dans un assembly et on peut alors utiliser directement l'objet sans donner son espace de nom.
Regardons l'exemple suivant :
private void button1_Click(object sender, System.EventArgs e)
{
string strConn, strSQL;
strConn = "Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data
Source=C:\\tutoriel\\biblio.mdb;";
System.Data.OleDb.OleDbConnection ConnAccess = new
System.Data.OleDb.OleDbConnection(strConn);
ConnAccess.Open();
strSQL = "SELECT Author FROM Authors WHERE Au_Id=1";
System.Data.OleDb.OleDbCommand CommandAccess = new
System.Data.OleDb.OleDbCommand(strSQL, ConnAccess);
textBox1.Text = CommandAccess.ExecuteScalar().ToString();
}

{
String strConn, strSQL;
strConn = "User ID=sa;Initial Catalog=pubs;Data Source=NOM-
SZ71L7KTH17\\TUTO;password=monpasse";
System.Data.SqlClient.SqlConnection ConnSQL = new
System.Data.SqlClient.SqlConnection(strConn);
ConnSQL.Open();
strSQL = "SELECT au_lname FROM Authors WHERE Au_Id='172-32-1176'";
System.Data.SqlClient.SqlCommand CommandSQL = new
System.Data.SqlClient.SqlCommand(strSQL, ConnSQL);
textBox2.Text = CommandSQL.ExecuteScalar().ToString();
}
Nous voyons donc que des objets similaires possdent une syntaxe diffrente ce qui nous permet de
travailler avec l'espace de nom System.Data. A part cette syntaxe il n'y a que peu de diffrences entre des
objets dfinis par les fournisseurs manags, je veux dire que par exemple les objets OLEDBConnection et
SqlConnection se manipulent de la mme manire.
24/130
La classe Dataset
Comme la programmation ADO.NET tourne principalement autour de l'objet Dataset, nous allons
commencer par lui. Le Dataset peut donc tre vu comme un magasin de donnes, l'enjeu tant de ne pas le
transformer en dpotoir. Un Dataset est un container pour des objets DataTable et DataRelation. Pour
schmatiser, on dira qu'un Dataset sans donnes est li un fichier de schma XSD et qu'un Dataset rempli
est li un fichier XMLDataDocument. Cette liaison passe travers un certain nombre de mthode qui
permettent de pouvoir synchroniser l'un et l'autre. En soi, un Dataset n'a pas d'autre fonction que de vhiculer
un schma.
ExtendedProperties & PropertyCollection

U
Les objets Dataset, DataColumn, DataTable, DataRelation et Constraint possdent une collection
PropertyCollection qui permet l'utilisateur de rajouter des proprits personnalises ces objets.
Ces proprits s'utilisent comme n'importe quelle proprit. Elles doivent tre de type String pour tre
transmises au fichier XML.
{
strConn = "Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data
strSQL = "SELECT * FROM Authors";
OleDbDataAdapter MonDA As = OleDbDataAdapter(strSQL, strConn);
DataSet MonDataset = New DataSet("Auteurs");
MonDA.Fill(MonDataset);
MonDataset.ExtendedProperties.Add("TimeStamp",DateTime.Now);
Me.DataGrid1.DataSource = MonDataset.Tables[0];
}
private void dataGrid1_DataSourceChanged(object sender, System.EventArgs

e)
{
DataSet UnDataset = CType(Me.DataGrid1.DataSource.Dataset, DataSet);
MessageBox.Show(UnDataset.ExtendedProperties("TimeStamp").ToString());
}
Proprits
U
CaseSensitive (Boolen)
Dfinit si les objets DataTable qui composent le Dataset sont sensibles la casse lors des oprations de
recherche, de tri et de filtrage. Comme cette proprit existe aussi pour l'objet DataTable, la dfinition au
niveau du Dataset revient la dfinition de la proprit pour chacun des DataTable.
DefaultViewManager (DataViewManager)
Renvoie le DataViewManager utilis par dfaut pour grer les vues du Dataset. Nous verrons le
fonctionnement des vues un peu plus loin.
EnforceConstraints (Boolen)
Dfinit si les contraintes doivent tre appliques. Typiquement, on dsactive les contraintes lors de la
rcupration des donnes d'une source ou celles-ci ont dj t valides. Certain dveloppeurs prfrent
rapatrier les donnes puis ajouter les contraintes mais cela n'a pas vritablement de sens mes yeux. En effet,
si l'on procde une mise jour d'un Dataset existant, il paratrait incohrent de supprimer toutes les
contraintes pour les rtablir aprs la rcupration.
25/130
Lors du rtablissement des contraintes, il y aura leve d'une exception si des donnes ne les respectent
pas. On peut se demander alors s'il est intressant de les dsactiver puisque le contrle a lieu de toute faon.
Cependant, ce contrle est beaucoup plus rapide sur les lignes du Dataset dans le cache client que lors d'un
contrle pendant la rcupration ligne par ligne.
Les lignes violant les contraintes peuvent tre rcupres l'aide de la mthode GetErrors.
HasErrors (Boolen)
Renvoie vrai si une DataTable du Dataset possde une ligne au moins en erreur. Cette proprit existe
aussi au niveau de la table.
void VerifErreur(DataSet MyDataset)
{
if (MyDataset.HasErrors)
{
DataRow[] LigneErreur;
foreach (DataTable MaTable in MyDataset.Tables)
if (MaTable.HasErrors)
LigneErreur = MaTable.GetErrors();
}
}Locale (CultureInfo)
Dfinit les informations de langue utilises par le tri.
Relations (DataRelationCollection)
Obtient la collection des relations qui relient des tables et permettent de naviguer des tables parentes aux
tables enfants.
Tables (DataTableCollection)
Obtient la collection des tables contenues dans le DataSet.
Mthodes
U
AcceptChanges
Valide toutes les modifications en cours. La mme mthode existe pour les objets DataTable et
DataRow. L'appel au niveau du Dataset bascule toutes les lignes de toutes les tables du Dataset vers l'tat
'Unchanged'.
Clear
Supprime toutes les lignes de toutes les tables du Dataset. Lve une exception si le Dataset est li un
XMLDataDocument. Dans ce cas vous devez supprimer les lignes une une.
Clone
Renvoie une copie du schma dans un nouveau Dataset. Les donnes ne sont pas copies.
Copy
Renvoie une copie du Dataset dans un nouveau Dataset. Les donnes sont copies.
GetChanges
Envoie une copie du Dataset contenant toutes les lignes en cours de modification. Accepte une surcharge
permettant de limiter le duplicata en fonction de la valeur DataRowState. Les relations peuvent entraner la
prsence de lignes qui ne sont pas en cours de modification dans le nouveau Dataset. Ceci veut dire que
lorsqu'une ligne d'une table parente est modifie, les lignes en relation de la table enfant seront incluses dans
le Dataset.
26/130
HasChanges (Boolen)
Renvoie vrai si une ou plusieurs lignes sont modifies.
Merge
Permet de fusionner deux Dataset. Il est trs important de bien comprendre comment fonctionne cette
mthode, aussi allons nous en parler assez souvent tout au long de ce cours. ADO.NET cherche constamment
russir la fusion quel que soit le scnario. S'il n'est pas simple de faire chouer la fusion, il est par contre
assez simple d'obtenir un rsultat diffrent de celui escompt.
La fusion procde toujours par identification des noms locaux. C'est dire que lorsqu'un objet existe
dans un Dataset mais pas dans l'autre, il y a ajout de l'objet la collection dans le Dataset fusionn. Par
exemple:
{
string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data
string strSQL = "SELECT * FROM Authors";
OleDbDataAdapter MonDA = new OleDbDataAdapter(strSQL, strConn);
DataSet MonDataset = new DataSet("Auteurs");
DataSet DatasetCible = new DataSet();
DatasetCible.MergeFailed += new
MergeFailedEventHandler(DatasetCible_MergeFailed);
MonDA.Fill(DatasetCible, "Authors");
DatasetCible.Merge(MonDataset);
foreach (DataTable maTable in DatasetCible.Tables)
Console.WriteLine(maTable.TableName);
}
void DatasetCible_MergeFailed(Object sender, MergeFailedEventArgs e)

{
MessageBox.Show("La fusion a chou");
}
Bien que stricto sensu j'ajoute deux fois la mme table, le Dataset rsultant contient deux tables appeles
'Authors' et 'Table' ; nous verrons le pourquoi dans l'tude du mappage des tables par le DataAdapter.
Il y a l un premier danger car par dfaut, un DataAdapter donne toujours le mme nom aux objets
mapps. Imaginons le cas suivant :
{
MonDA.SelectCommand.CommandText = "SELECT * FROM Publishers";
MonDA.Fill(DatasetCible);
dataGrid1.DataSource = DatasetCible.Tables(0);
}
27/130
Dans ce cas, je construis deux Dataset contenant chacun une table diffrente. Lors de la fusion, les deux
tables s'appellent 'table' dans leur Dataset respectif. Comme il y a identit de noms, il y a fusion en une seule
table. Je cre une table qui contient tous les champs de chaque table et tous les enregistrements. Comme il
n'y pas d'identit, tous les champs appartenant une table ont une valeur NULL pour les enregistrements
de l'autre table. Ceci arrive aussi car il n'y a pas de contraintes sur mes tables. Selon les cas, la situation peut
rapidement se complexifier. Si mon code de remplissage est :
MonDA.FillSchema(DatasetCible, SchemaType.Source);
Je vais obtenir une exception de type ArgumentNullException, car la table du dataset DatasetCible
possde une cl primaire. Comme il n'y a pas de possibilit d'ajouter une valeur NULL dans un champ de la
cl primaire, une exception est leve. Par contre si mon code est:
MonDataset.Tables[0].Constraints.Add("pk1",
MonDataset.Tables[0].Columns[0],true);
C'est une ConstraintException qui va tre leve.
Jusque l, bien qu'ayant toujours dclar l'vnement MergeFailed, il ne c'est jamais dclench. Ceci
vient du fait que la fusion est considre comme russie lorsque la fusion des schmas est ralisable.
Je vais maintenant mlanger mes deux codes prcdents.
{
MonDataset.Tables[0].Columns[0],true);
MonDA.FillSchema(DatasetCible, SchemaType.Source);
dataGrid1.DataSource = DatasetCible.Tables[0];
}
void DatasetCible_MergeFailed(object sender, MergeFailedEventArgs e)

{
MessageBox.Show("La fusion a chou");
}
L'vnement se dclenche car il n'y a pas possibilit de fusionner deux tables portant le mme nom mais
dont le champ de cl primaire ne porte pas le mme nom. Dans les cas prcdents, j'obtenais une table
contenant tous les champs des deux tables, mme si toutes les lignes ne pouvaient pas tre fusionnes, dans
celui-ci il n'y a pas fusion.
Donc pour fusionner deux tables il faut qu'elles possdent une cl primaire identique. Ds lors il y a
fusion des schmas, puis tentative d'ajout des lignes de la table entrante.
28/130
Si une ligne entrante possde la mme valeur de cl qu'une ligne existante, les champs communs aux
deux tables prennent les valeurs entrantes.
Ce comportement n'est pas toujours le mme, il dpend du paramtre MissingSchmaAction. De la
mme faon, lorsque des modifications sont en cours dans un Dataset, vous pouvez ou non forcer la
conservation de ces modifications. C'est pour cela que je vous conseille d'utiliser la surcharge :
Public void Merge(DataSet Dataset, Boolean PreserveChanges, MissingSchemaAction
MissingSchemaAction);
Ou MissingSchemaAction peut prendre les valeurs suivantes.
Nom Description
Add Ajoute les colonnes ncessaires pour achever le schma.
AddWithKey Ajoute les colonnes et les informations de cl primaire ncessaires pour achever le
schma.
Error Une exception InvalidOperationException est gnre si le mappage de colonnes
spcifi est manquant.
Ignore Ignore les colonnes supplmentaires.
Nous reviendrons sur la mthode Merge lors de l'tude des actualisations.
RejectChanges
Rejette l'ensemble des modifications en attente sur toutes les tables du Dataset.
Reset
Rinitialise le Dataset dans son tat d'origine.
Proprits & mthodes lies au XML

U
Je spare dans cet objet ce qui est li la manipulation des XML car un certain nombre d'explications
est ncessaire. L'criture d'un fichier XML est assez simple avec les mthodes intgres dans ADO.NET
mais le fichier XML obtenu peut tre sensiblement diffrent selon le paramtrage des objets.
Nous allons utiliser le code suivant comme base de travail pour l'tude des proprits XML de l'objet
Dataset
{
//MonDataset.Namespace = "DemoName"
//MonDataset.Prefix = "DemoPrefix"
MonDataset.WriteXmlSchema("c:\\tutoriel\\schema.xml");
}
Proprits NameSpace et Prefix

Permettent de dfinir un espace de nom et un prfixe XML lors de l'criture du fichier. Si cela n'a pas
d'importance pour l'criture du fichier, cela peut permettre de limiter les informations rcupres lors de la
lecture. En effet, un Dataset ne rcupre que les donnes ayant le mme espace de nom et le mme prfixe
que lui lors de la lecture d'un fichier XML.
29/130
Mthode WriteXMLSchma & ReadXmlSchema
Dans le cas de notre exemple, le fichier rsultant sera de la forme :
<?xml version="1.0" standalone="yes" ?>
T T T T
- <xs:schema id="Auteurs" xmlns=""

HTU UTH T T T T T T T T
xmlns:xs="http://www.w3.org/2001/XMLSchema" T T T T
xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> T T T T
- <xs:element name="Auteurs" msdata:IsDataSet="true" msdata:Locale="fr-

HTU UTH T T T T T T T T T T T T
FR"> T T
- <xs:complexType> HTU UTH T T T T
- <xs:choice maxOccurs="unbounded"> HTU UTH T T T T T T
- <xs:element name="Table"> HTU UTH T T T T T T
- <xs:sequence> HTU UTH T T T T
<xs:element name="Au_ID" type="xs:int" T T T T T T T T T T T T T T
minOccurs="0" /> T T T T
<xs:element name="Author" type="xs:string" T T T T T T T T T T T T T T
minOccurs="0" /> T T T T
<xs:element name="Year_x0020_Born" T T T T T T T T T T
type="xs:short" minOccurs="0" /> T T T T T T T T
</xs:sequence> T T T T T T
</xs:complexType> T T T T T T
</xs:element> T T T T T T
</xs:choice> T T T T T T
</xs:element>T T T T T T
T </xs:schema>
T T T T T
Je vous ai parl plus avant des objets Dataset fortement typs, c'est dire construits autour d'une source
dfinie. Nous pouvons nous demander si notre schma XML est identique au schma d'un Dataset fortement
typ de la mme table.
<?xml version="1.0" standalone="yes"?>
<xs:schema id="AuteurTyped"
targetNamespace="http://www.tempuri.org/AuteurTyped.xsd"
xmlns:mstns="http://www.tempuri.org/AuteurTyped.xsd"
xmlns="http://www.tempuri.org/AuteurTyped.xsd"
xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-
com:xml-msdata" attributeFormDefault="qualified" elementFormDefault="qualified">
<xs:element name="AuteurTyped" msdata:IsDataSet="true" msdata:Locale="fr-FR">
<xs:complexType>
<xs:choice maxOccurs="unbounded">
<xs:element name="Authors">
<xs:complexType>
<xs:sequence>
<xs:element name="Au_ID" msdata:AutoIncrement="true" type="xs:int" />
<xs:element name="Author" type="xs:string" minOccurs="0" />
<xs:element name="Year_x0020_Born" type="xs:short" minOccurs="0" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
<xs:unique name="Constraint1" msdata:PrimaryKey="true">
<xs:selector xpath=".//mstns:Authors" />
<xs:field xpath="mstns:Au_ID" />
</xs:unique>
</xs:element>
</xs:schema>
30/130
Nous voyons que tel n'est pas le cas. Un Dataset fortement typ possde des informations de schma que
mon schma ne possde pas. Je pourrais pourtant aisment reproduire le mme fichier en rcuprant
correctement le schma de ma source et en faisant attention au nom lors du mappage des donnes. Le schma
obtenu par la mthode WriteXMLSchema produit donc bien un fichier de Schma XSD, mais celui-ci sera
compos des informations de schma prsentes dans le Dataset.
La mthode ReadXmlSchema permet de donner un schma au Dataset par la lecture d'un fichier XML,
celui-ci pouvant ventuellement contenir des donnes.
Mthode InferXMLSchma.
Cette mthode doit tre utilise avec prcaution voire ignore en raison des risques qu'elle prsente.
Cette mthode tente de dfinir le schma en fonction des donnes du fichier XML. Vous pouvez tre peu
prs certains que tous vos champs seront de types chane et qu'il n'y aura aucune contrainte.
Mthode WriteXML & ReadXml
Pour ces mthodes comme pour les prcdentes je travaille partir d'un fichier. Cependant elles
acceptent aussi des objets TextReader, TextWriter, XMLReader et XMLWriter ainsi que les objets Stream.
La mthode WriteXML crit un Dataset avec les donnes qu'il contient. Nous verrons dans l'tude des
DataColumn et des DataRelation qu'il peut tre crit diffremment. La mthode accepte un paramtre
important XMLWriteMode qui peut prendre les valeurs suivantes :
Nom Description
DiffGram Permet d'crire les modifications en cours dans le fichier XML.
IgnoreSchema crit le contenu actuel de DataSet en tant que donnes XML.
WriteSchema crit le contenu actuel de DataSet en tant que donnes XML, avec la structure
relationnelle comme schma XSD.
La mthode ReadXML remplit un Dataset en partant d'un fichier XML. A l'identique de la mthode
WriteXML, elle accepte un paramtre XMLReadMode qui peut prendre une des valeurs ci-dessous :
Nom Description
Auto Membre par dfaut. Tente d'utiliser le mode le plus appropri
DiffGram Lit un DiffGram en affectant les modifications du DiffGram au DataSet. La smantique
est identique celle d'une opration Merge. Comme lors de l'opration Merge, les
valeurs RowState sont conserves. L'entre pour ReadXml l'aide de DiffGrams doit
uniquement tre obtenue en utilisant la sortie de WriteXml en tant que DiffGram.
Le DataSet cible doit avoir le mme schma que le DataSet sur lequel WriteXml est
appel en tant DiffGram. Sinon, l'opration de fusion du DiffGram choue, provoquant
la leve d'une exception.
Fragment Lit des documents XML, tels ceux qui sont gnrs suite l'excution de requtes FOR
XML, sur une instance de SQL Server. Lorsque la valeur de XmlReadMode est
Fragment, l'espace de noms par dfaut est lu en tant que schma inline.
IgnoreSchema Ignore tout schma inline et lit les donnes dans le schma DataSet existant. Si des
donnes ne correspondent pas au schma existant, elles sont ignores (y compris les
donnes d'espaces de noms diffrents dfinis pour le DataSet). Si les donnes sont un
DiffGram, IgnoreSchema fonctionne comme DiffGram.
InferSchema Ignore tout schma inline, obtient le schma partir des donnes et charge ces
dernires. Si DataSet contient dj un schma, le schma en cours est tendu par l'ajout
de nouveaux tableaux ou l'ajout de colonnes aux tableaux existants. Une exception est
leve si le tableau obtenu existe dj avec un espace de noms diffrent, ou si une ou
plusieurs des colonnes obtenues entrent en conflit avec des colonnes existantes.
ReadSchema Lit tout schma inline et charge les donnes. Si DataSet contient dj un schma, de
nouveaux tableaux peuvent tre ajouts ce dernier, mais une exception est leve si un
tableau du schma inline existe dj dans DataSet.
Nous reviendrons dans la troisime partie sur la manipulation des fichiers XML.
U
31/130
Evnements
MergeFailed
Se dclenche lors de l'chec de la mthode Merge c'est dire lorsque les schmas ne peuvent tre
fusionns en fonction du paramtre MissingSchemaAction.
La classe DataTable
Cet objet est trs similaire au Dataset et conceptuellement identique une table de base de donne. On
peut voir la DataTable comme le croisement d'une collection de colonnes (les champs) et de lignes (les
donnes). La table est donc container d'une collection de DataColumn et de DataRow. Elle possde aussi des
contraintes. Ds prsent il faut faire la diffrence entre les contraintes d'une table et celles d'une colonne.
N'hsitez pas lire la documentation du site de Frdric Brouard.
La plupart des proprits et mthodes sont les mmes que pour l'objet Dataset je n'y reviendrais pas ici.
Les noms des tables ne sont normalement pas sensibles la casse, sauf si deux tables existent avec une
casse diffrente dans le mme Dataset. Faite attention lors de la cration de vos tables.
Construction d'une table par le code

U
Lorsqu'on souhaite ajouter une table par programmation, on doit respecter un ordre bien dfini.
Ajout des colonnes
Ajout de la table au Dataset
Ajout des contraintes
Ajout des lignes
Il est tout fait de possible de remplir une table cre par le code avec des donnes tires d'une source
existantes. En effet, il n'y a pas rcupration du schma sur un schma existant si ceux-ci sont identiques.
L'ajout des lignes quant lui repose toujours sur une question de cl primaire.
Mise jour des tables

U
Quel que soit le mode de remplissage de la table (Merge d'un Dataset, lecture XML, Ajout par code) il
y a toujours comparaison des valeurs de cl primaire si celle-ci existe. Si la cl primaire n'existe pas toute
opration de ligne sur la table ajoute une ligne. Si la cl primaire existe, il y a mise jour d'une ligne
possdant une valeur de cl identique une ligne existante et ajout sinon.
Je vais prendre un exemple simple pour illustrer mon propos.
{
//MonDA.FillSchema(MonDataset, SchemaType.Source)
MessageBox.Show(MonDataset.Tables[0].Rows.Count.ToString());
MessageBox.Show(MonDataset.Tables[0].Rows.Count.ToString());
}
En l'tat mon code va afficher 6246 puis 12492. Par contre si je valide la ligne en commentaire, il va
afficher deux fois 6246. Ceci vient du fait que la ligne de rcupration de schma va attribuer la contrainte de
cl primaire la colonne 'Au_Id'. Ds lors, comme toutes les lignes existent dj dans la table, il y aura
rafrachissement des lignes. Ce code est un exemple. N'oubliez pas que les rcuprations de schma sont trs
onreuses en terme d'efficacit.
U
32/130
Mthodes de DataTableCollection
Add
Ajoute une table la collection des tables du Dataset. La mthode autorise le passage d'une chane ou
d'un objet DataTable comme paramtre. Comme je vous l'ai signal, il vaut mieux crer le schma de la table
avant de l'ajouter la collection.
DataTable MaTable =new DataTable("Correcteurs");
MaTable.Columns.Add("Co_id", Type.GetType("System.Int32")).AutoIncrement
= true;
MaTable.Columns.Add("Co_Name", Type.GetType("System.String"));
MaTable.Constraints.Add("pk1", MaTable.Columns[0], true);
MonDataset.Tables.Add(MaTable);
Attention au respect de la casse dans la syntaxe "System.Int32"

AddRange
Ajoute un tableau d'objets DataTable la fin de la collection.
{
//MonDA.FillSchema(MonDataset, SchemaType.Source)
DataTable MaTable1 =new DataTable("Correcteurs");
MaTable1.Columns.Add("Co_id", Type.GetType("System.Int32")).AutoIncrement
= true;
MaTable1.Columns.Add("Co_Name", Type.GetType("System.String"));
MaTable1.Constraints.Add("pk1", MaTable1.Columns[0], true);
DataTable MaTable2 =new DataTable("Correcteurs_Auteurs");
MaTable2.Columns.Add("Co_id", Type.GetType("System.Int32"));
MaTable2.Columns.Add("Au_id", Type.GetType("System.Int32"));
MaTable2.PrimaryKey = new DataColumn[] {MaTable2.Columns[0],
MaTable2.Columns[1]};
MonDataset.Tables.AddRange(new DataTable[] {MaTable1, MaTable2});
MessageBox.Show(MonDataset.Tables.Count.ToString());
}
CanRemove
Vrifie si une table peut tre supprime de la collection.
Clear
Supprime toutes les tables de la collection.
Contains
Renvoie vrai si la table dont le nom est pass en paramtre appartient la collection.
IndexOf
Renvoie la position ordinale de la table dont le nom est pass en paramtre.
33/130
Remove & RemoveAt
Supprime la table passe en paramtre. Accepte le nom ou l'objet. RemoveAt fonctionne avec l'index.
if (MonDataset.Tables.Contains("Correcteurs"))
if (MonDataset.Tables.CanRemove(MonDataset.Tables["Correcteurs"]))
MonDataset.Tables.RemoveAt(MonDataset.Tables.IndexOf("Correcteurs"));
La syntaxe de cet exemple est trs mauvaise. Il ne s'agit ici que d'exemple de possibilits d'criture.
Proprits de DataTable
U
ChildRelations (DataRelationCollection)
Renvoie la collection des relations enfants de l'objet DataTable. Les relations enfants sont celles ou la
table cible fournit sa cl primaire comme cl trangre de la table enfant.
Columns (DataColumnCollection)
Renvoie la collection des objets DataColumn de la table.
Constraints (ConstraintCollection)
Renvoie la collection des contraintes de la table.
DefaultView (DataView)
Renvoie le DataView associ la table.
ParentRelations (DataRelationCollection)
Renvoie la collection des relations parents de l'objet DataTable. Les relations parents sont celles ou la
table cible contient la cl trangre.
PrimaryKey (DataColumn)
Dfinit ou renvoie un tableau d'objets DataColumn qui contient la ou les colonnes composant la cl
primaire. Il s'agit d'une alternative l'utilisation de la collection des contraintes.
Rows (DataRowCollection)
Renvoie la collection des lignes de la table.
Mthodes de DataTable
U
BeginLoadData & EndLoadData

Dsactive ou active les notifications, la gestion d'index et les contraintes lors du chargement de donnes
par la mthode LoadDataRow.
Compute
Public Object Compute(String expression, String filter);
Calcule la valeur passe dans expression sur les lignes qui respectent le paramtre Filter.
Object objMoy;
objMoy = MonDataset.Tables[0].Compute("avg([year born])", "[year born] is
not null");
textBox1.Text = Convert.ToString(objMoy);
34/130
ImportRow
Importe la ligne passe en paramtre dans la Table. La ligne est importe telle quelle et conserve sa
valeur d'tat.
LoadDataRow
Public DataRow LoadDataRow(Object [] values, Boolean fAcceptChanges);
Modifie ou ajoute une ligne avec les valeurs passes dans le tableau. Le tableau values() doit contenir
autant de valeurs qu'il y a de champs dans la table. Si un champ possde une valeur par dfaut vous pouvez
passer la valeur NULL pour que la ligne prenne la valeur par dfaut. Passez aussi NULL dans les colonnes
auto-incrmentes pour que la table gnre la valeur.
La mthode utilise le tableau values() pour calculer la valeur de la cl primaire dans le contexte de la
table. Si une cl quivalente existe dans la table, la ligne est mise jour sinon elle est ajoute.
Si fAcceptChanges vaut True ou est omis, la mthode AcceptChanges est appele sur la ligne, sinon la
valeur d'tat de la ligne passe Added ou Modified.
Cette mthode s'utilise gnralement avec les mthodes BeginLoadData et EndLoadData.
NewRow
Cre une nouvelle ligne qui respecte le schma de la table. Cette ligne n'est pas implicitement ajoute
la table, vous devez donc grer cet ajout par votre code. A la diffrence de la mthode prcdente, il doit y
avoir respect des contraintes pour la ligne ajoute. Regardons l'exemple suivant.
Object[] RowValues = {1, "Rabilloud J-M", 1967};
MonDataset.Tables[0].PrimaryKey = new
DataColumn[]{MonDataset.Tables[0].Columns[0]};
MonDataset.Tables[0].BeginLoadData();
MonDataset.Tables[0].LoadDataRow(RowValues, true);
MonDataset.Tables[0].EndLoadData();
DataRow MaLigne = MonDataset.Tables[0].NewRow();
MaLigne[MonDataset.Tables[0].Columns[0]] = 1;
MaLigne[MonDataset.Tables[0].Columns[1]] = "Rabilloud J-M";
MaLigne[MonDataset.Tables[0].Columns[2]] = 1967;
MonDataset.Tables[0].Rows.Add(MaLigne);
La mthode LoadDataRow va remplacer une ligne existante, mais vous aurez une exception lors de
l'ajout de la ligne 'MaLigne' puisque la ligne existe dj.
Select
Permet de rcuprer un tableau d'objet DataRow rpondant un filtre. Le tableau peut tre
ventuellement tri.
Public DataRow[] Select(String filterExpression, String sort, DataViewRowState recordStates);
Cette syntaxe est une surcharge, il est possible d'omettre des paramtres. Examinons ceux-ci
successivement. N'oubliez pas que l'objet renvoy est toujours un tableau d'objets DataRow.
FilterExpression est l'quivalent d'une clause WHERE SQL sans le mot cl WHERE. Pour ceux d'entre
vous qui avez utilis la mthode Find ADO, la syntaxe est identique.
Sort est l'quivalent de la clause ORDER BY SQL sans le mot cl ORDER BY. On utilise le mot cl
DESC pour trier dans l'ordre dcroissant.
RecordStates permet de limiter la mthode des lignes possdant des tats particuliers.
35/130
DataTable MaTable = MonDataset.Tables[0];
DataRow[] tabResult;
tabResult = MaTable.Select("Au_id<100");
MessageBox.Show(tabResult.GetUpperBound(0).ToString());
tabResult = null;
tabResult = MaTable.Select("Au_id<100", "Author DESC");
MessageBox.Show(Convert.ToString( tabResult[0][0]));
tabResult = null;
tabResult = MaTable.Select("Au_id<100", " Author DESC",
DataViewRowState.Added);
MessageBox.Show(Convert.ToString(tabResult.GetUpperBound(0)));
Il est possible d'utiliser des caractres gnriques pour le filtre et de composer les critres. Un exemple
valide est :
tabResult = MaTable.Select("Author like '%john%' AND [year born] IS NOT NULL");
N'oubliez pas que la dfinition de la proprit CaseSensitive peut influer sur le tri.
Les rgles sur les dlimiteurs s'appliquent.
Evnements de DataTable
U
ColumnChanging & ColumnChanged

void MaTable_ColumnChanged(Object sender,
System.Data.DataColumnChangeEventArgs e)
void MaTable_ColumnChanging(Object sender,
System.Data.DataColumnChangeEventArgs e)
Se produit chaque fois que la valeur d'une colonne est modifie. Ce concept est toujours un peu difficile
cerner car il faut voir dans ce cas la colonne non comme le champ stricto sensu mais plutt comme le
champ d'une ligne. Il s'agit donc bien des modifications de donnes.
Les arguments de l'vnement renvoient la ligne et la colonne ainsi que la valeur propose pour la
donne.
RowChanging & RowChanged
void MaTable_RowChanging(Object sender,System.Data.DataRowChangeEventArgs e)
void MaTable_RowChanged(Object sender, System.Data.DataRowChangeEventArgs e)
Se produit lorsqu'une ligne est modifie. Les arguments de l'vnement renvoient la ligne concerne
ainsi qu'un paramtre action qui dfini l'action en cause. Celui-ci peut prendre une des valeurs suivantes.
Nom Description Valeur
Nothing La ligne n'a pas t modifie. 0
Delete La ligne a t supprime de la table. 1
Change La ligne a t modifie. 2
Rollback La dernire modification de la ligne a t annule. 4
Commit Les modifications de la ligne ont t valides. 8
Add La ligne a t ajoute la table. 16
RowDeleting & RowDeleted

Se produit lorsqu'une ligne est supprime de la table.
La classe DataColumn
Un objet DataColumn reprsente le champ d'une table. Il n'est jamais possible d'accder une valeur de
donnes uniquement par le champ. Il y a donc une dualit dans le concept de colonne. Soit-on entend par-l,
la colonne d'une table qui reprsente un champ, soit la colonne d'une ligne qui cible une valeur. Dans ce
chapitre, c'est l'objet 'champ' qui nous intresse.
U
36/130
Colonne auto-incrmente
S'il est vrai que l'enfer est pav de bonnes intentions, nous tenons l une trs belle dalle. Ce problme
n'est d'ailleurs pas tant d aux colonnes 'auto-incrmentes' qu'aux colonnes de cls primaires non
informationnelles. Je dveloppe brivement. Une cole de pense des SGBD consiste dire qu'une bonne cl
est une cl purement informatique, sur une seule colonne de la taille du mot du processeur ; c'est dans ce
contexte que s'utilise une colonne auto-incrmente. Si je ne conteste pas qu'en termes de vitesse ce soit
idal, dans une approche multi utilisateurs je suis beaucoup plus rserv. Une colonne auto-incrmente
revient demander au SGBD d'attribuer une valeur forcment unique chaque enregistrement. Comme elle
n'est lie en aucune manire une quelconque information, elle ne garantit pas l'absence de doublons et elle
ne permet pas d'avoir le moindre commencement de soupons de la prsence d'un enregistrement identique.
Bref il s'agit d'un mcanisme qui utilis seul est assez inefficace. C'est pour cela qu'en gnral on ajoute une
contrainte d'unicit sur un chantillon de colonne de la table.
Mais revenons nos moutons, votre table dans votre Dataset n'est pas lie la source de donnes.
Lorsque vous dfinissez une colonne auto-incrmente dans votre DataTable, vous allez devoir lui attribuer
une valeur d'incrment et une valeur de dpart, en vous assurant qu'elle ne risque pas de donner une valeur
existant dj dans la table. Une ide qui vient spontanment consiste prendre comme valeur de dpart la
plus grande valeur prsente dans la table. Il s'agit pourtant d'une des plus mauvaises ides dans la longue
histoire des mauvaises ides. En effet, il existe une bonne chance que le numro que le SGBD fournira entre
dans une sorte de conflit masqu avec vos propres numros. Je vous donne un exemple de ce scnario
catastrophe dans la troisime partie.
Sachez ds prsent que les colonnes auto-incrmentes d'une base de donnes vous forceront une
programmation plus ou moins immonde pour grer correctement le cas.
Type de donnes
U
Une colonne de table possde toujours un type. Le type de votre table doit tre cohrent avec celui de la
table source. Il y a un mappage entre les types de votre table et ceux de la table source.
Utiliser les types de votre espace de nom
Chaque espace de nom possde une numration (OleDBType par exemple) qui permet de faire
l'quivalence entre le type de la source et le type du DataColumn. Lorsque vous crez votre table par le code
dans l'intention d'y rapatrier des donnes, vous devez chercher un type acceptable sans quoi il y aura leve
d'une exception s'il y a dperdition d'information.
Utiliser des types SQL-Server
Ceci n'est possible que pour un travail avec SQL-Server. Il existe un ensemble de classes contenues dans
l'espace de nom 'System.Data.SqlTypes'. Il ne faut pas confondre cela avec les numrations de type prsents
dans les espaces de noms SQL, OLEDB et ODBC. Le tableau suivant montre le mappage des types.
Type SqlTypes .NET Type SqlDbType .NET
Type SQL-Server natif
Framework Framework
binary SqlBinary Binary
Bigint SqlInt64 BigInt
Char SqlString Char
datetime SqlDateTime DateTime
decimal SqlDecimal Decimal
Float SqlDouble Float
image SqlBinary Image
Int SqlInt32 Int
Money SqlMoney Money
nchar SqlString NChar
37/130
Type SqlTypes .NET Type SqlDbType .NET
Type SQL-Server natif
Framework Framework
Ntext SqlString NText
nvarchar SqlString NVarChar
Numeric SqlDecimal Numeric
Real SqlSingle Real
smalldatetime SqlDateTime SmallDateTime
smallint SqlInt16 SmallInt
smallmoney SqlMoney SmallMoney
sql_variant Object Variant
sysname SqlString VarChar
text SqlString Text
timestamp SqlBinary TimeStamp
tinyint SqlByte TinyInt
varbinary SqlBinary VarBinary
varchar SqlString VarChar
uniqueidentifier SqlGuid UniqueId
Il y a plusieurs avantages inhrents l'utilisation des classes SqlTypes.
La rapidit : Pour communiquer entre les types du FrameWork et les types natifs, il y a
conversion dans ces classes. Travailler directement avec diminue le temps de conversion.
La scurit : Il y a une nette diminution du risque de faute de conversion.
Un certain nombre de fonctionnalits sont accessibles avec ses classes. Il y a notamment la leve
d'exception en cas de troncature ou la gestion pour tous les types de la valeur Null.
Mthode Add de DataColumnCollection

U
Il existe plusieurs versions surcharges. Utilisez de prfrence

Public void Add(DataColumn column);
Plutt que
Public virtual DataColumn Add(string columnName, Type type);
Proprits de DataColumn
U
AllowDbNull (Boolen)
Dfinit ou renvoie True si la colonne accepte les valeurs NULL
AutoIncrement, AutoIncrementSeed & AutoIncrementStep
AutoIncrement attend un boolen. S'il est vrai, ADO.NET gnrera des valeurs pour les lignes ajoutes
avec les valeurs dfinies dans AutoIncrementSeed et AutoIncrementStep (int32). Si vous tentez de convertir
une colonne existante en colonne AutoIncrement, son type sera converti en Int32. Ceci n'est pas possible si la
colonne est une colonne contenant une expression.
Nous verrons dans la troisime partie comment grer leurs utilisations.
MaTable.Columns[0].AutoIncrement = True;
MaTable.Columns[0].AutoIncrementSeed = -1;
MaTable.Columns[0].AutoIncrementStep = -1;
Caption (String)
Dfinit la lgende de la colonne. Si elle n'est pas dfinie, c'est la proprit ColumName qui sera
renvoye.
38/130
ColumnMapping (MappingType)
Obtient ou dfinit le MappingType de la colonne. Peut prendre une des valeurs suivantes :
Nom Description
Attribute La colonne est mappe un attribut XML.
Element La colonne est mappe un lment XML.
Hidden La colonne est mappe une structure interne.
SimpleContent La colonne est mappe un nud XmlText.
Cette proprit dfinit comment le fichier XML sera crit lors de l'appel de la mthode WriteXML.
Si je reprends mon exemple de schma XML, avec le code :
foreach (DataColumn MaColonne in MonDataset.Tables[0].Columns)
MaColonne.ColumnMapping = MappingType.Attribute;
MonDataset.WriteXmlSchema("c:\\tutoriel\\schema2.xml");
J'obtiendrais
<?xml version="1.0" standalone="yes" ?>
T T T T
- <xs:schema id="Auteurs" xmlns=""

HTU UTH T T T T T T T T
xmlns:xs="http://www.w3.org/2001/XMLSchema" T T T T
xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> T T T T
- <xs:element name="Auteurs" msdata:IsDataSet="true" msdata:Locale="fr-

HTU UTH T T T T T T T T T T T T
FR"> T T
- <xs:choice maxOccurs="unbounded"> HTU UTH T T T T T T
- <xs:element name="Table"> HTU UTH T T T T T T
<xs:attribute name="Au_ID" type="xs:int" /> T T T T T T T T T T T T T T
<xs:attribute name="Author" type="xs:string" /> T T T T T T T T T T T T T T
<xs:attribute name="Year_x0020_Born" T T T T T T T T T T
type="xs:short" /> T T T T
</xs:choice> T T T T T T
T </xs:schema>
T T T T T
ColumnName (String)
Dfinit ou renvoie le nom de la colonne. Utilisez imprativement des noms sans espaces si vos colonnes
servent dans des expressions. De manire gnrale, utilisez des noms sans espaces.
39/130
DataType (Type)
Reprsente le type de la colonne. Ce type doit tre un des types grs par le Framework, indiqus ci-
dessous.
Boolean
Byte
Char
DateTime
Decimal
Double
Int16
Int32
Int64
SByte
Single
String
TimeSpan
UInt16
UInt32
UInt64
Une exception est gnre si vous modifiez cette proprit alors que la colonne a commenc stocker
des donnes.
DefaultValue (Object)
Dfinit la valeur par dfaut d'une colonne. Cette valeur est automatiquement ajoute dans les lignes
nouvellement cres. La valeur doit tre dfinie aprs le type et doit videmment respecter celui-ci.
Expression (String)
Cette proprit permet de remplacer lgamment le DataShape Provider. Elle permet de faire des calculs
dans une colonne, soit utilisant une ou plusieurs colonnes de la table, soit d'crire des fonctions d'agrgation.
Les exemples suivants sont raliss avec la base NorthWind SQL-Server.
Calcul d'une expression dpendant d'une autre colonne :
{
string strSQL = "SELECT ProductID, UnitPrice, UnitsInStock FROM
Products";
SqlDataAdapter MonDa = new SqlDataAdapter(strSQL, strConn);
DataSet MonDataSet = new DataSet();
MonDa.Fill(MonDataSet);
MonDataSet.Tables[0].Columns.Add("Taxe",
System.Type.GetType("System.Decimal"), "UnitPrice*0.196");
dataGrid1.DataSource = MonDataSet.Tables[0].DefaultView;
}
40/130
Calcul d'un agrgat
{
Products";
MonDataSet.Tables[0].Columns.Add("Compte",
System.Type.GetType("System.Decimal"), "Avg(UnitPrice)");
}
Dans ce genre de calcul c'est beaucoup moins efficace puisque la valeur est reproduite sur toutes les
lignes.
Simulation d'un filtre
{
Products";
MonDataSet.Tables[0].Columns.Add("Filtre",
System.Type.GetType("System.String"), "iif(UnitPrice>50,'vrai','faux')");
}
MaxLength (Integer)
Dfinit un nombre maximum de caractres pour une colonne de type texte. Renvoie 1 si elle n'est pas
dfinie.
Ordinal (Integer)
Renvoie la position ordinale de la colonne. Renvoie 1 si la colonne n'est pas dans une table.
ReadOnly (Boolen)
Renvoie ou dfinit si les valeurs du champ peuvent tre modifies.
Unique (Boolen)
Renvoie ou dfinit l'unicit des lignes de la colonne.
41/130
La classe DataRow
Les objets DataRow contiennent les donnes de la table. La manipulation des lignes d'une table est
toujours lie un travail sur les donnes. Cette collection est centrale dans les applications impliquant des
mises jour de la source de donnes. Ce sont les objets DataRow qui rcuprent les informations d'erreurs et
de modification.
Les valeurs de la ligne

U
Une ligne contient plusieurs valeurs pour reprsenter ses donnes. Ce concept est familier au
dveloppeurs ADO. Une ligne peut possder une ou plusieurs des valeurs suivantes
DataRowVersion Description
Current Les valeurs actuelles de la ligne. Cette version de ligne n'existe pas pour les lignes dont
le RowState est Deleted.
Default Version de ligne par dfaut d'une ligne particulire. La version de ligne par dfaut d'une
ligne Added, Modified ou Unchanged est Current. La version de ligne par dfaut d'une
ligne Deleted est Original. La version de ligne par dfaut d'une ligne Detached est
Proposed.
Original Les valeurs d'origine de la ligne. Cette version de ligne n'existe pas pour les lignes ayant
un RowState Added.
Proposed Les valeurs proposes de la ligne. Cette version de ligne existe pendant une opration de
modification sur une ligne ou pour une ligne qui ne fait pas partie d'un
DataRowCollection.
Il est possible de savoir si une version particulire existe en utilisant la mthode HasVersion. En gnral
vous n'avez pas besoin de lire les diffrentes versions d'une ligne. Par contre celles-ci sont indispensables
l'criture des requtes de mises jour.
L'tat d'une ligne

U
Les lignes possdent toujours un tat. Celui-ci permet de savoir si la ligne possde des modifications en
attente ou non. L'tat peut prendre une des valeurs suivantes.
RowState Description
Unchanged Aucune modification n'a t apporte depuis le dernier appel AcceptChanges ou depuis la
cration de la ligne par DataAdapter.Fill.
Added La ligne a t ajoute la table mais la mthode AcceptChanges n'a pas t appele.
Modified Certains lments de la ligne ont t modifis.
Deleted La ligne a t supprime d'une table et AcceptChanges n'a pas t appel.
Detached Detached est dfini pour une ligne qui a t cre mais qui ne fait pas partie d'un
DataRowCollection. Le RowState d'une ligne cre prend la valeur Detached. Une fois le
DataRow ajout au DataRowCollection l'aide de l'appel la mthode Add, la proprit
RowState prend la valeur Added.
Detached est galement dfini pour une ligne qui a t supprime d'un DataRowCollection
l'aide de la mthode Remove ou par la mthode Delete suivie de la mthode AcceptChanges.
Vous pouvez utiliser l'tat pour filtrer les lignes d'une table. C'est aussi par l'tat que le DataAdapter
dtermine la commande appliquer.
Remonte des erreurs

U
Lorsqu'une ligne ne peut transmettre ses modifications vers la source, il y a criture d'une chane
dcrivant l'erreur dans la proprit RowError de la ligne. Cette proprit permet de traiter les erreurs a
posteriori de la mise jour. Il ne faut pas perdre de vue que seule une chane est stocke. Dans certains cas,
la lecture et l'interprtation de l'erreur ne sont pas aises. La ligne n'a pas ncessairement une erreur dans sa
proprit RowError mme si une erreur est survenue. Il faut parfois utiliser les mthodes GetColumnError et
GetColumnsInError pour trouver une erreur spcifique un champ de la ligne.
U
42/130
Ajout et modification de ligne
On peut tre un peu perturb par la profusion de techniques permettant d'ajouter une ligne. De manire
gnrale, on utilise NewRow puis un Add sur la collection. On utilise ImportRow lors du transfert de la ligne
d'une table vers une autre. Enfin on se sert de LoadDataRow lorsqu'on souhaite qu'ADO.NET ajoute ou
mette jour une ligne ventuellement existante.
La modification des lignes suit globalement deux principes.
On slectionne une ligne puis on modifie ses valeurs soit directement soit en mode dition
On ajoute une ligne en comptant sur la cl primaire pour assurer les modifications.
Evidemment la premire mthode est beaucoup plus propre.
Une autre mthode est la modification indirecte. Lorsqu'on manipule des objets DataRow dans un
tableau, celui-ci fais rfrence aux objets de la table. Une modification dans le tableau engendre une
modification dans la table.
DataRow[] TabLigne = MonDataset.Tables(0).Select("Au_Id < 10");
TabLigne[0][1] = "Mzigue";
dataGrid1.DataSource = MonDataset.Tables[0];
Mthode de DataRowCollection
U
En outre des mthodes habituelles des collections ADO.NET, cette collection possde deux mthodes
spcifiques Find et InsertAt.
Add
Permet l'ajout d'une ligne la collection, soit en passant un objet DataRow, soit avec un tableau de
valeurs.
Find
Permet une recherche d'une ligne par la valeur de sa cl primaire. Il n'est pas possible de spcifier un
champ pour la recherche. Si la cl primaire est compose de plusieurs champs, vous devez passer un tableau
de valeurs la mthode
{
MonDataset.Tables[0].Columns[0], true);
DataRow MaLigne = MonDataset.Tables[0].Rows.Find("1");
MessageBox.Show(Convert.ToString(MaLigne[1]));
strSQL = "SELECT * FROM [Title Author]";
MonDA.SelectCommand.CommandText = strSQL;
DataTable Matable =new DataTable();
MonDA.Fill(Matable);
Matable.Constraints.Add("pk", new DataColumn[] {Matable.Columns[0],
Matable.Columns[1]}, true);
MonDataset.Tables.Add(Matable);
MaLigne = MonDataset.Tables[1].Rows.Find(new Object[] {"0-0133656-1-4",
"1454"});
if (MaLigne != null)
MessageBox.Show("Reussie");
}
43/130
InsertAt
Permet l'insertion une position spcifique dans la collection.
void InsertAt(DataRow row, Integer pos)
Attention, cette mthode ne fonctionne pas pour un tableau d'objet DataRow mais uniquement pour un
objet DataRowCollection. N'oubliez pas non plus que la notion de position de ligne n'a pas de sens pour un
SGBD. Celle-ci n'a d'importance que pour l'criture d'un fichier XML ou pour la navigation dans votre
collection.
Proprits de l'objet DataRow

U
HasErrors (Boolen)
Indique si la ligne contient un message d'erreur. Cette proprit est en lecture seule mais vous pouvez la
modifier en jouant sur la proprit RowError.
Item (Object)
Surcharge. Permet de rcuprer la valeur d'un champ de la ligne en spcifiant ventuellement la
version.
public object this [DataColumn column, DataRowVersion version] {get;}
Le paramtre column peut tre l'objet DataColumn, la position ordinale ou le nom de la colonne. Pour
des raisons de performance, n'utilisez pas le nom de la colonne. Si vous ne prcisez pas la version c'est la
valeur courante qui est renvoye.
ItemArray (Object())
Renvoie ou dfinit un tableau d'objet contenant les valeurs de tous les champs de la ligne. Cette mthode
ne possde pas de surcharge permettant de spcifier la version. Lors de l'utilisation de cette mthode pour
modifier une ligne, passez des paramtres Nothing pour obtenir les valeurs AutoIncrement ou par dfaut
d'une colonne.
RowError (String)
Dfinit ou obtient le texte d'un message d'erreur affect la ligne.
44/130
RowState (DataRowState)
Lecture seule. Obtient l'tat de la ligne spcifie. Voici un petit exemple de manipulation de ligne.
{
MaTable.Columns[0].AutoIncrement = true;
MaTable.Columns[0].AutoIncrementSeed = -1;
MaTable.Columns[0].AutoIncrementStep = -1;
MaTable.Constraints.Add("pk1", MonDataset.Tables[0].Columns[0], true);
MaTable.BeginLoadData();
MaTable.LoadDataRow(new Object[] {1, "Rabilloud", 1967}, false);
MaTable.EndLoadData();
DataRow maLigne = MaTable.NewRow();
maLigne.ItemArray = new Object[] {null, "Mezigue", 1930};
MaTable.Rows.Add(maLigne);
maLigne = MaTable.Rows.Find(10);
maLigne.Delete();
DataRow[] TabLigne = MaTable.Select("", "", DataViewRowState.Added |
DataViewRowState.Deleted | DataViewRowState.ModifiedCurrent);
MessageBox.Show(Convert.ToString(TabLigne.GetLength(0)));
}
Mthode de DataRow
U
AcceptChanges
Valide les modifications en attente sur la ligne. Si la proprit RowState de la ligne tait Added ou
Modified, elle devient Unchanged. Si la proprit RowState est Deleted, la ligne est supprime. Fait aussi un
appel implicite de la mthode EndEdit. Attention cela n'induit pas un quelconque envoi des modifications
vers la source de donnes. Prenons le cas suivant
MaTable.Constraints.Add("pk1", MonDataset.Tables[0].Columns[0], true);
MaTable.BeginLoadData();
MaTable.LoadDataRow(new Object[] {1, "Rabilloud", 1967}, false);
MaTable.EndLoadData();
DataRow maLigne = MaTable.NewRow();
maLigne.ItemArray = new Object[] {null, "Mezigue", 1930};
MaTable.Rows.Add(maLigne);
MaTable.AcceptChanges();
MessageBox.Show(maLigne.RowState.ToString());
Dans ce cas, lors de l'appel de la mise jour, la ligne quoique rcemment ajoute, sera marque comme
tant inchange. Ds lors elle ne sera pas envoye vers la source de donnes.
45/130
BeginEdit, CancelEdit & EndEdit
Ces mthodes permettent de procder la modification des lignes en mode dition. Les contrles
dpendants utilisent toujours ce principe. L'utilisation du mode dition n'est jamais impose mais elle permet
de suspendre les oprations de validation et les vnements de changement jusqu' l'appel de la mthode
EndEdit.
DataRow maligne = MaTable.Rows[0];
maligne.BeginEdit();
maligne[1] = textBox1.Text;
if (Len(maligne[1].DataRowVersion.Proposed) > 0)
maligne.EndEdit();
else
maligne.CancelEdit();
ClearErrors
Efface toutes les erreurs de la ligne qu'elles soient ou non affectes un champ.
Delete
Marque une ligne comme 'Deleted'. Si l'tat de la ligne tait 'Added' la ligne est dfinitivement
supprime. Une ligne marque 'Deleted' peut tre restaure par l'appel de la mthode RejectChanges.
GetChildRows & GetParentRows
Permet la rcupration des lignes dans un tableau de DataRow au travers d'une relation spcifie.
Accepte un paramtre pour prciser la version de la ligne dsire.
Public DataRow[] GetChildRows(DataRelation relation, DataRowVersion version) ;
Le paramtre relation peut tre aussi dfini par son nom.
GetColumnError
Public String GetColumnError(DataColumn colum);
Permet de rcuprer l'erreur d'une colonne spcifie de la ligne. Le paramtre colonne peut tre aussi
pass comme nom ou comme position ordinale.
GetColumnsInError
Renvoie un tableau de DataColumn contenant les colonnes en erreurs de la ligne. Regardons l'exemple
suivant de gestion d'erreurs.
DataRow maLigne = MaTable.Rows[0];
if (maLigne.HasErrors)
{
DataColumn[] TabErrCol= maLigne.GetColumnsInError();
foreach(DataColumn MaColonne in TabErrCol)
MessageBox.Show(Convert.ToString(maLigne.GetColumnError(MaColonne)));
maLigne.ClearErrors();
}
HasVersion
Public Boolean HasVersion(DataRowVersion version);
Permet de dfinir si la version passe en paramtre existe pour la ligne. S'utilise gnralement en
conjonction avec les mthodes GetChildRows et GetParentRows ou avant l'appel de la proprit Item.
46/130
IsNull
Public Boolean IsNull(DataColumn column, DataRowVersion version);
Le paramtre colonne peut aussi tre la position ordinale ou le nom mais dans ce cas la version ne peut
tre prcise. Renvoie vrai si la valeur de la colonne est NULL.
RejectChanges
Annule les modifications en attente. Si RowState est 'Deleted' ou 'Modified', les valeurs prcdentes de
la ligne sont rtablies et RowState devient 'Unchanged'. Si RowState est 'Added', la ligne est supprime.
Appelle aussi CancelEdit implicitement.
SetColumnError
Public void SetColumnError(DataColumn column, String error);
Affecte la colonne dfinie en paramtre le texte d'erreur contenu dans la chane error.
SetParentRow
Public void SetParentRow(DataRow parentRow, DataRelation relation);
Dfinit la nouvelle ligne parent de la ligne. Vous n'tes pas oblig de spcifier la Relation mais je vous
conseille vivement de le faire.
La Classe Constraint
La collection Constraints reprsente les contraintes d'une table. Les contraintes de colonne sont des
proprits de l'objet DataColumn. Il y a l un pige smantique important. Une colonne peut possder la
contrainte unique par sa proprit Unique et tre la cible d'une contrainte UniqueConstraint de la table.
Lorsque je dis qu'il s'agit d'une contrainte de table, je commets une approximation. La seule vritable
contrainte de table est la cl primaire, c'est dire une contrainte 'UniqueConstraint' particulire. Les autres
ont pour cible une colonne ou un groupe de colonnes.
Cette collection ne contient que deux types possibles 'UniqueConstraint' et 'ForeignKeyConstraint'.
UniqueConstraint
U
Contrainte d'unicit verticale ou horizontale. Lorsqu'il s'agit d'une colonne ceci revient mettre la
proprit unique de la colonne Vrai. L'ajout d'une colonne ayant la proprit unique une table provoque
l'ajout d'une contrainte de ce type la collection ConstraintCollection de la table.
La cl primaire de la table est une contrainte 'UniqueConstraint' de la collection.
La mthode Add de la collection permet d'ajouter des contraintes d'unicit. Soit vous crez un objet
Constraint que vous passez la mthode Add, soit vous pouvez utiliser la version surcharge suivante.
Public virtual Constraint Add(string name, DataColumn column, bool primaryKey);
O name est le nom de la contrainte, column l'objet DataColumn cibl et primaryKey un boolen
dfinissant si cette contrainte est la cl primaire.
Nous avons vu de nombreux exemples de cration de contrainte, je n'en rcris pas ici.
Proprits de UniqueConstraint
Columns (DataColumn())
Renvoie le tableau des objets DataColumn contenus dans la contrainte
IsPrimaryKey (Boolen)
Renvoie vrai si la contrainte est la cl primaire de la table.
U
47/130
ForeignKeyConstraint
La contrainte de cl trangre, appele aussi contrainte d'intgrit rfrentielle ne se conoit que dans le
cadre d'une relation. En fait une cl trangre est compose d'une ou plusieurs colonnes, celles-ci tant la cl
primaire de la table mise en relation. L'ajout d'une relation induit l'ajout d'une 'ForeignKeyConstraint' la
collection. Nous verrons cela dans l'tude des DataRelation. Voici un exemple de manipulation de cl
trangre et d'une relation.
{
string strSQL = "SELECT * FROM Publishers";
OleDbDataAdapter MonDAPublisher = new OleDbDataAdapter(strSQL, strConn);
DataSet MonDataset = new DataSet("Pubs");
MonDAPublisher.Fill(MonDataset, "Editeurs");
DataTable maTable = MonDataset.Tables[0];
maTable.Constraints.Add("pk1", maTable.Columns[0], true);
strSQL = "SELECT * FROM Titles";
OleDbDataAdapter MonDATitle = new OleDbDataAdapter(strSQL, strConn);
MonDATitle.Fill(MonDataset, "Titres");
maTable = MonDataset.Tables[1];
maTable.Constraints.Add("pk1", maTable.Columns["ISBN"], true);
DataRelation DRelat = new DataRelation("EditeurTitre",
MonDataset.Tables[0].Columns[0], maTable.Columns["PubId"], true);
MonDataset.Relations.Add(DRelat);
ForeignKeyConstraint FKCont = (ForeignKeyConstraint)
maTable.Constraints[1];
FKCont.AcceptRejectRule = AcceptRejectRule.Cascade;
FKCont.DeleteRule = Rule.Cascade;
FKCont.UpdateRule = Rule.Cascade;
maTable = MonDataset.Tables[0];
maTable.Columns.Add("NbLivre", Type.GetType("System.Int32"),
"Count(child(EditeurTitre).ISBN)");
dataGrid1.DataSource = maTable;
}
Proprits de ForeignKeyConstraint
AcceptRejectRule
Dfinit les rgles appliquer en cas d'appel de la mthode AcceptChanges. Peut prendre la valeur :
None : Aucune action ne se produit
Cascade : Les actions se rpercutent en cascade
Les actions sont dfinies dans les proprits DeleteRule et UpdateRule
Columns (DataColumn())
Renvoie le tableau des objets DataColumn contenus dans la contrainte
48/130
DeleteRule & UpdateRule(Rule)
Renvoie ou dfinit la rpercussion de l'action lorsqu'une ligne parent est supprime ou modifie. Peut
prendre une des valeurs suivantes :
Nom Description
Cascade Supprime ou modifie les lignes enfants. Il s'agit de la valeur par dfaut.
None Aucune action n'est effectue sur les lignes enfants.
SetDefault Affecte la valeur contenue dans la proprit DefaultValue comme valeur des lignes enfants.
SetNull Affecte DBNull comme valeur des lignes enfants.
Attention, mettre ces proprits None n'empche pas la leve d'exceptions.
RelatedColumns (DataColumn())
Renvoie un tableau d'objet DataColumn reprsentant les colonnes parents de la relation.
RelatedTable (DataTable)
Renvoie la table parente de la relation
La classe DataRelation
Les objets DataRelation appartiennent l'objet Dataset. Une relation permet de mettre en
correspondance les lignes d'une ou de plusieurs tables. Elle se base sur l'utilisation d'une cl trangre qui
permet d'identifier une ligne 'parente'. La mise en relation des informations permet de ne pas dupliquer les
donnes et donc d'allger considrablement le SGBD. Dans ADO.NET vous pouvez crer des relations
entres des objets d'un mme Dataset. On distingue quatre types de relation:
o Relation rflexive : Celle-ci n'utilise qu'une seule table. La cl trangre permet de faire
rfrence une ligne de la mme table, donc de crer une vision 'hirarchique' de la table.
strConn = @"packet size=4096;user id=sa;data source= NOM-
SZ71L7KTH17\\TUTO ;persist security info=False;initial
catalog=northwind;password=monpasse"
strSQL = "SELECT * FROM Employees";
SqlClient.SqlDataAdapter MonDa = new SqlClient.SqlDataAdapter(strSQL,
strConn);
Data.DataTable maTable = MonDataSet.Tables(0);
maTable.Constraints.Add("pk1", maTable.Columns(0), true);
MonDataSet.Relations.Add("AutoReflex", maTable.Columns(0),
maTable.Columns("ReportsTo"), true);
maTable.Columns.Add("NbSubord", Type.GetType("System.Int32"),
"Count(child(AutoReflex).ReportsTo)");
this.DataGrid1.DataSource = maTable;
o Relation un un : Une telle relation associe une ligne enfant avec une ligne parent. Dans ce
seul cas la cl trangre doit tre unique. Les relations de ce type sont trs rares car il est alors
plus simple de mettre tous les champs dans une seule table.
o Relation un plusieurs : C'est le type le plus courant. Une ligne parent peut avoir plusieurs
lignes enfants, mais une ligne enfant ne peut avoir qu'un seul parent. Celle-ci s'obtient par la
recopie d'une ou plusieurs colonnes ayant la contrainte d'unicit dans la table enfants.
o Relation plusieurs plusieurs : Stricto sensu il ne s'agit plus d'une relation, mais de deux
relations utilisant une table de jointure. Une table de jointure comporte les colonnes composant
la cl primaire des deux tables, sa propre cl primaire tant dfinie sur l'ensemble des colonnes.
Les relations prsentent aussi l'avantage des performances. Il est souvent moins lourd de crer deux
tables puis une relation que de crer une table utilisant une requte avec jointure.
Sachez aussi qu'il est possible de dsigner des lignes enfants dans l'expression d'une colonne calcule.
49/130
Remarque de Maxence Hubiche
Je ne suis pas daccord avec cette assertion Stricto sensu, il ne sagit pas dune relation mais de deux
relations utilisant une table de jointure . Sur le plan de la modlisation, il sagit dune association entre 2
entits. Il est vrai quune telle association ncessitera, au moment de la cration de la base de donnes, la
gnration dune table intermdiaire qui est en fait le rsultat de lassociation entre les 2 entits du modle.
Mais l, nous sommes dans le modle conceptuel. Par contre, dans la base de donnes (modle physique) le
cas pourra tre lgrement diffrent : Imagine que tu aies lier (pour je ne sais quelle raison) 2 champs
quelconques (avec doublons), de 2 tables quelconques. Il est plus que probable que tu auras une vraie
relation n-n, puisque chaque valeur de la table 1 sera susceptible dtre associe n valeurs de la table 2, et
vice-versa.
Rponse : Je ne saisie pas pourquoi une relation n:n avec des doublons serait plus une vraie relation n:n
que s'il n'y a pas de doublons. Sur le plan conceptuel tu as raison, mais je n'aborde pas le plan conceptuel
dans le cadre de ce cours, je dcris comment il faudra grer les objets DataRelation dans ADO.NET.
Rponse de M. Hubiche
C'est le 'Stricto Sensu' qui m'ennuie, parce que tout dpend de l'endroit o l'on se situe :
Sur le plan analytique, la relation N-N existe. Qu'il y ait des doublons ou pas !
Maintenant, il est vrai que sur le plan physique, on ne peut la reprsenter autrement que par 2 relations
1-N. Qu'il y ait des doublons ou pas ...
Remarque de Maxence Hubiche

Puis-je te poser une question ? (Histoire de vraiment tennuyer)
Imagine la table des matriels.
Avec ID, Description, Prix.
Imagine que, maintenant, tu veuilles connatre la quantit de matriels composant dautres matriels, de
telle sorte que tu puisses rcuprer les compositions. Cette fois, lassociation est une association plusieurs-
-plusieurs sur la mme table
Comment tu gres ?
Pourtant, cest une relation rflexive aussi
Je tnerve l ?
Rponse : Une lgre contrarit tout au plus . Je ne suis pas bien sur de voir l ou tu veux en venir.
Mais dans le cas que tu cites, il s'agit d'une relation plusieurs plusieurs. La notion de relation de type n:n
n'induit pas l'existence de deux tables. Il s'agit bien d'une relation entre des enregistrements. Tu auras donc
une table de jointure faisant rfrence dans ses champs la cl primaire de la mme table. C'est certes une
relation reflexive, mais elle ncessite plus d'une table.
Rponse de M. Hubiche
Ce qui m'a ennuy c'est que tu limites, dans ta dfinition, la relation rflexive une relation 1-N. ALors
que dans l'exemple que je te donne, il s'agit aussi d'une relation N-N, et elle est aussi rflexive.
En fait, la rflexivit porte sur le fait que l'association se fait d'une entit sur elle-mme. Les cardinalits
interviennent peu ici.
La collection DataRelationCollection
U
Elle se manipule avec les mmes mthodes que DataTableCollection.

Mthode Add
Surcharge. Comme d'habitude vous pouvez soit crer une relation puis l'ajouter la collection, soit
utiliser une des syntaxes surcharges de cration directe.
public DataRelation Add(String name, DataColumn[] parentColumns, DataColumn[]
childColumns, bool createConstraints)
Le nom est facultatif.
CreateConstraint permet de crer implicitement la contrainte de cl trangre sur la table enfant.
ParentColumn et ChildColumn peuvent tre soit un tableau de DataColumn, soit un seul DataColumn.
U
50/130
Proprits de DataRelation
ChildColumns (DataColumn())
Renvoie un tableau d'objet DataColumn (ou un seul DataColumn) composant la cl trangre de la table
enfant.
ChildKeyConstraint (ForeignKeyConstraint)
Renvoie l'objet ForeignKeyConstraint de la relation.
ChildTable (DataTable)
Renvoie la table enfant.
ParentColumns, ParentTable, ParentKeyConstraint
Fonctionne comme les proprits prcdentes pour les objets parents. Dans le cas de
ParentKeyConstraint c'est un objet UniqueConstraint qui est renvoy.
Nested (Boolen)
Renvoie vrai si les objets DataRelation sont imbriqus. Cette proprit est utilise lorsqu'on crit un
fichier XML ou pour synchroniser un XMLDataDocument avec le Dataset.
<CustomerOrders>
<Customers>
<CustomerID>ALFKI</CustomerID>
<CompanyName>Alfreds Futterkiste</CompanyName>
</Customers>
<Customers>
<CustomerID>ANATR</CustomerID>
<CompanyName>Ana Trujillo Emparedados y helados</CompanyName>
</Customers>
<Orders>
<OrderID>10643</OrderID>
<OrderDate>1997-08-25T00:00:00</OrderDate>
</Orders>
<Orders>
</Orders>
<Orders>
</Orders>
</CustomerOrders>
Notez que l'lment Customers et les lments Orders sont reprsents en tant qu'lments frres. Si
vous souhaitiez que les lments Orders apparaissent comme les enfants de leurs lments parents respectifs,
il vous faudrait assigner la valeur true la proprit Nested du DataRelation.
51/130
Le code suivant montre la sortie que vous obtiendriez, avec les lments Orders imbriqus dans leurs
lments parents respectifs.
<CustomerOrders>
<Customers>
<Orders>
</Orders>
<Orders>
</Orders>
<CompanyName>Alfreds Futterkiste</CompanyName>
</Customers>
<Customers>
<Orders>
</Orders>
<CompanyName>Ana Trujillo Emparedados y helados</CompanyName>
</Customers>
</CustomerOrders>
Les classes DataView & DataViewManager

Jusque l, je ne vous ai pas tellement parl de navigation dans les donnes ni de contrles dpendants.
Beaucoup de dveloppeurs ADO sont pourtant perturbs par la disparition des mthodes de navigation de
l'objet Recordset. Si ces mthodes avaient un sens dans un recordset qui gre une position courante, elle n'en
a plus dans un Dataset qui est un ensemble de collections. En effet, la ligne en cours d'une collection n'est
jamais qu'une position ordinale et naviguer dans une collection ne revient qu' modifier celle-ci.
Les objets DataView sont une couche entre les objets DataTable et l'interface utilisateur. Elles
permettent de prsenter la table sous-jacente comme on veut. Une table peut exposer plusieurs vues d'elle-
mme. Un DataView est li dynamiquement la table, ce qui veut dire qu'il reflte les donnes et les
changements apports la table.
Il ne faut pas confondre un DataView et une vue au sens SQL du terme. Un DataView ne peut exposer
que des donnes provenant d'une seule table, ne peut pas crer de colonne de calcul et ne peut pas restreindre
les colonnes affiches.
Un DataViewManager permet de grer les paramtres des vues de toutes les tables au niveau du Dataset.
En lui-mme il ne fait rien de bien particulier si ce n'est permettre d'afficher des donnes connexes dans des
contrles dpendants.
Je vous parlais un peu plus avant de navigation dans le jeu d'enregistrement.
52/130
La navigation au sens ADO du terme se gre par l'intermdiaire du DataBinding. Non parce que ce n'est
pas possible de faire autrement pour naviguer dans les enregistrements, mais parce que c'est la mthode pour
pouvoir lier la conception des contrles dpendants grant la navigation. La navigation dans une collection
ne pose aucun problme. Regardons le code suivant :
private int monIndex;
this.Form1.Load += new System.EventHandler(Form1_Load);
this.Btn_Del.Click += new System.EventHandler(Btn_Del_Click);
this.cmdFirst.Click += new System.EventHandler(cmdFirst_Click);
this.cmdNext.Click += new System.EventHandler(cmdNext_Click);
this.cmdPrev.Click += new System.EventHandler(cmdPrev_Click);
this.cmdLast.Click += new System.EventHandler(cmdLast_Click);

private void Form1_Load(object sender, System.EventArgs e) {
strConn = @"Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data
strSQL = "SELECT * FROM Authors";
Data.OleDb.OleDbDataAdapter MonDAPublisher = new
Data.OleDb.OleDbDataAdapter(strSQL, strConn);
MonDAPublisher.Fill(MonDataset, "Auteurs");
MaTable = MonDataset.Tables(0);
monIndex = 0;
Affiche_Donnee();
}
private void Btn_Del_Click(object sender, System.EventArgs e) {

MaTable.Rows.RemoveAt(monIndex);
}
private void cmdFirst_Click(object sender, System.EventArgs e){
monIndex = 0;
Affiche_Donnee();
}
private void Affiche_Donnee() {
MaLigne = MaTable.DefaultView.Item(monIndex);
this.TextBox1.Text = MaLigne.Item(0);
this.TextBox2.Text = MaLigne.Item(1);
this.TextBox3.Text = MaLigne.Item(2) & "";
}
private void cmdNext_Click(object sender, System.EventArgs e){
monIndex++;
Affiche_Donnee();
}
private void cmdPrev_Click(object sender, System.EventArgs e){
monIndex-;
Affiche_Donnee();
}
private void cmdLast_Click(object sender, System.EventArgs e) {
monIndex = MaTable.DefaultView.Count 1;
Affiche_Donnee();
}
Vous verrez que le code fonctionne trs bien mme si je retire des lignes de la table. Cela vient du fait
que le DataView gre toujours correctement ces index.
U
53/130
Proprits de DataView
AllowDelete, AllowEdit & AllowNew (Boolen)
Obtient ou dfinit si la modification de table spcifie est autorise au travers du DataView.
ApplyDefaultSort (Boolen)
Applique le tri par la cl primaire comme tri par dfaut. Il faut videmment que la proprit Sort soit
vide et qu'il y ait une cl primaire.
Count (Integer)
Renvoie le nombre d'enregistrements visibles aprs l'application des filtres.
RowFilter (String)
Utilise une chane de filtre, de manire identique un filtre sur une expression de colonne, c'est dire
une clause WHERE SQL sans le mot cl WHERE. Les chanes suivantes sont des chanes valides :
"Au_Id > 100"
"Author like '%John%'"
"Isnull([year born],'Null Column') = 'Null Column'"
"BirthDate =< #01/01/2004#"
Et toutes les combinaisons avec les oprateurs logiques.
RowStateFilter (DataRowState)
Renvoie ou dfinit un filtre en fonction de l'tat et/ou de la version de la ligne. Il est possible de
combiner plusieurs valeurs.
Sort (String)
Renvoie ou dfinit une chane de tri, identique la clause 'ORDER BY'. Les colonnes sont tries par
ordre d'apparition dans la chane ; on utilise DESC pour un tri en ordre dcroissant.
Mthodes du DataView
U
AddNew
Ajoute une ligne un DataView.
Find
Identique la mthode du DataRow.
DataRowView
U
Reprsente une ligne d'un objet DataView. Ces lignes se manipulent sensiblement comme des DataRow
mais possdent des proprits supplmentaires.
Proprits
IsEdit (Boolen)
Renvoie vrai si le DataRowView est en mode dition.
IsNew (Boolen)
Renvoie vrai si le DataRowView a t ajout.
Item (Object)
Renvoie ou dfinit la valeur dans la colonne passe en paramtre comme nom ou position ordinale.
54/130
Row (DataRow)
Renvoie l'objet DataRow dsign par le DataRowView.
RowVersion (DataRowVersion)
Renvoie la version de la ligne qui est utilise pour l'affichage. (originale, courante, propose)
Manipulation des DataView

U
Les DataView se manipulent comme des DataTable, mais en ajoutant des fonctionnalits de
prsentation. Vous n'avez pas ncessairement besoin de code pour utiliser les DataView puisqu'il existe un
composant dans l'onglet 'Donnes' de la palette.
Lorsqu'on manipule les DataView par le code, c'est toujours dans le cadre d'une liaison avec des
contrles. Sinon ils ne font rien que vous ne pourrez faire avec un Select sur des DataRow. Nous verrons
dans la troisime partie des exemples d'utilisation.
DataViewManager
U
Cet objet par contre n'est quasiment jamais utilis, car il est rare de vouloir grer des vues de donnes
non connexes. Toutefois, il est possible de lier un DataViewManager au contrle DataGrid. Dans ce cas,
celui-ci vous affichera une liste de table que vous pourrez ajouter. Si je reprends mon exemple
this.Button1.Click += new System.EventHandler(Button1_Click);

private void Button1_Click(object sender, System.EventArgs e) {
strSQL = "SELECT * FROM Publishers";
OleDbDataAdapter MonDAPublisher = new OleDbDataAdapter(strSQL,
strConn);
MonDAPublisher.Fill(MonDataset, "Editeurs");
Data.DataTable maTable = MonDataset.Tables(0);
strSQL = "SELECT * FROM Titles";
OleDbDataAdapter MonDATitle = new OleDbDataAdapter(strSQL,
strConn);
MonDATitle.Fill(MonDataset, "Titres");
maTable = MonDataset.Tables(1);
maTable.Constraints.Add("pk1", maTable.Columns("ISBN"), true);
DataRelation DRelat = new DataRelation("EditeurTitre",
MonDataset.Tables(0).Columns(0), maTable.Columns("PubId"), true);
MonDataset.Relations.Add(DRelat);
ForeignKeyConstraint FKCont = maTable.Constraints.Item(1);
FKCont.AcceptRejectRule = AcceptRejectRule.Cascade;
FKCont.DeleteRule = Rule.Cascade;
FKCont.UpdateRule = Rule.Cascade;
maTable = MonDataset.Tables(0) ;
maTable.Columns.Add("NbLivre", Type.GetType("System.Int32"),
"Count(child(EditeurTitre).ISBN)") ;
this.DataGrid1.DataSource = MonDataset.DefaultViewManager;
}
J'obtiendrais une grille comme cela.
55/130
Les fournisseurs manags
Nous allons maintenant regarder les classes composant les fournisseurs manags. A la fin de cette tude
nous verrons comment fonctionne un Dataset li un DataAdapter pour une communication
Bidirectionnelle.
Comme prcdemment nous allons beaucoup travailler sur le fournisseur OLEDB ; nanmoins vous
trouverez plusieurs exemples utilisant le fournisseur Manag pour SQL-Server chaque fois que celui-ci
engendrera des diffrences de codage.
Je vais maintenant expliciter quelques termes que j'emploie dans la suite de ce document.
Lot de requtes
U
Certains SGBD supportent le principe du lot de requtes. Ceci consiste envoyer plusieurs requtes par
le code ou par le biais d'une procdure stocke et rcuprer les informations en un seul lot. Les lots de
requtes sont grs par ADO.NET mais ils comportent un certain nombre de piges qu'il faut connatre.
Procdures stockes & Requtes stockes

U
Une requte stocke, parfois improprement appele vue est une requte dont la dfinition se situe dans le
SGBD. Ce peut tre indiffremment une requte action, slection ou de manipulation de structure. Celle-ci
peut attendre des paramtres d'entre.
Une procdure stocke est un ensemble d'ordre SQL, crits dans un langage propre au SGBD. Elle peut
combiner plusieurs types de requtes et peut utiliser des paramtres d'entre, de sortie et de retour.
Que ce soit des requtes ou des paramtres, il appartient au dveloppeur de savoir ce qu'elles attendent
et/ou renvoient.
La connexion
Comme dans ADO, l'objet OledbConnection reprsente une session unique d'accs la source de
donnes. La connexion gre les exceptions et la scurit de l'accs.
Regroupement de connexions
U
Ce mcanisme appel 'connection pooling' est toujours implment dans ADO.NET comme il l'est dans
ADO. Les fournisseurs proposent un jeu de connexions disponible pour augmenter les performances.
Lorsqu'on demande la fermeture d'une connexion, celle-ci retourne dans le pool toujours ouverte et ne se
fermera effectivement qu'au dpassement de son paramtre LifeTime. Ce principe, mconnu de la plupart
des dveloppeurs permet l'utilisation de connexions dites 'implicites' avec des performances acceptables.
56/130
Le pool peut tre configur par le biais de la chane de connexion l'aide des paramtres suivants :
Nom Valeur par Description
dfaut
Connection Lifetime 0 Lorsqu'une connexion est retourne au pool, l'heure de sa cration est
compare l'heure actuelle et la connexion est dtruite si cet
intervalle de temps (en secondes) excde la valeur spcifie par
Connection Lifetime. Ceci est utile dans les configurations en
clusters pour forcer l'quilibrage de la charge entre un serveur en
cours d'excution et un serveur qui vient d'tre mis en ligne. La
valeur zro (0) aura pour consquence un dlai d'attente maximal
pour les connexions regroupes.
Connection Reset True Dtermine si la connexion de base de donnes est rinitialise
lorsqu'elle est supprime du pool. Pour Microsoft SQL Server
version 7.0, False vite un aller-retour supplmentaire du serveur lors
de l'tablissement d'une connexion, mais vous devez savoir que l'tat
de connexion, comme le contexte de base de donnes, n'est pas
rinitialis.
Enlist True Si la valeur est True, le dispositif de regroupement inscrit
automatiquement la connexion dans le contexte de transaction en
cours du thread de cration si un contexte de transaction existe.
Max Pool Size 100 Nombre maximal de connexions autorises dans le pool.
Min Pool Size 0 Nombre minimal de connexions conserves dans le pool.
Pooling True Si la valeur est True, la connexion est retire du pool appropri ou, si
ncessaire, cre et ajoute au pool appropri.
Sauf cas particulier on ne dfinit que le nombre maximum de connexions dans le pool.
Il ne faut pas perdre de vue qu'un pool ne contient que des connexions cres par des chanes de
connexions strictement identiques. Une petite modification de cette dernire sous-entend la cration d'un
nouveau pool. Le pool se subdivise seul lorsqu'une transaction est dfinie, il n'y a donc pas de risque de
rcuprer une connexion ayant un contexte de transaction.
La mise en pool des connexions se justifie pleinement dans les applications n-tiers o les objets mtier
librent et reprennent frquemment des connexions. Elle est assez inoprante dans les applications
Client/serveur.
Pour empcher la mise en pool des connexions il suffit d'ajouter "OLEDB Services = -4;" dans votre
chane de connexion pour le fournisseur OLE DB ou "Pooling=False" pour le fournisseur SQL-Server
Proprits
U
ConnectionString (String)
C'est la dfinition de la chane de connexion. A la diffrence d'ADO, on ne peut plus morceler la
construction de la chane de connexion. Celle-ci peut avoir une criture assez complexe lorsqu'on gre la
scurit. Vous trouverez dans l'aide la liste des paramtres utilisables. Rappelons-nous que la dfinition de
cette proprit n'ouvre pas la connexion. Une chane non valide lve une exception ArgumentException. Il
n'est pas possible de modifier la chane d'une connexion ouverte. La plupart de ces paramtres se retrouvent
dans les proprits ci-dessous, mais elles sont maintenant en lecture seule.
string strConn = @"Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data
Source=C:\\tutoriel\\biblio.mdb;Mode=Share Deny None;Jet OLEDB:Engine
Type=5;Jet OLEDB:Database Locking Mode=1;Jet OLEDB:Global Partial Bulk
Ops=2;Jet OLEDB:Global Bulk Transactions=1;Jet OLEDB:Create System
Database=False;Jet OLEDB:Encrypt Database=False;Jet OLEDB:Don't Copy
Locale on Compact=False;Jet OLEDB:Compact Without Replica
Repair=False;Jet OLEDB:SFP=False" ;
Data.OleDb.OleDbConnection MaConn = new
Data.OleDb.OleDbConnection(strConn);
MaConn.Open() ;
57/130
Cas du fournisseur SQL
Celui-ci attend une chane de connexion ne possdant pas de paramtre Provider. N'utilisez pas une
chane utilisant le fournisseur SqlOledb pour le fournisseur manag SQL.
strConn = @"workstation id=NOM-SZ71L7KTH17;packet size=4096;user
id=sa;data source=NOM-SZ71L7KTH17\\TUTO;persist security
info=False;initial catalog=northwind;password=monpasse";
Data.SqlClient.SqlConnection MaConn = new
Data.SqlClient.SqlConnection(strConn);
MaConn.Open() ;
ConnectionTimeOut (Integer)
Vaut 0 si le Timeout n'est pas dfini, sinon reprsente la dure en seconde (15 par dfaut).
Database & DataSource (String)
Renvoie le nom de la source et le nom du serveur.
PacketSize (Integer)
Spcifique au fournisseur manag pour SQL-Server.
Reprsente la taille (octets) des paquets transitant par le rseau. Si vous devez transmettre des donnes
de gros volume, il est souvent recommandable d'augmenter la taille. Attention cette modification doit tre
faite dans la chane de connexion.
State (ConnectionState)
Renvoie l'tat de la connexion.
Nom Valeur Description
Closed 0 La connexion est ferme.
Open 1 La connexion est ouvertee.
Connecting 2 La connexion est en cours
Executing 4 Une commande est en train de s'excuter
Fetching 8 Des donnes sont en cours de transfert
Broken 16 La connexion a t interrompue par une cause diffrente de close
Les quatre dernires valeurs ne sont pas encore utilises dans C#.
Mthodes
U
BeginTransaction
Dans ADO.NET seule existe la mthode BeginTransaction sur l'objet Connection. Dans ADO.NET on
utilise un objet Transaction cre par l'appel de BeginTrans. Ceci prsente une bien meilleure lisibilit des
transactions. La syntaxe est :
public override SqlTransaction BeginTransaction(IsolationLevel iso, string transactionName)
58/130
Les deux paramtres sont facultatifs. TransactionName permet de nommer la transaction ; isolationLevel
peut prendre une des valeurs suivantes :
Le fournisseur utilise un niveau d'isolation diffrent de celui qui est
Unspecified -1
spcifi mais ce niveau ne peut pas tre dtermin.
Vous ne pouvez pas craser les changements en attente des transactions
Chaos 16
dont le niveau d'isolation est suprieur.
partir d'une transaction, vous pouvez voir les modifications des
ReadUncommitted 256
autres transactions non encore engages.
Valeur utilise par dfaut. A partir d'une transaction, vous pouvez
ReadCommitted 4096 afficher les modifications d'autres transactions uniquement lorsqu'elles
ont t engages.
partir d'une transaction, vous ne pouvez pas voir les modifications
adXactRepeatableRead 65536 effectues dans d'autres transactions, mais cette nouvelle requte peut
renvoyer de nouveaux jeux d'enregistrements.
Serializable 1048576 Les transactions sont conduites en isolation d'autres transactions.
Vous noterez qu' l'exception des noms, c'est exactement le mme tableau que dans ADO.
Pour plus de renseignement sur les transactions, reportez-vous la section 'objet Transaction' dans ce
chapitre.
ChangeDatabase
Cette proprit permet la connexion cible de changer de base de donnes avec le mme fournisseur.
Ceci prsente un intrt pour remplir un Dataset avec des donnes d'origines varie. Il faut toutefois faire trs
attention lors du changement de base car il peut y avoir gnration de nombreuses exceptions.
Close
Ferme la connexion.
CreateCommand
Renvoie un objet Command li la connexion. Cela revient faire de faon explicite l'approche que l'on
pouvait avoir avec la mthode Execute dans ADO. La diffrence majeure vient du fait que la commande
ainsi cre n'est pas dfinie. On doit la manipuler comme un objet Command classique.
Open
Ouvre la connexion
U
59/130
Evnements
La gestion des vnements est un peu diffrente que celle dont vous aviez l'habitude avec VB
Rappels sur les vnements
Les vnements en C# se programment en utilisant des dlgus.
Un exemple classique est

string strConn = @"Provider=Microsoft.Jet.OLEDB.4.0;User
ID=Admin;Data Source=C:\\tutoriel\\biblio.mdb;Mode=Share Deny None;Jet
OLEDB:Engine Type=5;Jet OLEDB:Database Locking Mode=1;Jet OLEDB:Global
Partial Bulk Ops=2;Jet OLEDB:Global Bulk Transactions=1;Jet OLEDB:Create
System Database=False;Jet OLEDB:Encrypt Database=False;Jet OLEDB:Don't
Copy Locale on Compact=False;Jet OLEDB:Compact Without Replica
Repair=False;Jet OLEDB:SFP=False";
MaConn.ConnectionString = strConn;
MaConn.Open();
MaConn.InfoMessage += new
OleDb.OleDbInfoMessageEventHandler(MaConn_InfoMessage);
}
private static void MaConn_InfoMessage(object sender,

Data.OleDb.OleDbInfoMessageEventArgs args) {
foreach(Data.OleDb.OleDbError err in args.Errors) {

}
}
Dans ce cas, il vous faut ensuite grer ce qui revient dans EventArgs et crire le code de gestion (dans
notre exemple : parcours de la collection des erreurs)
C'est dans la programmation vnementielle que la connexion a le plus chang. En effet il n'y a plus que
deux vnements pour la connexion
InfoMessage
C'est de loin mon vnement prfr. Cela fait longtemps que j'utilise ADO et je peux dire que cet
vnement n'aura jamais fait ce que je pouvais esprer. En thorie cela permet de rcuprer les messages
'sans gravit'. Comme l'interprtation du 'sans gravit' varie selon le fournisseur, c'est une programmation
heureuse qui vous attend.
Dans la thorie, une erreur 'pas grave' dclenche un vnement InfoMessage, une erreur 'grave' lve une
exception et une erreur 'trs grave' ferme la connexion. Nous voil bien avancs.
60/130
Pour les aventuriers, regardons le code suivant qui devrait tre utilis pour la gestion des erreurs du
fournisseur.

cn.ConnectionString = @"workstation id=NOM-SZ71L7KTH17;packet
size=4096;user id=sa;data source="NOM-SZ71L7KTH17\\TUTO";persist security
info=False;initial catalog=northwind;password=monpasse";
try {
cn.Open();
cn.StateChange += new StateChangeEventHandler(cn_StateChange);
cn.InfoMessage += new
SqlInfoMessageEventHandler(cn_InfoMessage1);
catch(Exception ex) {
MessageBox.Show("l c'est grave", "ERREUR",
MessageBoxButtons.OK, MessageBoxIcon.Error) ;
}
}
private void cn_InfoMessage1(object sender,

System.Data.SqlClient.SqlInfoMessageEventArgs e) {
MessageBox.Show("L c'est moins grave", "ERREUR",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
private void cn_StateChange(object sender,

System.Data.StateChangeEventArgs e) {
if(e.CurrentState == ConnectionState.Closed && e.OriginalState ==
ConnectionState.Open) {
MessageBox.Show("L ca peut tre trs grave", "ERREUR",
MessageBoxButtons.OK, MessageBoxIcon.Error) ;
}
}
StateChange
Se produit chaque fois que la connexion passe d'ouverte ferme ou inversement.
Sous ces airs anodins il est souvent intressant d'utiliser cet vnement. En effet trois cas peuvent tre
intressants grer.
Les erreurs de procdures stockes ferment la connexion.
Cela permet de grer un contrle vnementiel de la fermeture effective de la connexion.
Attendre l'ouverture relle avant de manipuler les donnes.
Les arguments renvoys sont l'tat d'origine et le nouvel tat.
U
61/130
Objet Transaction
Voil une nouveaut ADO.NET qui est encore une amlioration par rapport ADO.
Maintenant l'appel de BeginTrans cre un objet transaction qu'il est possible d'identifier. Cela permet de
savoir quelles oprations sont incluses dans quelles transactions. Les proprits de l'objet transaction sont
une rfrence la connexion qui supporte la transaction et le niveau d'isolation choisi.
Comme mthodes spcifiques, on trouve
Commit
Valide la totalit de la transaction.
RollBack
Annule la transaction jusqu'au dernier tat stable. Celui-ci peut tre soit la cration de la connexion, soit
le dernier point 'Save' que vous avez dfini.
Save
Permet de fixer un point de la transaction limitant l'effet d'un RollBack.
L'exemple suivant montre une gestion assez complte d'une transaction.
SqlClient.SqlTransaction MaTrans ;
cn.ConnectionString = @"packet size=4096;user id=sa;data
source=NOM-SZ71L7KTH17\\TUTO;persist security info=False;initial
try {
cn.Open();
MaTrans = cn.BeginTransaction(IsolationLevel.Serializable,
"tr1");
SqlClient.SqlCommand MaCommand = new SqlClient.SqlCommand();
MaCommand.CommandText = "UPDATE Products SET UnitPrice =19
WHERE UnitPrice=20";
MaCommand.Connection = cn ;
MaCommand.Transaction = MaTrans ;
MaCommand.ExecuteNonQuery();
MaTrans.Save("tr1");
MaCommand.CommandText = "UPDATE Products SET UnitPrice =19
WHERE UnitPrice=20";
Catch(Exception ex) {
MaTrans.Rollback();
}
MaTrans.Commit() ;
Les commandes
Elles sont identiques aux commandes ADO, avec maintenant la possibilit de ne pas utiliser de magasin
de donnes pour rcuprer le rsultat d'une commande ne renvoyant qu'une valeur. Globalement il y a deux
approches de l'objet commande.
L'action sur la source de donnes attendant ou non des paramtres et renvoyant ou non des
paramtres. Celle-ci regroupe aussi la possibilit de modifier la source l'aide de commande SQL
DDL.
La recherche de donnes ou de rsultats ne ncessitant pas la cration d'un DataSet.
Les actions des commandes sont donc bidirectionnelles. Pour ma part j'ai toujours beaucoup apprci
ces objets dans ma programmation mais je sais que nombre de dveloppeurs ne l'utilisent jamais afin d'crire
un code plus 'gnrique'.
Il existe des commandes gres par le DataAdapter. Celles-ci sont stricto sensu des commandes
ADO.NET. Nous en reparlerons dans la partie DataAdapter.
U
62/130
Proprits
CommandText (String)
Dfinit le texte de la commande SQL, le nom de la table ou le nom de la procdure stocke.
CommandTimeOut (Integer)
Dfinit le temps avant la leve d'une exception si la commande n'a pas abouti.
CommandType
Constantes Valeur Description
CommandText correspond la dfinition textuelle d'une
Text 1
commande ou d'un appel de procdure stocke.
StoredProc 4 CommandText correspond au nom d'une procdure stocke.
CommandText correspond un nom de table dont les colonnes
TableDirect 512
sont toutes renvoyes.
La bonne dfinition de cette proprit est trs importante.
Attention, TableDirect n'est supporte que par la commande OleDbCommand.
Connection(Connection)
Renvoie ou dfinit la connexion sur laquelle la commande est lie. Attention, vous lverez une
exception si la connexion est en cours d'extraction.
Transaction(Transaction)
Renvoie ou dfinit la transaction qui englobe la commande. La transaction dfinie doit forcment
appartenir la connexion dfinie dans la proprit Connection.
Parameters
Renvoie la collection des objets Parameter d'une commande. Voir plus loin l'utilisation dans 'Objet
Parameter' du mme chapitre.
UpdateRowSource
Spcifie comment la commande ragit lors d'une opration de modification (Update). Peut prendre une
des valeurs suivantes :
Nom de membre Description
Both Les paramtres de sortie et la premire ligne retourne sont mapps la ligne
modifie dans DataSet.
FirstReturnedRecord Les donnes de la premire ligne retourne sont mappes la ligne modifie dans
DataSet.
None Tous les paramtres et les lignes retourns sont ignors.
OutputParameters Les paramtres de sortie sont mapps la ligne modifie dans DataSet.
Ceci est plutt utilis dans la mise jours des donnes par les procdures stockes. C'est toutefois aussi
applicable si vous travaillez avec des lots de requtes.
U
63/130
Retour de procdure stocke
Discutons de l'utilisation de cette proprit. Lorsque j'cris une procdure stocke, je possde plusieurs
possibilits d'action. Envisageons l'ajout d'une ligne dans la table 'Authors'. Celle-ci possde une colonne
Auto-incrmente pour le champ 'Au_Id' qui est la cl primaire, un champ texte 'Author' et un champ entier
'year born'. Une Procdure d'ajout va tre du style
CREATE PROCEDURE InsertAuthor
@Auteur nchar(50),
@Annee integer
AS
INSERT INTO Authors (Author, [year born])
VALUES(@Auteur, @Annee)
RETURN @@ROWCOUNT
Cette procdure va fonctionner parfaitement, malheureusement elle est inutilisable en l'tat. En effet, je
ne passe pas de paramtres pour le champ 'Au_Id' puisque c'est le SGBD qui attribue la valeur. Seulement je
ne renvoie pas la valeur cre ce qui fait qu'il sera impossible de mettre jour la table.
Les administrateurs crivent deux sortes de procdure pour grer ce cas.
Utilisation d'un paramtre de sortie
@Auteur nchar(50),
@Annee integer
@Ident integer OUTPUT
AS
SET @ Ident = @@Identity
RETURN @@ROWCOUNT
Dans un cas comme celui-ci il suffit de mapper le paramtre de retour sur la ligne pour mettre la table
jour. Les paramtres de sortie sont simples utiliser et plutt rapides, mais @@IDENTITY pose des
problmes. Normalement @@IDENTITY renvoie la valeur gnre par le SGBD la dernire ligne ajoute
par votre connexion. Si jamais il existe un dclencheur (trigger) ajoutant une information dans une autre
table utilisant un champ auto-incrment, c'est cette valeur que vous allez rcuprer. Avec SQL-Server 2000
vous pouvez utiliser SCOPE_IDENTITY, mais sinon il y a un risque.
Utilisation d'une ligne de retour
Il existe aussi la possibilit de renvoyer la dernire ligne insre par une requte SELECT. Dans ce cas,
c'est la ligne renvoye qu'il faut mapper. Notez bien que le problme de la rcupration de la valeur gnre
reste identique. Imaginons le cas suivant :
@Auteur nchar(50),
@Annee integer
AS
SELECT * FROM Authors WHERE Au_Id=@Ident
RETURN @@ROWCOUNT
Si un dclencheur a gnr une autre valeur la ligne retourne peut tre vide ou une ligne existante, mais
pas celle que vous voulez. Pour rcuprer une valeur fiable vous devez utiliser :
SELECT * FROM Authors WHERE Au_Id=@Ident AND Author=@Auteur
Dans ce cas, vous ne rcuprerez pas de ligne, ce qui vous permettra de dtecter l'erreur.
64/130
Nombres de lignes modifies
Il s'agit l d'un problme un peu similaire, mais qui peut avoir des consquences tout aussi graves. Dans
le fonctionnement de la mthode Update du DataAdapter, il y a vrification du nombre de lignes modifies
pour savoir si la modification a chou. Imaginons que l'objet InsertCommand du DataAdapter fait rfrence
la procdure stocke suivante :
@Auteur nchar(50),
@Annee integer
AS
INSERT INTO Audit(DateMod,Table,Enregistrement)
VALUES(GETDATE(), 'Authors',@Ident)
RETURN @@ROWCOUNT
Il y aura toujours une insertion dans la table 'Audit'. La commande rcuprera comme valeur soit 1 si
l'insertion a choue soit 2 si elle russie, mais en tout cas jamais zro. Ceci fait qu'une insertion qui a
chou sera considre comme ayant aboutie.
Pour ce genre de problme, il est indispensable d'utiliser la commande NOCOUNT correctement. Tout
cela pour vous redire qu'il est indispensable de bien connatre les procdures stockes que l'on utilise.
Mthodes
U
Cancel
Fonctionne l'identique de son homologue ADO, c'est dire mal. Cancel tente d'annuler une commande
en cours mais ne lve pas d'erreur si l'annulation choue.
CreateParameter
Cre un nouvel objet Parameter. Lobjet est cr mais n'est pas dfini.
Je vais en profiter pour faire une digression sur les constructeurs. Avec les langages DotNet comme
vous le savez srement, et sinon vous allez le savoir, on peut dclarer et affecter dans la mme ligne. Les
classes DotNet font toujours appel un constructeur, mais celui-ci peut tre surcharg, c'est dire qu'il
accepte plusieurs paramtrage diffrent. Prenons l'exemple de OleDbParameter. Il utilise le constructeur
New (en C#) qui cre une nouvelle instance de la classe. Le constructeur accepte cinq surcharges :
public void New(String name, object value)
public void New(String name, OleDbType dataType)
public void New(String name, OleDbType dataType, int size)
public void New(String name, OleDbType dataType, int size, string srcColumn)
public void New(string parameterName, OleDbType dbType, int size, ParameterDirection direction,
bool isNullable, byte precision, byte scale, string srcColumn, DataRowVersion srcVersion, object value)
De la mme faon je peux dans la mme ligne, instancier, dfinir et utiliser.
Command1.Parameters.Add(new OleDbParameter("Original_Au_ID",
OleDbType.Integer, 0, ParameterDirection.Input, false, (byte)0, (byte)0,
"Au_ID", DataRowVersion.Original, null));
Ce code est parfaitement juste mais peu lisible. Faites trs attention avec ce type de codage.
ExecuteNonQuery
Execute la commande et renvoie le nombre de lignes affectes par la commande. C'est l'excution
classique d'une commande comme dans ADO. Si la commande est une requte SELECT, la valeur retourne
est 1.
Il y a tout de mme valorisation des paramtres de sortie et de retour.
65/130
ExecuteReader
Cette mthode sert crer un objet DataReader. Cette mthode attend un paramtre CommandBehavior
qui peut prendre les valeurs suivantes.
Default 0 quivaut fonctionnellement l'appel ExecuteReader().
SingleResult 1 La requte retourne un jeu de rsultat unique.
2 La requte retourne uniquement les informations de colonne et
SchemaOnly
n'affecte pas l'tat de la base de donnes.
4 La requte retourne des informations de colonne et de cl primaire.
KeyInfo
Elle est excute sans verrouiller les lignes slectionnes.
8 La requte retourne normalement une ligne unique. L'excution de la
requte peut affecter l'tat de la base de donnes. Certains fournisseurs
de donnes .NET Framework peuvent ventuellement utiliser ces
informations pour optimiser les performances de la commande.
Lorsque vous spcifiez SingleRow avec la mthode ExecuteReader
de l'objet OleDbCommand, le fournisseur de donnes.NET
Framework pour OLE DB effectue la liaison l'aide de l'interface
SingleRow IRow OLE DB si elle est disponible. Sinon, il utilise l'interface
IRowset. Si votre instruction SQL doit normalement retourner une
seule ligne, la spcification de SingleRow peut galement amliorer
les performances de l'application.
Il est possible de spcifier SingleRow lorsque vous excutez des
requtes qui retournent plusieurs jeux de rsultats. Dans ce cas,
plusieurs jeux de rsultats sont toujours retourns, mais chaque jeu
possde une ligne unique.
16 Fournit DataReader un moyen de grer les lignes qui contiennent
des colonnes renfermant des valeurs binaires leves. Plutt que de
charger la ligne entire, SequentialAccess permet DataReader de
charger les donnes en tant que flux. Vous pouvez ensuite utiliser la
mthode GetBytes ou GetChars afin de spcifier un emplacement
d'octets partir duquel dmarrer l'opration de lecture, ainsi qu'une
taille limite de mmoire tampon pour les donnes retournes.
Lorsque vous spcifiez SequentialAccess, vous tes oblig de lire les
SequentialAccess
colonnes dans l'ordre o elles sont retournes, mais il n'est cependant
pas ncessaire de lire chaque colonne. Lorsque vous avez lu au-del
d'un emplacement du flux de donnes retourn, les donnes situes
jusqu' cet emplacement ne peuvent plus tre lues partir de
DataReader. Si vous utilisez OleDbDataReader, vous pouvez relire la
HTU UTH
valeur de la colonne en cours jusqu' ce que vous lisiez au-del de

celle-ci. Si vous utilisez SqlDataReader, une valeur de colonne peut
HTU UTH
tre lue une seule reprise.

32 Lorsque la commande est excute, l'objet Connection associ se
CloseConnection
ferme en mme temps que l'objet DataReader.
L'appel de l'objet DataReader renvoie normalement un curseur de type FireHose. Rappelons ici ses
principales caractristiques. Le DataReader va tre en lecture seule. Il ne peut se dplacer que vers l'avant,
d'une ligne la fois. Seul l'enregistrement lu se trouve dans votre cache. Ceci fait que les modifications
engendres par d'autres utilisateurs sur des enregistrements non encore lus seront prises en compte. Il n'est
pas possible avec un tel objet de dterminer combien de lignes seront effectivement renvoyes.
66/130
Bien que nous voyions plus en dtail son utilisation plus loin, voil la gestion classique d'un
DataReader.

SqlClient.SqlDataReader dtaRead;
SqlClient.SqlCommand
MaCommand = new SqlClient.SqlCommand();
cn.Open();
MaCommand.CommandText = "SELECT * FROM Products";
MaCommand.CommandType = CommandType.Text;
MaCommand.Connection = cn;
dtaRead =
MaCommand.ExecuteReader(CommandBehavior.CloseConnection);
while(dtaRead.Read()) {
this.ComboBox1.Items.Add(dtaRead.GetString(1));
}
}
Notez qu'il faut toujours faire au moins un appel Read car le positionnement du DataReader sa
cration est avant le premier enregistrement.
ExecuteScalar
Cette mthode permet de rcuprer un rsultat unique sans crer de jeu de donnes. Elle est spcialement
utilise pour rcuprer le rsultat d'une requte d'agrgation.

SqlClient.SqlCommand MaCommand = new SqlClient.SqlCommand();
cn.Open();
MaCommand.CommandText = "SELECT Count(*) FROM Products";
MaCommand.CommandType = CommandType.Text;
MaCommand.Connection = cn;
MessageBox.Show(.ExecuteScalar());
}
Il y a un intrt certain ne pas crer de jeux d'enregistrements pour obtenir une seule rponse.
Cependant il convient de ne pas remplacer la cration d'un jeu de donnes, DataReader ou Dataset par la
multiplication d'appel ExecuteScalar.
Prepare
Identique dans ADO. Ceci consiste compiler une requte avant de l'excuter. Certaines rgles doivent
s'appliquer avant de dcider d'une telle action :
Une requte excute une fois ne doit pas tre compile
L'ensemble des paramtres doit tre correctement dfini avant de prparer une commande. Une
dfinition correcte sous-entend que chaque paramtre possde un type et que chaque paramtre
ayant un type de longueur variable ait une taille dfinie.
La connexion sur laquelle s'appuie la commande doit tre dfinie et ouverte.
U
67/130
Objet Parameter
Dans cette partie et dans la suivante, nous allons regarder la manipulation des paramtres dans
ADO.NET. Il convient de concevoir ce qu'on entend par paramtres. Il existe trois types de paramtres dont
deux sont uniquement utiliss dans le cadre des procdures stockes.
Les paramtres d'entre : Ce sont ceux que vous communiquez votre requte / procdure afin qu'elle
puisse fonctionner.
Les paramtres de sortie : Ils sont dfinis par une procdure stocke. La rcupration de leurs valeurs n'a
de sens qu'aprs excution mais il est parfois ncessaire d'interroger la procdure pour connatre leurs types
ou leurs tailles.
Les paramtres de retour : Il s'agit d'une valeur parfois renvoyer par l'instruction RETURN. En gnral,
on utilise ce paramtre pour indiquer l'tat de succs de la procdure.
Les objets paramtres appartiennent un espace de nom, nous trouverons donc selon les cas des objets
SqlParameter, OleDBParameter, etc
Les paramtres appartiennent une collection qui est lie soit la commande, soit au mappage d'un
Dataset dans le DataAdapter. Une astuce classique consiste se rappeler que les mthodes appartiennent la
collection et les proprits au paramtre.
Il y a deux possibilits d'utilisation selon les fournisseurs.
Utiliser des paramtres nomms
C'est le mode obligatoire pour travailler avec le fournisseur SQL-Server. Attention cela ne veut pas dire
que vous ne pouvez pas passer par le mode ordinal dans ADO.NET. Cela veut juste dire que le texte de la
commande doit utiliser des paramtres nomms et non des espaces rservs (?). Les paramtres peuvent tre
ajouts la collection dans l'ordre de votre choix.
Utiliser des espaces rservs
C'est le mode privilgi du fournisseur OLEDB. Attention, certains SGBD n'acceptent pas cette syntaxe
et forcent l'utilisation de paramtres nomms. Les espaces rservs attendent une dfinition dans l'ordre de
leur apparition. Il n'existe aucune drogation cette rgle puisque les paramtres n'ont pas de noms.
OleDbCommand MaCommand = new OleDbCommand("UPDATE Authors SET Author=?,
[year born]=? WHERE Au_Id = ?", MaConn) ;
MaCommand.Parameters.Add("Au_Id", OleDbType.Integer).Value = 1;
MaCommand.Parameters.Add("Annee", OleDbType.SmallInt).Value = 1967;
MaCommand.Parameters.Add("Auteur", OleDbType.VarChar, 50).Value =
"RABILLOUD";
int Retour = MaCommand.ExecuteNonQuery();
MessageBox.Show(Retour.ToString);
Dans ce cas la valeur de retour va tre 0 mais aucune exception ne sera leve.
OleDbCommand MaCommand = new OleDbCommand("UPDATE Authors SET Author=?,
[year born]=? WHERE Au_Id = ?", MaConn) ;
MaCommand.Parameters.Add("Auteur", OleDbType.VarChar, 50).Value =
"RABILLOUD";
MaCommand.Parameters.Add("Annee", OleDbType.SmallInt).Value = 1967;
MaCommand.Parameters.Add("Au_Id", OleDbType.Integer).Value = 1;
int Retour = MaCommand.ExecuteNonQuery();
MessageBox.Show(Retour.ToString);
Par contre, cette commande va fonctionner correctement puisque les paramtres sont bien ajouts dans
le mme ordre que leur apparition dans la commande.
68/130
Mthodes de ParameterCollection
Add
Il existe plusieurs versions surcharges de cette mthode. Dans le principe on ajoute toujours un objet
paramtre la collection. On peut faire la dfinition dans la mme ligne que l'ajout mais ce n'est pas
recommandable.
public override SqlParameter Add(String parameterName, SqlDbType sqlDbType, int size, String
sourceColumn)
Clear
Supprime les paramtres de la collection.
Contains
Vrifie la prsence d'un paramtre dans une commande. Existe dans deux syntaxes permettant de
chercher le paramtre par son nom ou par sa valeur.
CopyTo
Fait une copie des paramtres d'une collection dans un tableau.
IndexOf
Renvoie la position ordinale d'un paramtre dans la collection. Accepte le nom ou l'objet paramtre
comme argument.
Insert
Insre un objet paramtre la position indique
Remove
Enlve le paramtre pass en argument.
RemoveAt
Similaire la prcdente mthode, mais accepte comme argument la position ordinale ou le nom du
paramtre.
Proprits des paramtres
DBType (Dbtype)
Dfinit le type du paramtre. Il convient de faire attention car si celui-ci n'est pas dfini, il y aura
dfinition d'un type en partant de la valeur du paramtre. Ce comportement prsente un risque lev quant au
fonctionnement de l'application. Le tableau de mappage suivant rsume les types utiliser.
69/130
Type .NET DbType SqlDbType OleDbType OdbcType OracleType
Framework
bool Boolean Bit Boolean Bit Byte
byte Byte TinyInt UnsignedTinyInt TinyInt Byte
byte[] Binary VarBinary. Cette VarBinary Binary Raw
conversion
implicite chouera
si le tableau
d'octets est
suprieur la taille
maximale de
VarBinary, soit
8 000 octets.
char La dduction de Char Char Byte
SqlDbType partir
de char n'est pas
prise en charge.
DateTime DateTime DateTime DBTimeStamp DateTime DateTime
Decimal Decimal Decimal Decimal Numeric Number
double Double Float Double Double Double
float Single Real Single Real Float
Guid Guid UniqueIdentifier Guid UniqueIdentifier Raw
Int16 Int16 SmallInt SmallInt SmallInt Int16
Int32 Int32 Int Int Int Int32
Int64 Int64 BitInt BigInt BigInt Number
object Object Variant Variant La dduction de Blob
OdbcType partir
de Object n'est pas
prise en charge.
string String NVarChar. Cette VarWChar NVarChar NVarChar
conversion
implicite chouera
si la chane est
suprieure la
taille maximale de
NVarChar, soit
4 000 caractres.
Timespan Time La dduction de DBTime Time DateTime
SqlDbType partir
de TimeSpan n'est
pas prise en
charge.
UInt16 UInt16 La dduction de UnsignedSmallInt Int UInt16
SqlDbType partir
de UInt16 n'est pas
prise en charge.
UInt32 UInt32 La dduction de UnsignedInt BigInt UInt32
SqlDbType partir
de UInt32 n'est pas
prise en charge.
70/130
Type .NET DbType SqlDbType OleDbType OdbcType OracleType
Framework
UInt64 UInt64 La dduction de UnsignedBigInt Numeric Number
SqlDbType partir
de UInt64 n'est pas
prise en charge.
AnsiString VarChar VarChar VarChar VarChar
AnsiStringFixedLength Char Char Char Char
Currency Money Currency La dduction de Number
OdbcType partir
de Currency n'est
pas prise en
charge.
Date La dduction de DBDate Date DateTime
SqlType partir de
Date n'est pas prise
en charge.
SByte La dduction de TinyInt La dduction de SByte
SqlType partir de OdbcType partir
SByte n'est pas de SByte n'est pas
prise en charge. prise en charge.
StringFixedLength NChar WChar NChar NChar
Time La dduction de DBTime Time DateTime
SqlType partir de
Time n'est pas
prise en charge.
VarNumeric La dduction de VarNumeric La dduction de Number
SqlDbType partir OdbcType partir
de VarNumeric de VarNumeric
n'est pas prise en n'est pas prise en
charge. charge.
Direction (ParameterDirection)
Peut prendre une des valeurs suivantes :
Nom de membre Description
Input Le paramtre est un paramtre d'entre.
InputOutput Le paramtre est la fois un paramtre d'entre et de sortie.
Output Le paramtre est un paramtre de sortie.
ReturnValue Le paramtre reprsente une valeur de retour d'une opration telle qu'une procdure
stocke, une fonction intgre ou une fonction dfinie par l'utilisateur.
IsNullable (Boolen)
Indique si le paramtre peut prendre la valeur NULL.
Offset (SQL parameter uniquement)
Utilise avec les types Long Binary et Long String. Indique la taille des fragments passs au client.
Precision (Byte)
Uniquement si le type est 'Decimal'. Dfinit le nombre de chiffres utiliss pour donner la valeur. Elle ne
peut tre spare de la dfinition de la proprit 'Scale'. La version 1.0 du FrameWork ne vrifie pas les
valeurs de ces deux proprits.
Scale (Byte)
Dfinit le nombre de dcimal d'une donne de type dcimal. Lie la proprit prcision.
71/130
Size (Integer)
Dfinie la taille en octet d'un paramtre d'entre. N'est utilise qu'avec des types de donnes de longueur
variable (chane ou binaire). L encore la taille sera dduite si elle n'est pas dfinie.
SourceColumn (String)
Utilise les informations de mappage pour attribuer une valeur au paramtre.
C'est en fait comme cela que travaillent gnralement les commandes de mise jour du DataAdapter.
Regardons le code suivant :
//OleDbUpdateCommand
Command1.CommandText = "UPDATE Authors SET Author = ?, [Year
Born] = ? WHERE (Au_ID = ?) AND (Author = ? " & _
"OR ? IS NULL AND Author IS NULL) AND ([Year Born] = ? OR ? IS
NULL AND [Year Bor" & _
"n] IS NULL)";
Command1.Connection = Me.OleDbConnection1;
Command1.Parameters.Add(new OleDbParameter("Author",
OleDbType.VarWChar, 50, "Author"));
Command1.Parameters.Add(new OleDbParameter("Year_Born",
OleDbType.SmallInt, 0, "Year Born"));
Command1.Parameters.Add(new OleDbParameter("Original_Au_ID",
OleDbType.Integer, 0, ParameterDirection.Input, false, (byte)0,
(byte)0,""Au_ID", DataRowVersion.Original, null));
Command1.Parameters.Add(new OleDbParameter("Original_Author",
OleDbType.VarWChar, 50, ParameterDirection.Input, false, (byte)0,
(byte)0," "Author", DataRowVersion.Original, null));
Command1.Parameters.Add(new OleDbParameter("Original_Author1",
(byte)0," "Author", DataRowVersion.Original, null));
Command1.Parameters.Add(new OleDbParameter("Original_Year_Born",
OleDb.OleDbType.SmallInt, 0, ParameterDirection.Input, false, (byte)0,
(byte)0,""Year Born", DataRowVersion.Original, null));
Command1.Parameters.Add(new OleDbParameter("Original_Year_Born1",
OleDbType.SmallInt, 0, ParameterDirection.Input, false, (byte)0,
(byte)0,"Year Born", DataRowVersion.Original, null));
Le texte de la commande est de la forme :
Command1.CommandText = "UPDATE Authors SET Author = ?, [Year Born] = ?
WHERE (Au_ID = ?) AND (Author = ? OR ? IS NULL AND Author IS NULL) AND
([Year Born] = ? OR ? IS NULL AND [Year Born] IS NULL)";
Je dois donc passer sept paramtres ma commande. Il serait fastidieux de grer la vole tous ces
paramtres, nous allons donc utiliser les proprits des paramtres.
Pour un paramtre passant une des valeurs nouvelles, la syntaxe est :
Command1.Parameters.Add(New OleDbParameter("Author", OleDbType.VarWChar,
50, "Author"));
Soit de la forme :
OleDbParameter Add(String parameterName, OleDbType oleDbType, int size,String sourceColumn)
Pour le paramtre devant passer l'ancienne valeur du mme champ
Command1.Parameters.Add(new OleDbParameter("Original_Author",
(byte)0,"Author", DataRowVersion.Original, null));
Soit de la forme :
New(String parameterName, OleDbType dbType, Integer size, ParameterDirection direction, bool
isNullable, byte precision, byte scale, String srcColumn, DataRowVersion srcVersion, object value)
72/130
SourceVersion (DataRowVersion)
Dfinit la version de la colonne dsigne par SourceColumn pour valoriser le paramtre. Peut prendre
une des valeurs suivantes :
membre Description
Current Le paramtre utilise la valeur actuelle de la colonne. Il s'agit de la valeur par dfaut.
Default Le paramtre utilise le DefaultValue de la colonne.
Original Le paramtre utilise la valeur d'origine de la colonne.
Proposed Le paramtre utilise une valeur propose.
La classe DataReader
Nous avons donc vu que l'objet DataReader est obtenu par l'intermdiaire d'un objet Command et d'un
objet Connection. Dans le cas de cette classe, vous ne pouvez pas utiliser directement un constructeur, il est
obligatoire d'appeler la mthode ExecuteReader.
L'objet DataReader est exclusif sur la connexion, tout comme l'est le curseur quivalent dans ADO. Ceci
revient dire que la connexion utilise par le service du DataReader ne supportera aucun autre composant.
Seul peut tre appel sa mthode Close. La connexion est libre si vous fermez l'objet DataReader.
Il y a leve d'une exception sur l'appel d'une connexion dj utilise par un DataReader.
La visibilit des modifications induites par d'autre processus est assez difficile percevoir. Disons que
les enregistrements supprims ou modifis n'ayant pas encore t lus seront vus avec les modifications. Il
faut donc se mfier de la possibilit d'avoir une lecture partiellement incohrente. J'entends par-l qu'il est
tout fait possible qu'une opration ait lieu pendant la lecture et affectant des enregistrements dj lus et
d'autres non.
Le DataReader est idal pour le parcours unique d'un jeu d'enregistrement, des fins de remplissage par
exemple. Il est soumis aux rgles des objets connects, ce qui veut dire qu'il doit tre utilis le moins
longtemps possible. N'oubliez jamais que c'est le serveur qui fournit le curseur, n'abusez donc pas de ces
objets sur un mme serveur.
Le code suivant est un exemple standard de manipulation du DataReader.

SqlClient.SqlConnection MaConn = new
SqlClient.SqlConnection(@"packet size=4096;user id=sa;data source=NOM-
catalog=pubs;password=monpasse");
MaConn.Open();
string strSQL = "SELECT Author FROM Authors";
SqlClient.SqlCommand MaComm = new SqlClient.SqlCommand(strSQL,
MaConn);
MaComm.CommandType = CommandType.Text;
SqlClient.SqlDataReader dtaRead = MaComm.ExecuteReader();
while(dtaRead.Read())
this.ComboBox1.Items.Add(dtaRead.GetSqlString(0));
}
dtaRead.Close();
}
U
73/130
Proprits
FieldCount (Integer)
Renvoie le nombre de colonnes (champ) prsent dans la ligne en cours.
HasRows (Boolen)
Renvoie vrai si le jeu d'enregistrements contient au moins une ligne.
IsClosed (Boolen)
Renvoie vrai si l'objet est ferm.
Item
Renvoie la valeur de la colonne dans son format natif. On peut identifier la colonne par son nom ou par
sa position ordinale. Il est toujours meilleur pour les performances de prfrer la position ordinale. Item peut
toujours tre omis, mais la syntaxe ainsi obtenue est particulirement absconse.
RecordsAffected (Integer)
Cette proprit est particulire plus d'un point. En effet il n'est pas simple de comprendre ce qui peut
affecter des enregistrements avec un curseur en lecture seule. Cette proprit renvoie le nombre
d'enregistrements affects avec l'emploi d'une procdure stocke ou d'un traitement SQL par lot comprenant
des requtes actions. Dans la plupart des cas elle renverra 1. Il faut accder cette valeur aprs fermeture de
DataReader autant que faire se peut pour obtenir un rsultat fiable.
Mthodes
U
Dans la plupart des mthodes de rcupration de valeur, il faut dsigner la colonne cible par son numro
ordinal.
Close
Ferme le DataReader. Ceci libre la connexion. Seule les proprits IsClosed et RecordsAffected sont
encore accessibles aprs la fermeture.
Attention, dans le cas d'une procdure stocke, les paramtres de sortie ne sont valoriss qu'aprs l'appel
de la mthode Close.
GetBoolean, GetByte, GetChar, etc.
Renvoie la valeur d'une colonne sous la forme d'une donne type telle que demande dans la mthode
Get type.
Il n'y a pas conversion effective de la valeur, vous devez donc tre sr que la donne sera bien du type
spcifi. On utilise souvent la mthode IsDbNull avant.
GetDataTypeName, GetFieldType
Renvoie le type ou le nom du type de la colonne dsigne.
GetName, GetOrdinal
Renvoie le nom de la colonne en fonction de sa position ou inversement.
74/130
GetSchemaTable
Permet de rcuprer les informations de colonnes (mta-donnes) dans un objet DataTable. Cette
mthode implique donc la cration d'un DataSet. C'est partiellement l'quivalent de la mthode OpenSchema
ADO. Vous devez passer KeyInfo comme paramtre de la mthode ExecuteReader pour que les informations
renvoyes soient correctes.
Les informations renvoyes sont :
Colonne DataReader Description
Nom de la colonne. S'il ne peut pas tre dtermin, une valeur Null est retourne.
ColumnName
Ce nom reflte toujours le dernier nom attribu la colonne (Alias par exemple).
Numro de la colonne. Il s'agit de zro pour le signet de colonne de la ligne, le
ColumnOrdinal cas chant. Les autres colonnes sont numrotes partir de un. Cette colonne ne
peut pas contenir de valeur Null.
Longueur maximale possible pour une valeur de la colonne. Pour les colonnes qui
ColumnSize utilisent un type de donnes de longueur fixe, il s'agit de la taille du type de
donnes.
Si ProviderType est un type de donnes numrique, il s'agit de la prcision
NumericPrecision maximale de la colonne. La prcision dpend de la dfinition de la colonne.
Sinon, il s'agit d'une valeur Null.
Si ProviderType est DBTYPE_DECIMAL ou DBTYPE_NUMERIC, il s'agit du
NumericScale nombre de chiffres droite de la virgule dcimale. Sinon, il s'agit d'une valeur
Null.
true : deux lignes figurant dans la table retourne dans BaseTableName ne
peuvent pas avoir la mme valeur dans cette colonne ; c'est dire si la colonne
constitue une cl en soi ou s'il existe une contrainte de type UNIQUE qui
IsUnique
s'applique uniquement cette colonne.
false : La colonne peut contenir des valeurs dupliques dans la table de base. La
valeur par dfaut de cette colonne est false.
true : la colonne fait partie d'un ensemble de colonnes du jeu de lignes qui, dans
son ensemble, identifie de manire unique la ligne. L'ensemble de colonnes avec
IsKey gal true doit identifier de manire unique une ligne du jeu de lignes. Ce
IsKey jeu de colonnes ne doit pas obligatoirement tre un jeu minimal de colonnes. Ce
jeu de colonnes peut tre gnr partir de la cl primaire d'une table de base,
d'une contrainte unique ou d'un index unique.
false : la colonne n'est pas tenue d'identifier de manire unique la ligne.
BaseServerName Le nom de l'instance de Microsoft SQL Server utilise par SqlDataReader.
HTU UTH
Nom du catalogue dans le magasin de donnes qui contient la colonne. NULL si

BaseCatalogName
le nom du catalogue de base ne parvient pas tre dtermin.
Nom de la colonne dans le magasin de donnes. Il peut tre diffrent du nom de
colonne retourn dans la colonne ColumnName si un alias a t utilis. Valeur
BaseColumnName Null si le nom de la colonne de base ne peut pas tre dtermin ou si la colonne
du jeu de lignes est drive d'une colonne du magasin de donnes, et non
identique celle-ci.
Nom du schma dans le magasin de donnes qui contient la colonne. Valeur Null
BaseSchemaName
si le nom du schma de base ne peut pas tre dtermin.
Nom de la table ou de la vue dans le magasin de donnes qui contient la colonne.
BaseTableName
Valeur Null si le nom de la table de base ne peut pas tre dtermin.
DataType Type de la colonne au type .NET Framework
Dfini si le consommateur ne peut pas affecter de valeur Null la colonne ou si le
fournisseur ne parvient pas dterminer si le consommateur peut affecter une
AllowDBNull
valeur Null la colonne. Non dfini dans les autres cas. Une colonne peut
contenir des valeurs Null, mme si une valeur Null ne peut pas lui tre affecte.
Indicateur du type de donnes de la colonne. Si le type de donnes de la colonne
ProviderType varie d'une ligne l'autre, il doit s'agir de la valeur Object. Cette colonne ne peut
pas contenir de valeur Null.
75/130
Colonne DataReader Description
IsAliased true si le nom de la colonne est un alias, sinon, false.
IsExpression true si la colonne est une expression, sinon, false.
IsIdentity true si la colonne est une colonne identit, sinon, false.
true : la colonne assigne des valeurs aux nouvelles lignes selon des incrments
fixes. false :La colonne n'assigne pas des valeurs aux nouvelles lignes par
IsAutoIncrement
incrments fixes.
La valeur par dfaut de cette colonne est false.
Dfinit si la colonne contient un identificateur de ligne persistant dans lequel il
IsRowVersion est impossible d'crire et ne possde aucune valeur significative, except pour
identifier la ligne.
IsHidden true si la colonne est masque, sinon, false.
Dfini si la colonne comporte un objet binaire volumineux (BLOB, Binary Long
IsLong OBject) comportant des donnes trs volumineuses. La dfinition des donnes
trs volumineuses est propre au fournisseur.
IsReadOnly true si la colonne ne peut pas tre modifie, sinon, false.
GetSqlBinary, GetSqlBoolean, etc

Permet de rcuprer les donnes sous forme de types mapps SqlType. Les donnes dcrites dans ces
types sont plus facilement manipulable (voir avant Type Sql).
GetValue, GetSqlValue
Rcupre un objet reprsentant la donne soit dans le type Framework, soit dans le type SQL.
GetValues, GetSqlValues
Renvoient un tableau d'objets contenant toutes les donnes de la ligne.
IsDBNull
Renvoie vrai si la donne est Null. En fait s'il s'agit d'un objet DBNull. Cet objet permet de travailler
comme dans ADO puisqu'il sait faire la diffrence entre une valeur Null (VT_NULL) et une ligne non
initialise (VT_EMPTY). Les oprations avec Null suivent les rgles classiques.
NextResult
Permet de changer le jeu de rsultat actif dans les oprations par lot.
Imaginons le cas suivant. Je vais appeler la procdure suivante :
CREATE PROCEDURE EssaiParamSortie (@ParSortie Integer OUTPUT) AS
SELECT @ParSortie = Count(Au_Id) FROM Authors;
SELECT au_lname FROM Authors;
GO
76/130
Cette procdure va nous permettre de comprendre la valorisation des paramtres de sortie par un
DataReader. Notez qu'il a t crit pour le fournisseur manag pour SQL-Server.

SqlClient.SqlConnection MaConn = new
SqlClient.SqlConnection(@"packet size=4096;user id=sa;data source=NOM-
catalog=pubs;password=monpasse");
MaConn.Open();
string strSQL = "EssaiParamSortie";
SqlClient.SqlCommand MaComm = new SqlClient.SqlCommand(strSQL,
MaConn);
MaComm.CommandType = CommandType.StoredProcedure;
SqlClient.SqlParameter MonParam = new SqlClient.SqlParameter();
MonParam.ParameterName = "@ParSortie";
MonParam.Direction = ParameterDirection.Output;
MonParam.DbType = DbType.Int32;
MaComm.Parameters.Add(MonParam);
SqlClient.SqlDataReader dtaRead = MaComm.ExecuteReader();
MessageBox.Show((string)(MonParam.Value));
do{
while(dtaRead.Read())
this.ComboBox1.Items.Add(dtaRead.GetSqlString(0));
}
}while(dtaRead.NextResult());
dtaRead.Close();
}
Vous verrez que la valeur du paramtre n'est correctement documente qu' la sortie de la boucle
NextResult.
Read
Cette mthode avance le curseur jusqu' l'enregistrement suivant. Elle renvoie True s'il reste des
enregistrements aprs, sinon False. Attention l'appel de Read ne signifie pas la rcupration des valeurs.
77/130
La classe DataAdapter
Pour apprhender correctement le DataAdapter, il faut le voir dans une certaine mesure comme un
moteur de curseur configurable. En effet, il change des informations entre la source et le jeu de donnes. On
peut l'utiliser de faon assez transparente ou configurer finement son paramtrage afin de savoir exactement
quelles donnes et mta-donnes seront renvoyes.
Le Schma suivant va nous permettre de mieux comprendre le fonctionnement.
Comme nous l'avons dj dit, il n'y a jamais de connexion directe entre le DataSet et la source de
donnes. Le DataSet ne peut communiquer qu'avec le DataAdapter l'aide des mthodes que celui-ci fournit.
Le DataAdapter quant lui communique avec la source en utilisant un objet Connection et quatre objets
Command. On peut dire qu' minima, il faut qu'il y ait une commande Select et une connexion un
DataAdapter pour fonctionner.
Plusieurs types de requtes sont comprises dans les mthodes Fill selon que l'on souhaite rcuprer des
donnes, des mta-donnes ou les deux. De la mme manire, l'appel de la mthode Update peut entrainer
des actions diverses selon le paramtrage. Nanmoins une chose est invariable, il y a toujours utilisation des
objets Command pour transmettre les actions.
L'objet CommandBuilder que vous voyez permet de laisser le DataAdapter crer les objets Command
Action en fonction des informations qu'il trouve dans l'objet Command Select. Les objets Command utiliss
par le DataAdapter peuvent tre des requtes SQL, des noms de tables, des procdures stockes
Habituellement, un DataAdapter ne prends en charge qu'une table d'un DataSet, mais cela n'est pas une
obligation.
Schma et Mappage
U
Il faut ici dterminer ici ces termes pour que nous nous comprenions correctement.
Le mappage est la lecture du schma de la source de donnes que fait le DataAdapter.
Le schma est la lecture du schma du DataSet que fait le DataAdapter.
Un DataAdapter contient une collection TableMappings qui lui permet de faire le lien entre le schma de
la source et le schma du DataSet. Gnralement les deux sont identiques, mais il arrive que non. Lorsqu'il
n'y a pas de liaison entre les deux, le DataAdapter peut rencontrer des problmes lors des tentatives de mises
jour. Pour viter des erreurs malheureusement frquentes vous devez soit grer entirement le mappage par
le code, soit laisser le DataAdapter le grer entirement.
U
78/130
Proprits
AcceptChangesDuringFill (Boolen)
Valeur par dfaut True. Indique si l'tat des enregistrements (DataRow) passe 'Unchanged' lors d'une
opration Fill ou si celui-ci reste dans son tat de modification.
Cette proprit ne doit pas tre modifie lors du premier Fill sauf dans le cas o vous souhaitez
rcuprer une table d'une source de donne pour l'insrer dans une autre source. Lorsque vous procder
plusieurs oprations Fill successives, il peut tre intressant de passer cette proprit False afin de dtecter
les enregistrements ayant subi des modifications du fait d'autres utilisateurs.
ContinueUpdateOnError (Boolen)
Stipule le comportement lors d'une erreur de mise jour. Valeur par dfaut False.
Nous reviendrons sur cette proprit plus loin, car elle dfinit un choix stratgique dans la mise jour
d'une source de donnes. Si sa valeur est vraie, il n'y a pas de leve d'exception lors d'une erreur de mise
jour d'une ligne. La proprit RowError rcupre les valeurs d'erreurs et le traitement continu.
MissingMappingAction
Dtermine le comportement du DataAdapter au cas ou des informations de mappage manquent. Voir
plus loin TableMapping. Peut prendre une des valeurs suivantes :
Nom Description
Error Une exception InvalidOperationException est gnre si le mappage de la
colonne spcifie est manquant.
Ignore Toute colonne ou table ne possdant pas de mappage est ignore. Retourne une
rfrence Nothing dans Visual Basic.
Passthrough La table ou colonne source est cre et ajoute DataSet l'aide de son nom
d'origine.
MissingSchemaAction
Dtermine le comportement du DataAdapter au cas o les informations de schma manquent. Peut
prendre une des valeurs suivantes :
Nom Description
Add Ajoute les colonnes ncessaires pour achever le schma.
Ajoute les colonnes et les informations de cl primaire ncessaires pour
achever le schma. L'utilisateur peut galement dfinir de manire explicite les
AddWithKey contraintes de cl primaire sur chaque DataTable. De cette faon, les
enregistrements entrants qui correspondent des enregistrements existants sont
mis jour plutt que d'tre ajouts.
Une exception InvalidOperationException est gnre si le mappage de
Error
colonnes spcifies est manquant.
Ignore Ignore les colonnes supplmentaires.
79/130
TableMappings
C'est la collection qui reprsente le mappage effectu par le DataAdapter. Rappelez-vous que le
mappage concerne une source de donnes et un objet DataSet. Si vous avez laiss le DataAdapter grer le
mappage, il existe un objet nomm 'Table' dans cette collection. Sinon, c'est vous de la remplir
correctement. Par exemple :
DataTableMapping PersMap = dtaAdapt.TableMappings.Add("Authors",
"Auteurs");
dtaAdapt.ColumnMappings.Add( "Au_Id", "NumAut");
dtaAdapt.ColumnMappings.Add( "Author", "Auteur");
dtaAdapt.ColumnMappings.Add( "year born", "Annee");
Le mappage doit tre fait avant l'appel d'une mthode Fill ou Update sinon le DataAdapter fera son
mappage par dfaut. Ne vous inquitez pas si vous trouvez tout cela un peu abscons, nous verrons un
exemple dtaill dans la troisime partie.
Mthodes
U
Fill
C'est donc la mthode de rcupration des donnes vers un DataSet. Il existe plusieurs versions
surcharges, mais seules deux sont gnralement utilises selon que la cible sera un DataTable simple ou un
DataSet plus complexe.
La syntaxe est de la forme :
public override int Fill(DataSet NomDataSet, String NomDataTable);
La valeur retourne est le nombre de lignes rapatries. Si DataTable existe dj les lignes existantes sont
mises jour.
Cette mthode fait appel l'objet Command SELECT du DataAdapter. Celui-ci doit contenir une
commande valide. Si la connexion utilise est ferme, la mthode Fill l'ouvre le temps du rapatriement et la
referme, sinon la connexion reste ouverte aprs le remplissage.
Si la commande renvoie plusieurs jeux de rsultats, il sera cr autant de table que de jeux. Si une erreur
survient pendant l'opration, les donnes dj rapatries seront gardes et l'opration sera arrte.
Lorsqu'on utilise la mthode Fill pour actualiser des donnes, la commande SELECT ne doit pas avoir
t modifie. De plus, il faut que la ou les colonnes dfinissant la cl primaire doivent tre renseignes. Si tel
n'est pas le cas, les lignes seront dupliques. Si la requte est une requte avec jointure vous devrez crer
vous-mmes la cl.
FillSchema
Mthode de rcupration des informations de schma. Lors de l'utilisation de la mthode Fill, seuls les
noms de colonnes sont rcuprs. Si vous voulez rcuprer des informations de schma, vous devez utiliser
cette mthode
public override DataTable[] FillSchema(DataSet NomDataSet, SchemaType TypeSchema, String
NomTable);
O SchemaType peut prendre une des valeurs suivantes :
Mapped Applique le mappage sur les tables dj existantes du DataSet
Source Pas de modification sur les tables existantes
Les informations de schma rcupres pour les colonnes sont
AllowDBNull
AutoIncrement
MaxLength
ReadOnly
Unique
Si la ou les colonnes dfinissant la cl primaire sont renvoyes par la requte, la cl est ajoute au
schma. Sinon la cl primaire sera dfinie par une colonne ayant la contrainte d'unicit s'il y en a une.
La cl primaire et les contraintes d'unicit sont les seules contraintes rcupres.
80/130
GetFillParameters
Permet de rcuprer les paramtres de l'utilisateur dans la requte SELECT.
Update
C'est la mthode dclenchant l'envoie des modifications faites dans le DataSet vers la source de donnes.
Il existe plusieurs versions surcharges mais la plus commune est :
public override int Update(DataSet NomDataSet, string NomDataTable)
La valeur retourne correspond au nombre de lignes correctement modifies dans la source.
Je vous ai dj expliqu le fonctionnement gnral mais nous allons recommencer car il est primordial
de bien comprendre ce qui se passe.
Votre DataSet contient la DataTable qui va servir de source de modification. Celle-ci peut tre vue
comme une collection d'objets DataRow. Lors de l'appel de la mthode Update, le DataAdapter va regarder
la proprit RowState de chaque ligne et tenter de rpercuter les modifications de toutes celles qui ne sont
pas marques 'Unchanged'. Normalement la lecture se fait dans l'ordre de tri actuellement slectionn mais
ceci peut tre chang par l'appel de la mthode GetChanges du DataSet. Ensuite pour chaque ligne la
squence suivante va s'excuter :
1. Vrification des informations de mappage ;
2. Leve de l'vnement OnRowUpdating ;
3. Slection de l'objet Command appropri. Si celui-ci n'est pas dfini et s'il existe un objet
CommandBuilder, ce dernier est appel ;
4. Ecriture et envoie de la commande ;
5. Selon les spcifications de la commande, la ligne peut tre mise jour dans le Dataset et il peut y
avoir rcupration de paramtres de sortie / retour ;
6. Leve de l'vnement OnRowUpdated ;
7. Appel de la mthode AcceptChanges .
Cette opration n'est pas une opration par lot. C'est vous de dclarer une transaction si vous voulez
que la mise jour soit atomique.
A chaque ligne une exception peut se dclencher si :
Les informations de mappage ne permettent pas d'identifier la cible.
Il y a concurrence optimiste.
Si une erreur se produit vous pouvez suivre trois stratgies.
Annuler toute l'opration si vous tes en mode transactionnel.
Traiter l'erreur la vole en la grant dans l'vnement OnRowUpdated.
Ignorer les erreurs en mettant la proprit ContinueUpdateOnError vraie. Dans ce cas, il y aura
remonte des valeurs d'erreur vers la proprit RowError de la ligne.
Comme nous le voyons, une mise jour demande le paramtrage correct d'un grand nombre d'lments.
Il est donc indispensable de bien dfinir la stratgie que l'on veut suivre, et recommand d'utiliser un
DataAdapter par objet DataTable.
Evnements
U
RowUpdating
Se produit avant l'excution de la commande sur la source. Les paramtres de l'vnement sont :
Proprit Description
Command Obtient ou dfinit SqlCommand excuter durant Update.
Obtient les erreurs gnres par le fournisseur de donnes .NET Framework lors
Errors
de l'excution de Command.
Row Obtient le DataRow envoyer par l'intermdiaire de Update.
StatementType Obtient le type de l'instruction SQL excuter.
Status Obtient UpdateStatus de la proprit Command.
TableMapping Obtient le DataTableMapping envoyer par l'intermdiaire de Update.
Cet vnement sert modifier le traitement d'une ou plusieurs lignes avant leur traitement.
81/130
RowUpdated
Dclench aprs une tentative de modification, quel qu'en soit le rsultat. Les arguments de l'vnement
sont :
Proprit Description
Command Obtient ou dfinit SqlCommand qui est excut lorsque Update est appel.
Obtient les erreurs gnres par le fournisseur de donnes .NET Framework lors de
Errors
l'excution de Command.
Obtient le nombre de lignes modifies, insres ou supprimes par l'excution de
RecordsAffected
l'instruction SQL.
Row Obtient le DataRow envoy par l'intermdiaire de Update.
StatementType Obtient le type de l'instruction SQL excute.
TableMapping Obtient le DataTableMapping envoy par l'intermdiaire de Update.
Cet vnement sert gnralement au traitement des erreurs.
FillError
Se produit lors d'un problme de remplissage. C'est gnralement soit une conversion de type entranant
une perte d'information soit un non-respect de contrainte. Les arguments sont :
Proprit Description
Continue Obtient ou dfinit une valeur indiquant s'il convient de poursuivre l'opration de remplissage
malgr l'erreur.
DataTable Obtient le DataTable en cours de mise jour au moment o l'erreur s'est produite.
Errors Obtient les erreurs gres actuellement.
Values Obtient les valeurs de la ligne en cours de mise jour au moment o l'erreur s'est produite.
Attention : Les erreurs du SGBD ne lvent pas cette exception.
Commandes du DataAdapter
U
Nous allons voir ici comment dfinir et paramtrer les objets Command du DataAdapter. Dans cette
partie nous n'allons pas revoir la syntaxe qui est la mme que celle de l'objet Command, mais nous
discuterons de stratgies d'action. Les objets Command du DataAdapter se manipulent par l'intermdiaire de
la proprit du mme nom de l'objet DataAdapter.
SelectCommand
Elle doit tre toujours dfinie. Si la commande ne renvoie pas de ligne, aucune exception ne sera leve.
La composition de cette commande est trs importante. En effet, selon sa composition, la cration des cls
dans le Dataset peut tre diffrente. En cas de besoin, le DataAdapter cherche toujours crer une cl
primaire sur la table. Si vous utilisez le CommandBuilder, il utilisera les informations de cette commande
pour gnrer le code de mise jour.
U
82/130
La classe CommandBuilder
A la diffrence d'ADO, le DataAdapter ne gnre pas spontanment le code de mise jour. Il attend que
vous lui fournissiez les objets Command ncessaire la mise jour dans ses objets UpdateCommand,
DeleteCommand et InsertCommand. Toutefois vous pouvez vous rapprocher des fonctionnalits ADO en
dclarant plutt un objet CommandBuilder pour qu'il prenne en charge le code de mise jour. La gnration
du code se fait grce aux informations rcuprables par le code de l'objet SelectCommand. Si vous modifiez
celui-ci, vous devez appeler la mthode RefreshSchema du CommandBuilder. Faute de cela, les anciennes
commandes continueront d'tre utilise.
L'utilisation de cet objet est restreinte au cas o votre requte ne concerne qu'une table unique.
Proprits
(Oledb, sql)DataAdapter
Obtient ou renvoie le DataAdapter li au CommandBuilder.
QuotePrefix, QuoteSuffix (String)
Permet de dfinir les caractres d'encadrement utiliser lorsque les noms d'objets contiennent des
caractres interdits (espace par exemple). La dfinition de ces proprits permet au CommandBuilder de
gnrer un code relativement robuste.
Mthodes
DeriveParameters
Permet d'affecter les paramtres d'une commande vers les commandes du CommandBuilder.
GetDeleteCommand, GetInsertCommand, GetUpdateCommand
Renvoie l'objet commande spcifi utilis par le CommandBuilder.
RefreshSchema
Rgnre les commandes actions en relisant la commande SELECT.
83/130
Discussions et exemples de codes
Utilisation de l'IDE
Le prsent chapitre ne va parler que de l'utilisation des composants de donnes dans l'interface de
dveloppement. Ces composants se trouvent dans la boite outils sous l'onglet "Donnes".
A la diffrence de VS6, les composants non visuels ne s'ajoutent pas sur la feuille mais sur une barre qui
se situe sous la fentre. A partir de l, il me suffit de les slectionner pour pouvoir accder leur fentre de
proprits. Dans le cas des composants de donnes je peux les slectionner en partant de la boite outils ou
en utilisant l'explorateur de serveur comme dans les captures ci-dessous.
Les composants DataAdapter vous proposent l'utilisation d'un assistant lors de leur ajout.
Assistant du DataAdapter
Le premier cran vous demande juste la connexion qu'il faut utiliser dans un Combo classique. La liste
reprise est celle des sources visibles dans l'explorateur de serveur. Une fois celle-ci choisie, vous cliquez sur
suivant :
84/130
Dans cet cran, vous avez le choix entre l'utilisation de requte SQL ou le travail avec des procdures
stockes existantes ou crer. Dans mon cas le choix n'existe pas puisque ma source de donnes n'accepte
pas les procdures stockes. Un clic sur suivant vous emmne vers l'criture de la requte SELECT.
Vous pouvez utiliser le gnrateur

de requte si vous le souhaitez, pour ma part je prfre l'utilisation de mes gros doigts boudins. En cliquant
sur options avances vous obtiendrez la boite suivante :
85/130
Les choix proposs ici sont
suffisamment importants pour que nous les expliquions ici.
Gnrer des instructions Insert, Update et Delete
Ce sujet va beaucoup revenir dans cette partie. Tout le choix propos consiste laisser l'assistant gnrer
les commandes de mises jour en fonction de votre instruction SELECT, c'est dire dans une certaine
mesure se comporter comme un objet CommandBuilder, soit vous laissez les grer vous-mmes. La
gnration des commandes par l'assistant est d'assez bonne qualit, aussi dans les cas simples je vous
conseille de l'utiliser. Nous verrons plus loin quand il convient de reprendre la main.
Utiliser l'accs concurrentiel optimiste
Cette phrase est un non-sens. En fait il s'agit de dfinir si vous voulez que tout les champs d'origines
apparaissent dans la clause WHERE ou si vous ne voulez utiliser que les champs cls (scnario last-in win).
Actualiser le Dataset
Si la source supporte les lots de requtes, il y aura ajout d'une requte SELECT aprs les requtes
INSERT ou UPDATE pour vous aider grer la mise jour.
Enfin un dernier clic sur suivant vous emmnera vers un rapport signalant les russites et les checs
rencontrs par l'assistant.
Composant Dataset
Quand bien mme avez-vous cr votre DataAdapter, l'ajout d'un composant Dataset sur votre feuille ne
liera pas les deux. Lorsque vous ajoutez le composant Dataset il vous demande juste si vous souhaitez crer
un Dataset typ, ce qui sous-entend que la classe existe dj dans votre projet ou un Dataset Non-typ. Il
n'existe pas de solution pour lier le composant Dataset et le composant DataAdapter en dehors du code.
Notez que de toute faon, vous aurez besoin du code pour remplir le Dataset.
Une erreur commune consiste utiliser le DataAdapter et choisir 'Gnrer le groupe de donnes'. On
voit alors apparatre un composant Dataset dans la fentre mais celui-ci est un Dataset fortement typ.
Votre composant Dataset peut commencer tre manipul la cration. Vous pouvez lui ajouter des
tables et des relations en manipulant ses proprits. Vous pouvez aussi ajouter des composants DataView et
les configurer la cration.
Pour savoir si votre Dataset est typ ou non il vous suffit de regarder dans l'explorateur de solution. Si
vous voyez apparatre un fichier '.xsd' et que celui-ci contient un fichier '.cs', vous tes en prsence d'un
Dataset fortement typ.
86/130
Concepts gnraux : Crer un Dataset
Pour obtenir une bonne reprsentation des objets DataAdapter et Dataset il n'est pas possible de les
dissocier. Il est tout fait possible de crer un Dataset de toute pice, de lui ajouter des contraintes et des
relations, de ne le mettre jamais en contact avec une source de donnes existantes. Ici nous allons plutt
discuter de l'change d'informations entre un Dataset et une source de donnes ; donc de l'utilisation d'un
Dataset et d'un DataAdapter.
Dans ce chapitre, nous allons voir comment crer un Dataset reprsentant la base Access 'Biblio' ou
'Pubs' pour SQL-Server. Le schma de la source de donnes est le suivant :
J'utilise cet exemple, car la base est assez simple, il y a peu de relations et peu de contraintes. Dtaillons
maintenant les contraintes et validation des tables.
Publishers
PubId Cl primaire ; Int32 ; AutoIncrement; Index.
Titles
Title Indx, Null interdit
ISBN Cl primaire ; Texte (20) ; Index
PubId Cl trangre ; Int32
Authors
Au_Id Cl primaire ; Int32 ; AutoIncrement; Index.
Author Null interdit
Title Author
ISBN Cl trangre ; Texte (20)
Au_ID Cl trangre ; Int32
La cl primaire de la table est compose de ces deux champs
Il existe trois relations dans cette base (autant que de cl trangres).
U
87/130
Discussion autour du schma
Lorsqu'on aborde un programme avec ADO.NET, c'est une des premires questions mettre dans la
balance, rcuprer le schma ou non. Lorsqu'on utilise ADO, la question ne se pose pas puisque le recordset
rcupre le schma, mme quand on n'a pas besoin d'ailleurs, mais dans notre cas il s'agit de deux
cheminements possibles. La rcupration du schma est une opration coteuse en ressources et selon la
mthode employe, le retour sera sensiblement diffrent. Les lments de rponse se trouvent souvent dans
l'expos du problme.
Je ne connais rien de la source lorsque j'cris mon programme. La rcupration dynamique du schma
est obligatoire.
Je connais ma source de donnes
Je veux pouvoir la manipuler comme une entit compacte, j'utilise un Dataset fortement typ
Je veux un travail plus souple, modification des contraintes, modification de structure, etc je gre par
le code
Le premier cas et le second sont clairs mais le troisime est un peu plus complexe. En effet je peux
souhaiter allger le dveloppement et utiliser des rcuprations partielles du schma par le code. Elles seront
gnralement partielles car la rcupration du schma complet n'est pas une opration vidente.
Lorsque je procde une opration de remplissage par mon DataAdapter, seule les donnes sont
rcupres. Si je veux rcuprer la cl primaire, je dois affecter AddWithKey la proprit
MissingSchemaAction du DataAdapter avant d'appeler Fill. Si je veux rcuprer d'autres informations en
plus de la cl, je dois faire un appel FillSchema avant le Fill. Je rcupre ainsi les colonnes auto-
incrmentes et les contraintes verticales. Nanmoins je ne reois jamais les informations de cls trangres.
N.B : Il n'y a jamais import des index dans le schma. ADO.NET ne gre pas les index dans le sens
SGBD du terme puisqu'il n'y a jamais recherche d'une valeur par un objet ADO.NET directement sur la
source de donnes. Par contre les objets DataView gre des index sur les Dataset.
Je sais qu'il peut tre tentant de faire de la rcupration dynamique, mais j'avoue que pour ma part
j'essaye de faire le maximum la conception pour allger l'excution. Voyons maintenant trois exemples
montrant le fonctionnement de ces trois cas.
U
88/130
Rcuprer le schma
Dans cet exemple, nous allons rcuprer les informations de schma par le code, partant du principe que
nous ne connaissons que le nom de la source. L'objet OleDbConnection fournit une mthode
GetOleDbSchemaTable qui permet de rcuprer des informations de schma. Elle est de la forme suivante :
public DataTable GetOleDbSchemaTable(Guid schema, object[] restrictions)

private void Button1_Click(object sender As, System.EventArgs e) {
OleDbConnection MaConn = new OleDbConnection(strConn);
MaConn.Open();
DataTable MaTable =
MaConn.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, new object[] {null,
null, null, "TABLE"});
string NomTable;
foreach(DataRow MaLigne in MaTable.Rows) {
NomTable = MaLigne.Item("TABLE_NAME");
OleDbDataAdapter TabDtaAdapt = new OleDbDataAdapter("SELECT *
FROM [" & NomTable & "]", MaConn);
TabDtaAdapt.Fill(MonDataset, NomTable);
TabDtaAdapt.FillSchema(MonDataset, SchemaType.Mapped,
NomTable);
TabDtaAdapt.Dispose();
}
MonDataset.WriteXmlSchema(@"c:\\tutoriel\\dotnet\\type.xsd");
}
J'ai avec ce code simple rcupr l'ensemble de mes tables avec leurs cls primaires et leurs contraintes
de colonnes. En utilisant la mthode WriteXmlSchema je peux donner une certaine persistance mon
modle. Il nous faut cependant encore ajouter les relations. Pour cela nous allons r interroger le schma de
la base.
89/130
MaTable.Clear() ;
//interrogation de la table des relations
MaTable = MaConn.GetOleDbSchemaTable(OleDbSchemaGuid.Foreign_Keys, new
object[] {null, null, null, null, null, null});
DataTable TableParent, TableEnfant; DataColumn ColParent, ColEnfant; Dim
ForeignKeyConstraint EtrKey; DataRelation MaRelat;
foreach(MaLigne in MaTable.Rows) {
TableParent = MonDataset.Tables(MaLigne.Item("Pk_Table_Name"));
TableEnfant = MonDataset.Tables(MaLigne.Item("Fk_Table_Name"));
ColParent = TableParent.Columns(MaLigne.Item("Pk_Column_Name"));
ColEnfant = TableEnfant.Columns(MaLigne.Item("Fk_Column_Name"));
EtrKey = new ForeignKeyConstraint(ColParent, ColEnfant);
if (MaLigne.Item("DELETE_RULE").IndexOf("NO ACTION") > 0)
EtrKey.DeleteRule = Rule.None;
else
EtrKey.DeleteRule = Rule.Cascade;
if (MaLigne.Item("UPDATE_RULE").IndexOf("NO ACTION") > 0)
EtrKey.UpdateRule = Rule.None;
else
EtrKey.UpdateRule = Rule.Cascade;
if (EtrKey.UpdateRule == Rule.Cascade && EtrKey.DeleteRule ==
Rule.Cascade)
EtrKey.AcceptRejectRule = AcceptRejectRule.Cascade;
EtrKey.ConstraintName = TableEnfant.TableName & "_fk_" &
TableParent.TableName;
TableEnfant.Constraints.Add(EtrKey) ;
MaRelat = new DataRelation(TableEnfant.TableName & "_rel_" &
TableParent.TableName, ColParent, ColEnfant, true) ;
MonDataset.Relations.Add(MaRelat) ;
}
MonDataset.WriteXmlSchema(@"c:\\tutoriel\\dotnet\\type.xsd") ;
Il serait un peu diffrent pour le fournisseur manag SQL. En effet celui-ci ne met pas votre
disposition une mthode de rcupration de schma identique GetOleDbSchemaTable. Pour rcuprer le
schma vous devez utiliser des vues de schma avec un objet Command ou avec des requtes de schma. Par
exemple pour rcuprer la liste des tables :
SqlClient.SqlDataAdapter schemaDA = new SqlClient.SqlDataAdapter("SELECT
* FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY
TABLE_TYPE", nwindConn);
DataTable schemaTable = new DataTable();
schemaDA.Fill(schemaTable) ;
Je peux donc assez aisment reconstruire ma base de donnes dans un dataset sans connatre la structure
l'origine. Ce type de cas est toutefois trs rare. Heureusement car le cot en ressources est lourd. Pourtant
j'ai gr au mieux le code pour privilgier sa rapidit et pour cela j'ai fait une impasse importante.
Tel que nous le voyons, notre Dataset nouvellement cr n'a pas possibilits de transmission de ces
modifications vers la source sauf gnrer un code extrmement lourd.
90/130
Pour gnrer correctement ces modifications, un dataset utilise gnralement un DataAdapter par table.
Dans mon cas je n'ai qu'un seul DataAdapter. Il serait techniquement possible de grer l'ensemble des
modifications avec un seul DataAdapter.
OleDbDataAdapter MonDtaAdRetour = new OleDbDataAdapter();
OleDbCommand[] TabSelectCommand = new OleDbCommand
[MonDataset.Tables.Count];
OleDbConnection MaConn = new
OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data
Source=C:\\tutoriel\\biblio.mdb;");
OleDbCommandBuilder CmdBuild = new OleDbCommandBuilder(MonDtaAdRetour);
CmdBuild.QuotePrefix = "[";
CmdBuild.QuoteSuffix = "]";
for(int cmpt = 0 ; cmpt <= TabSelectCommand.GetUpperBound(0) ; cmpt++){
TabSelectCommand(cmpt) = new OleDbCommand("SELECT * FROM [" &
MonDataset.Tables(cmpt).TableName & "]", MaConn);
}
if(MonDataset.HasChanges) {
foreach(DataTable MaTable in MonDataset.Tables) {
If(MaTable.GetChanges.Rows.Count > 0) {
MonDtaAdRetour.SelectCommand =
TabSelectCommand(MonDataset.Tables.IndexOf(MaTable));
CmdBuild.RefreshSchema();
MonDtaAdRetour.Update(MaTable) ;
}
}
}
Vu comme cela ce n'a pas l'air trop compliqu. Pourtant ce code ne fonctionnera pas bien. Dans le cas de
table en relation, l'ordre des modifications n'est pas sans importance. Supposons que j'ajoute et que je
supprime des diteurs et des titres. Je dois forcment insrer les diteurs avant les titres et supprimer les titres
avant les diteurs. Mon code est bien loin de faire cela et une telle modification l'alourdirait
considrablement. Je pourrais prendre d'autres mthodes, comme une collection de DataAdapter, mais toutes
serait difficiles grer correctement.
Nanmoins, il est possible de grer cela au prix d'un ralentissement du code. Nous allons maintenant
regarder le cas plus frquent ou je connais la source.
Dataset fortement typ

U
Comme je vous l'ai dj dit, il s'agit d'un fichier de schma XSD et d'un module de classe. Nous allons
crer celui-ci presque uniquement avec l'environnement intgr.
Mon but tant sensiblement le mme que prcdemment, je vais recrer ma source comme un Dataset
fortement typ. Pour mmoire, ceci consiste recrer un schma xsd de ma source et gnrer un module de
classe lie celui-ci. Un Dataset fortement typ permet un codage plus simple et un accs de trs bonnes
performances, mais il est li une source prdfinie.
Pour ma part, je vous recommande chaudement l'utilisation des Dataset fortement typs chaque fois que
vous travaillez sur une source unique et connue.
Je vais donc ajouter ma feuille un composant connexion (OleDbCnnPubs) et quatre composants
OleDbDataAdapter, un par table.
OleDbDAAuthors pour la table Authors
OleDbDAPublishers pour la table Publisher
OleDbDATitles pour la table Titles
OleDbDATitAut pour la table Title Author
J'ai rang mes requtes SQL dans un ordre particulier qui correspondait mes souhaits ultrieurs, mes
nous verrons que ce n'est utile que pour les DataView.
91/130
Pour crer mon Dataset fortement typ, je vais faire un clic droit sur un de mes DataAdapter et choisir
'Gnrer le groupe de donnes'. Je vais slectionner toutes les tables et ajouter le composant ainsi cr dans
le concepteur. J'ai nomm mon Dataset 'dtsPubs' mais le composant ajout s'appelle 'dtsPubs1'. Cela vient du
fait qu'il existe maintenant un fichier 'dtsPubs.xsd' dans l'explorateur de solution. Si je choisis d'afficher tous
les fichiers dans celui-ci, je vois apparatre un fichier 'dtsPubs.cs' qui est mon fichier de classe. Celui-ci tant
extrmement long je ne vais pas vous le recopier ici.
Si je clique droit sur mon composant Dataset je peux choisir d'aller dans les proprits du groupe de
donnes. J'aurais alors l'cran suivant :
De cette boite, je peux

facilement visualiser mon schma, mais pas le modifier. Mais dans ce groupe de donnes, pas de relations.
92/130
Ajouter les relations
Un autre clic droit sur mon Dataset et je choisis 'Afficher le schma'. Je vois alors apparatre l'cran
suivant.
Vous voyez que l'onglet du bas me permet de basculer la vision entre Dataset et XML. Le Dataset et le
fichier XSD sont synchroniss. Dans cette vue je peux modifier mon schma, mon fichier XSD se modifiera
automatiquement, et rciproquement. Faites trs attention dans cette vue, vous pouvez modifier le schma
sans problme. Malheureusement les problmes risquent de se passer l'excution si vous n'tes pas
particulirement vigilant.
Dans mon schma, je vais slectionner une des tables mettre en relation puis slectionner dans le menu
'Schema' 'Ajouter une relation'.
93/130
Il apparat une boite de dialogue permettant de dfinir ma relation comme je le souhaite.
Je rpte mon opration pour crer toutes mes relations et mon schma devient alors comme cela :
Les relations sont maintenant crites dans le fichier XSD.
94/130
Vous allez peut tre vous dire que c'tait un peu lourd mais vous possdez maintenant un Dataset trs
facile utiliser. Toutefois, si vous l'utilisez comme a il ne contient aucune donne. Un peu de code va
devoir tre ncessaire pour remplir le Dataset.

this.DtsPubs1.EnforceConstraints = false;
this.OleDbDAAuthors.Fill(this.DtsPubs1.Authors);
this.OleDbDAPublishers.Fill(this.DtsPubs1.Publishers);
this.OleDbDATitAut.Fill(this.DtsPubs1.Title_Author);
this.OleDbDATitles.Fill(this.DtsPubs1.Titles);
this.DtsPubs1.EnforceConstraints = true ;
//dmo de codage fortement typ
dtsPubs.PublishersRow NouvLigne = this.DtsPubs1.Publishers.Rows(1);
if(NouvLigne.IsAddressNull) NouvLigne.Address = "chez moi";
}
Je n'ai pas de dmonstration fantastique de la diffrence de codage, mais essayez-le une fois et vous
verrez une nette diffrence.
Stratgies de mise jour

Nous allons traiter ici de la partie la plus complexe de l'utilisation d'ADO.NET. Je ne vais traiter ici que
de l'utilisation d'un DataAdapter.
Il existe globalement trois choix pour grer les oprations de mise jour
Le CommandBuilder
La gnration par l'assistant
La gnration par le dveloppeur
Contrairement ce que vous pouvez penser, il y a de nombreux cas ou l'utilisation d'un
CommandBuilder ou de l'assistant suffit largement une bonne gestion de la mise jour.
Rappels SQL
U
Pour modifier les donnes de la source, on utilise des requtes actions. Une requte action ne doit porter
que sur une seule table. Toutes les requtes actions doivent respecter l'ensemble des contraintes et
restrictions pour tre valides. On en distingue trois.
Ajout avec INSERTINTO
INSERT [INTO] nom_de_la_table [(liste_des_colonnes)]
T T
{VALUES (liste_des_valeurs)}
T T
Cette requte ne prsente pas de problme d'identification de ligne puisqu'il s'agit d'une nouvelle ligne, il
convient de temprer ce jugement lorsqu'on travaille avec des cls gnres. Les valeurs omises lors de la
requte prennent la valeur par dfaut si celle-ci existe, la valeur NULL sinon. Il est possible de ne pas
spcifier la liste des colonnes, mais ceci sous-tend que la liste des valeurs correspond toutes les colonnes.
Trs honntement je vous dconseille vivement d'omettre la liste des colonnes car cela demande de savoir
dans quel ordre mettre les valeurs pour qu'il corresponde l'ordre des colonnes vises.
Lorsque la table cible possde des colonnes auto-incrmentes, on ne passe pas de valeurs dans la les
colonnes et on ne met pas non plus le nom de ces colonnes dans la liste des colonnes.
Suppression avec DELETE
DELETE [FROM] nom_de_la_table
T T
[WHERE condition]
T
Dans le contexte de concurrence que nous allons voir ci-aprs, c'est de loin la requte la plus
dangereuse. La condition WHERE doit videmment permettre d'identifier la ou les lignes cibles. Cette
requte ne prsente pas de difficult majeure.
95/130
Modification avec UPDATE
UPDATE nom_de_la_table e
SET colonne = valeur [, colonne2 = valeur2 ...]
[WHERE condition]
C'est autour de cette requte que vont se concentrer la plupart des difficults. Dans le concept, on passe
dans la clause SET la liste des nouvelles valeurs pour les colonnes cibles, et on identifie la ou les lignes par
la clause WHERE. Les colonnes non cibles sont laisses dans leur tat d'origine.
La premire chose que nous allons regarder est la construction du critre WHERE.
Choisir les restrictions du critre

U
Retournons dans notre vision ADO.NET. Les requtes utilises par le DataAdapter doivent pouvoir
toujours identifier la ligne cible de faon unique, ceci ne concernant videmment pas les requtes d'ajout.
Cette unicit d'identification est induite par le DataAdapter puisque celui-ci examine les lignes
successivement et envoie les requtes de misa jour successivement. Pour identifier une ligne de faon
unique, on utilise la cl primaire de la table. Une table sans cl primaire et ou aucun critre d'unicit ne peut
tre dfini est inexploitable.
Cette condition quoique ncessaire, n'est pas suffisante. Comme je vous l'ai dj dit, ADO.NET travaille
toujours dans un contexte de concurrence optimiste. Ceci veut dire qu'il vous appartiendra de vrifier que la
ligne que vous ciblez n'a pas dj t modifie par un autre utilisateur. Il existe ds lors plusieurs scnarii
possibles.
La cl uniquement
Connu sous le nom de 'last-in Win' (le dernier est vainqueur). Comme votre ligne n'est identifie que par
sa valeur de cl, vos modifications craseront toutes les modifications des autres utilisateurs sans que vous
soyez averti de la modification de la ligne. Je n'ai jamais vu d'utilisation fonde de ce genre de technique
dans un contexte multi-utilisateurs.
La cl et la version
De nombreux SGBD gre la notion de numro de version. On la trouve parfois sous le nom de
TimeStamp du fait que certains SGBD donnent une valeur de type Date/heure pour grer la version. Il faut
videmment que votre table soit conue avec cette information. Dans le fonctionnement, chaque
modification de la ligne dans la source entrane l'attribution d'une nouvelle valeur de version, forcment
unique, la ligne.
Lorsque vous rapatriez une ligne vers votre Dataset, elle contient son numro de version. Si vous
renvoyez cette ligne pour mise jour, son numro de version est compar avec celui existant dans la source
et la modification n'est effective que si ceux-ci sont identiques.
Ce principe de fonctionnement est trs fiable, mais tous les SGBD ne le grent pas et il faut que le
schma soit conu avec. Si c'est vous qui concevez la source, utilisez le ds que possible.
Notez que le CommandBuilder ne gre pas les numros de version dans sa logique.
La cl et les colonnes modifies
C'est la logique du moteur de curseur ADO. Celle-ci est une restriction partielle de l'identification. La
clause WHERE contient la cl et les valeurs d'origines de toutes les colonnes modifies. Ceci implique que
pour identifier la ligne, il faut qu'aucune des colonnes que vous voulez modifier ne l'ai t par un autre
utilisateur. Par contre, si un autre champ a t modifi cela ne pose pas de problme. Cette technique est trs
performante en termes de modifications successives, mais elle n'est pas gre par ADO.NET. Dans sa
stratgie de mise jour, ADO.NET se base sur des objets Command dfini une fois. Or cette technique sous-
tend que la requte soit cre la vole. Il est videmment possible de la reproduire par le code, mais il
convient alors de peser le cot d'excution par rapport aux avantages esprs.
96/130
La cl et tous les champs
C'est le cas que vous trouverez dfini dans la documentation comme 'concurrence optimiste' (sic)
Cela revient mettre les valeurs d'origine de tous les champs dans la clause WHERE. Si au moins une
valeur a t modifie par un autre utilisateur, la modification ne pourra avoir lieu. Cela revient globalement
la mme chose que d'utiliser un numro de version, mais en plus lourd. Toutefois tous les SGBD supportent
ce type de requte. Gardez l'esprit que l'assistant comme le CommandBuilder ne vous proposent que cette
option ou le scnario 'last-in Win'.
Etude des cas particuliers

U
Delete or not delete : That is

Je suis toujours surpris lorsque je vois autre chose que la cl dans la clause WHERE d'une requte de
suppression. En fait, soit vous donnez votre application le droit de supprimer des enregistrements, soit non.
En admettant que vous autorisiez la suppression, je ne vois pas en quoi la modification de la ligne par un
autre utilisateur la rende subitement moins supprimable. Il s'agit mes yeux d'une aberration logique. Car en
supposant que le timing soit lgrement diffrent, j'aurais alors supprim une ligne qui n'aurait pas du l'tre,
sans qu'il existe d'indication permettant de discerner une ligne qui peut tre supprime d'une qui ne peut pas
l'tre. C'est pourquoi dans mes requtes DELETE vous ne verrez que le champ cl dans le WHERE.
Champ Long String (Memo) ou Long Binary (BLOB)
Je ne vous ai pas parl de la manipulation de ce type de champ car elle ne prsente pas de difficults
majeures.
Contrairement ADO, il n'y a pas besoin d'utiliser les mthodes GetChunck ou AppendChunck. Vous
pouvez manipuler ces champs directement.
DataRow MaLigne; string strMemo; byte[] TabBLOB;
strMemo = (string)(MaLigne("ChampMemo"));
TabBLOB = (byte[])(MaLigne("ChampBLOB")) ;
//n'essayez pas TabBLOB = (byte)(MaLigne("ChampBLOB"))
L'aide en ligne explique parfaitement la rcupration et la transmission vers les champs longs.
Notre problme ici consiste la manipulation de ces champs vers ou depuis la source de donnes. Ces
champs longs peuvent tre d'une taille colossale. Essayez le rapatriement de 100000 enregistrements
contenant chacun un champ BLOB de 300 Mo et vous allez voir arriver votre administrateur avec un merlin.
C'est pour contourner le problme que l'on pratique la rcupration diffre. Il existe deux possibilits :
o On casse la table en deux dans le Dataset, une table contient la cl et tous les champs court,
l'autre la cl et tous les champs longs. Une relation un--un unit ces deux tables.
o On ne rapatrie que les champs courts. Puis on change la structure de la table dans le Dataset
pour ajouter les champs longs. On travaille alors avec deux DataAdapter pour une mme table,
l'un grant les champs courts et l'autre les longs.
Quelle que soit la mthode choisie, nous avons pour l'instant juste labor la base de notre stratgie. La
difficult rside dans la ncessit de rcuprer le champ BLOB uniquement lorsque l'utilisateur en a vraiment
besoin. Il faut alors faire preuve d'imagination dans votre interface. Un exemple standard est l'affichage d'un
enregistrement dans la feuille avec un bouton 'Afficher le plan' qui lui provoque la rcupration de l'image
dans cet exemple.
Il suffit alors de rapatrier le champ de l'enregistrement en cours, et tout le monde est content.
L'avantage de cette mthode rside aussi dans le fait que la plupart des champs longs sont rarement
modifis. Par un emploi judicieux de GetChanges, on pourra diminuer ainsi fortement le volume transmis.
Maintenant il est tout fait possible de laisser la table telle qu'elle est, et de rapatrier les champs longs.
Toutefois il convient de s'assurer que les champs longs ne sont pas inclus dans le critre des commandes
de mises jour sous peine d'une perte de performance totalement inutile.
U
97/130
Ecriture des commandes avec des requtes paramtres
Je vais ici donner des exemples de requtes de DataAdapter. Accrochez-vous car partir d'ici, il vaut
mieux avoir intgr correctement ce que nous avons dj vu.
Pour commencer, nous allons travailler sur la table Titles dont le schma est le suivant :
Titles
Nom champ Type de donnes Longueur Prcision Commentaires
Title AdWChar 255 0 Not NULL
Year Published AdSmallInt 0 5
ISBN adWChar 20 0 Cl primaire
PubId AdInteger 0 10 Cl trangre
Description AdWChar 20 0
Notes AdWChar 50 0
Subject AdWChar 50 0
Comments AdLongVarWChar 0 0 Mmo
La premire chose est de crer notre Dataset.
private DataSet dtsBiblio = new DataSet();

OleDbCommand MaCommand = new OleDbCommand("SELECT ISBN, Title, [Year
Published], Subject, Description, Notes, PubID FROM Titles", MaConn);
dtAdTitre.SelectCommand = MaCommand;
dtAdTitre.MissingSchemaAction = MissingSchemaAction.AddWithKey;
dtAdTitre.Fill(dtsBiblio, "Titres");
tblTitres = dtsBiblio.Tables("Titres");
OleDbDataAdapter dtAdComment = new OleDbDataAdapter("SELECT ISBN FROM
Titles", MaConn);
dtAdComment.MissingSchemaAction = MissingSchemaAction.AddWithKey;
tblTitres.Columns("Title").AllowDBNull = false;
dtAdComment.Fill(dtsBiblio, "Comments") ;
dtsBiblio.Tables("Comments").Columns.Add("Comments",
System.Type.GetType("System.String")) ;
dtsBiblio.Relations.Add(new DataRelation("unAun",
dtsBiblio.Tables("Titres").Columns("ISBN"),
dtsBiblio.Tables("Comments").Columns("ISBN"), true));
dtsBiblio.Relations("unAun").ChildKeyConstraint.AcceptRejectRule =
AcceptRejectRule.Cascade;
dtsBiblio.Relations("unAun").ChildKeyConstraint.UpdateRule =
Rule.None;
dtsBiblio.Relations("unAun").ChildKeyConstraint.DeleteRule =
Rule.Cascade;
Jusque l rien de bien complexe. Je cre une table 'Titres' qui regroupe tous les champs courts.
Je cre une seconde table contenant juste le champ cl primaire, et j'ajoute un champ 'Comment' de type
Mmo ne contenant rien.
Enfin je mets mes deux tables en relation.
Maintenant je vais devoir crer ma logique de mise jour.
98/130
Suppression
Commenons par la plus simple pour nous chauffer.
Comme je vous l'ai dj dit, pour ma part je n'intgre que les champs cl dans la clause WHERE. Ma
requte sera alors :
DELETE Titles WHERE ISBN=?
J'utilise pour l'instant des espaces rservs. Si je travaillais avec SQL-Server, je serais oblig d'utiliser
des paramtres nomms. Ce n'en serait d'ailleurs que plus simple.
Je cre la fonction suivante
private OleDbCommand CreateDeleteCommand(ByVal LaConnexion As
OleDbConnection) {
string strSQL = "DELETE Titles WHERE ISBN=?";
OleDbCommand cmdDel = new OleDbCommand(strSQL, LaConnexion);
OleDbParameter MonParam = new OleDbParameter();
MonParam.ParameterName = "OrISBN";
MonParam.OleDbType = OleDbType.VarWChar;
MonParam.Size = 20;
MonParam.Direction = ParameterDirection.Input;
MonParam.IsNullable = false;
MonParam.SourceColumn = "ISBN";
MonParam.SourceVersion = DataRowVersion.Original;
cmdDel.Parameters.Add(MonParam);
return cmdDel;
}
Je dtaille ici bien les proprits de mon paramtre. Profitez-en car lorsqu'il y a beaucoup de paramtres
dfinir comme nous allons le voir plus loin, je tends utiliser la notation suivante :
cmdDel.Parameters.Add(new OleDbParameter("OrISBN", OleDbType.VarWChar,
20, ParameterDirection.Input, false, (byte)0, (byte)0, "ISBN",
DataRowVersion.Original, null));
Dans le cas des espaces rservs, je dfinis le nom du paramtre par pure bont d'me. Je dfinis par
contre correctement le type et la taille, puisqu'il s'agit d'une chane, la taille est obligatoire. Je dfinis surtout
le nom de la colonne source et la version. C'est l que se joue tout le travail du DataAdapter. Lors de l'appel
de la mthode Update, chaque fois qu'il trouvera une ligne dont l'tat est 'Deleted', il rcuprera la valeur
originale de la colonne ISBN pour valoriser le paramtre, puis il excutera la requte dfinie par strSQL.
Bref, du tout automatique.
Notez que dans une requte de suppression, on passe toujours la version originale car il n'existe pas de
valeurs courantes
99/130
Insertion
Dans mon exemple, celle-ci va tre peine plus complexe, mais croyez bien qu'avant la fin de ce cours,
vous la verrez d'un tout autre il.
Ma requte va tre de la forme :
INSERT INTO Titles(ISBN, Title, [Year Published], Subject, Description, Notes, PubID) VALUES (?, ?, ?, ?,
?, ?, ?)
Je vous fais un code avec les deux notations :
private OleDbCommand CreateInsertCommand(OleDbConnection LaConnexion) {
string strSQL = "INSERT INTO Titles(ISBN, Title, [Year
Published], Subject, Description, Notes, PubID) VALUES (?, ?, ?, ?, ?, ?,
?)";
OleDbCommand cmdIns = new OleDbCommand(strSQL, LaConnexion);
OleDbParameter ParISBN = new OleDbParameter();
ParISBN.ParameterName = "CurISBN";
ParISBN.OleDbType = OleDbType.VarWChar;
ParISBN.Size = 20;
ParISBN.Direction = ParameterDirection.Input;
ParISBN.IsNullable = false;
ParISBN.SourceColumn = "ISBN";
ParISBN.SourceVersion = DataRowVersion.Current;
cmdIns.Parameters.Add(ParISBN);
OleDbParameter parTitles = new OleDbParameter();
parTitles.ParameterName = "CurTitle";
parTitles.OleDbType = OleDbType.VarWChar;
parTitles.Size = 255;
parTitles.Direction = ParameterDirection.Input;
parTitles.IsNullable = false;
parTitles.SourceColumn = "Titles";
parTitles.SourceVersion = DataRowVersion.Current;
cmdIns.Parameters.Add(parTitles)
OleDbParameter parYear = new OleDbParameter();
parYear.ParameterName = "CurYear";
parYear.OleDbType = OleDbType.UnsignedSmallInt;
parYear.Precision = 5;
parYear.Direction = ParameterDirection.Input;
parYear.IsNullable = true;
parYear.SourceColumn = "year published";
parYear.SourceVersion = DataRowVersion.Current;
cmdIns.Parameters.Add(parYear);
cmdIns.Parameters.Add(new OleDbParameter("curSubject",
OleDbType.VarWChar, 50, ParameterDirection.Input, true, (byte)0, (byte)0,
"Subject", DataRowVersion.Current, null));
cmdIns.Parameters.Add(new OleDbParameter("curDescription",
"Description", DataRowVersion.Current, null));
cmdIns.Parameters.Add(new OleDbParameter("curNotes",
"Notes", DataRowVersion.Current, null));
cmdIns.Parameters.Add(new OleDbParameter("PubId",
OleDbType.Integer, 0, ParameterDirection.Input, false, 10, (byte)0,
"PubId", DataRowVersion.Current, null));
return cmdIns;
}
Dans ce cas, j'utilise les valeurs courantes car les lignes ajoutes n'ont par de valeur originale.
100/130
Bien sur ce code est un peu fastidieux crire, mais vous pouvez utiliser le code gnr par l'assistant et
le modifier. J'ai dtaill le dbut du code pour indiquer deux trois prcisions.
Lorsqu'un champ utilise un caractre rserv comme l'espace, vous ne devez pas le mettre entre
crochet dans la proprit SourceColumn.
Vous n'tes pas oblig de dfinir la prcision pour les types numriques qui ne sont pas du type
OleDbType.Decimal.
Attention de bien mettre la proprit IsNullable du paramtre PubId false, puisqu'il s'agit d'une
cl trangre pour une autre table.
Vous n'tes pas tenu de dclarer la version, puisque la version courante est la valeur par dfaut
Modification
C'est hlas la plus fastidieuse crire (j'en vois qui regrettent dj le moteur de curseur).
Il n'y a qu'un pige avec elle, et comme il est vident, il suffit juste d'y penser.
La requte va tre de la forme
UPDATE Titles SET ISBN = ?, Title = ?, [Year Published] = ?, Subject = ?, Description = ?, Notes = ?,
PubID = ? WHERE ISBN = ? AND Description = ? AND Notes = ? AND PubID = ? AND Subject = ? AND
Title = ? AND [Year Published] = ?
Oui je sais, cela fait mal aux yeux. Mais dites-vous bien, que le pire est que cette requte est fausse. En
effet, certaines valeurs des champs d'origine peuvent tre NULL. Or si vous crivez une galit de la forme
Champ=NULL cela sera toujours faux. Ce qui revient dire que toute ligne ayant une valeur d'origine NULL
ne pourrait tre identifier par cette requte. Le code correcte est donc :
UPDATE Titles SET ISBN = ?, Title = ?, [Year Published] = ?, Subject = ?, Description = ?, Notes = ?,
PubID = ? WHERE (ISBN = ?) AND (Description = ? OR ? IS NULL AND Description IS NULL) AND
(Notes = ? OR ? IS NULL AND Notes IS NULL) AND (PubID = ?) AND (Subject = ? OR ? IS NULL AND
Subject IS NULL) AND (Title = ?) AND ([Year Published] = ? OR ? IS NULL AND [Year Published] IS
NULL)
A chaque fois qu'un champ peut tre NULL le critre doit tre crit sous la forme :
(Champ = ? OR ? IS NULL AND Champ IS NULL)
Que l'on peut lire sous la forme, le champ est gal au paramtre ou le champ et le paramtre sont NULL.
Il faut bien sur passer tous les paramtres. Dans cette requte qui concerne neuf champs il y a dix-neuf
paramtres transmettre. Cela peut sembler abominable, mais vous allez bientt voir que le jeu en vaut la
chandelle.
J'aurais alors ma fonction.
private OleDbCommand CreateUpdateCommand(OleDbConnection LaConnexion) {
string strSQL = "UPDATE Titles SET ISBN = ?, Title = ?, [Year
Published] = ?, Subject = ?, Description = ?, Notes = ?, PubID = ? WHERE
(ISBN = ?) AND (Description = ? OR ? IS NULL AND Description IS NULL) AND
(Notes = ? OR ? IS NULL AND Notes IS NULL) AND (PubID = ?) AND (Subject =
? OR ? IS NULL AND Subject IS NULL) AND (Title = ?) AND ([Year
Published] = ? OR ? IS NULL AND [Year Published] IS NULL)";
OleDbCommand cmdUpd = new OleDbCommand(strSQL, LaConnexion);
cmdUpd.Parameters.Add(New OleDbParameter("ISBN",
OleDbType.VarWChar, 20, "ISBN"));
cmdUpd.Parameters.Add(new OleDbParameter("Title",
OleDbType.VarWChar, 255, "Title"));
cmdUpd.Parameters.Add(new OleDbParameter("Year_Published",
OleDbType.SmallInt, 0, "Year Published"));
cmdUpd.Parameters.Add(new OleDbParameter("Subject",
OleDbType.VarWChar, 50, "Subject"));
cmdUpd.Parameters.Add(new OleDbParameter("Description",
OleDbType.VarWChar, 50, "Description"));
cmdUpd.Parameters.Add(new OleDbParameter("Notes",
OleDbType.VarWChar, 50, "Notes"));
101/130
cmdUpd.Parameters.Add(new OleDbParameter("PubID", OleDbType.Integer, 0,
"PubID"));
cmdUpd.Parameters.Add(new OleDbParameter("Original_ISBN",
(byte)0, "ISBN", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new OleDbParameter("Original_Description",
(byte)0, "Description", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new OleDbParameter("Original_Description1",
(byte)0, "Description", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new OleDbParameter("Original_Notes",
(byte)0, "Notes", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new OleDbParameter("Original_Notes1",
(byte)0, "Notes", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new OleDbParameter("Original_PubID",
OleDbType.Integer, 0, ParameterDirection.Input, false, (byte)0, (byte)0,
"PubID", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new OleDbParameter("Original_Subject",
(byte)0, "Subject", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new OleDbParameter("Original_Subject1",
(byte)0, "Subject", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new OleDbParameter("Original_Title",
(byte)0, "Title", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new
OleDbParameter("Original_Year_Published", OleDbType.SmallInt, 0,
ParameterDirection.Input, false, (byte)0, (byte)0, "Year Published",
cmdUpd.Parameters.Add(new
OleDbParameter("Original_Year_Published1", OleDbType.SmallInt, 0,
ParameterDirection.Input, false, (byte)0, (byte)0, "Year Published",
return cmdUpd;
}
Bien sur, je n'ai pas crit ce code. Je l'ai gnr l'aide de l'assistant et lgrement adapt, cela ne m'a
pas pris plus de deux minutes. Maintenant je n'ai plus qu' ajouter aprs mon code de cration
dtAdTitre.DeleteCommand = CreateDeleteCommand(MaConn);
dtAdTitre.InsertCommand = CreateInsertCommand(MaConn);
dtAdTitre.UpdateCommand = CreateUpdateCommand(MaConn);
Et mon DataAdapter possde sa logique de mise jour. Ce n'est pas bien compliqu, mais ce n'est que le
dbut.
U
102/130
Ecriture des commandes avec des procdures stockes
Nous allons reprendre le mme exemple ici en utilisant SQL-Server et des procdures stockes. La table
'Titles' de la base de donnes 'Pubs' pour SQL-Server est diffrente de celle de la base 'biblio' d'Access mais
cela n'a que peut d'importance. De manire gnrale et sur de nombreux aspects, il est beaucoup plus simple
de travailler avec des procdures stockes. Cela diminue grandement le travail de gestion effectuer avec le
code. Donc c'est reparti pour un tour.
private DataSet dtsBiblio = new DataSet();
SqlConnection MaConn = new SqlConnection(@"packet size=4096;user
id=sa;data source=NOM-SZ71L7KTH17\\TUTO;persist security
info=False;initial catalog=pubs;password=monpasse");
SqlCommand MaCommand = new SqlCommand();
MaCommand.CommandText = "psSelectTitre";
MaCommand.CommandType = CommandType.StoredProcedure;
MaCommand.Connection = MaConn;
dtAdTitre.SelectCommand = MaCommand;
dtAdTitre.MissingSchemaAction = MissingSchemaAction.AddWithKey;
dtAdTitre.Fill(dtsBiblio, "Titres") ;
tblTitres = dtsBiblio.Tables("Titres") ;
O la procdure stocke psSelectTitre est dfinie telle que:
CREATE PROCEDURE dbo.psSelectTitre
AS
SET NOCOUNT ON;
SELECT title_id, title, type, pub_id, price, royalty, ytd_sales, notes, pubdate FROM titles
GO
Suppression
La procdure appele est dcrite comme :
CREATE PROCEDURE dbo.psDeleteTitre
( @Original_title_id nvarchar(50) )
AS
SET NOCOUNT OFF;
DELETE FROM titles WHERE title_id = @Original_title_id
GO
Avec la fonction de cration
private SqlCommand CreateDeleteCommand(SqlConnection LaConnexion) {
SqlCommand cmdDel = new SqlCommand("psDeleteTitre", LaConnexion);
cmdDel.CommandType = CommandType.StoredProcedure;
SqlParameter MonParam = new SqlParameter();
MonParam.ParameterName = "Original_title_id";
MonParam.SqlDbType = SqlDbType.NVarChar;
MonParam.Size = 50;
MonParam.Direction = ParameterDirection.Input;
MonParam.IsNullable = false;
MonParam.SourceColumn = "title_id";
MonParam.SourceVersion = DataRowVersion.Original;
cmdDel.Parameters.Add(MonParam);
return cmdDel}
Jusque l la similitude est frappante. Mais les diffrences vont rapidement arriver. N'oubliez pas tout de
mme de bien prciser le type de la commande.
103/130
Insertion
Je vais dj anticiper la suite, donc cette procdure est dj plus complexe que le strict ncessaire. Nous
y reviendrons plus loin, mais notez dj la prsence indispensable de la mise Off de NOCOUNT afin que le
DataAdapter puisse rcuprer correctement le nombre de lignes modifies. Il me suffirait de le remettre ON
juste aprs pour pouvoir insrer sans risques des enregistrements dans une table de suivie par exemple.
CREATE PROCEDURE dbo.psInsertTitre
(
@title_id nvarchar(50),
@title nvarchar(80),
@type nchar(12),
@pub_id nchar(4),
@price money,
@royalty int,
@ytd_sales int,
@notes nvarchar(200),
@pubdate datetime
)
AS
SET NOCOUNT OFF;
INSERT INTO titles(title_id, title, type, pub_id, price, royalty, ytd_sales, notes, pubdate) VALUES
(@title_id, @title, @type, @pub_id, @price, @royalty, @ytd_sales, @notes, @pubdate);
SELECT title_id, title, type, pub_id, price, royalty, ytd_sales, notes, pubdate FROM titles WHERE
(title_id = @title_id)
GO
Le code de cration sera alors :
private SqlCommand CreateInsertCommand(SqlConnection LaConnexion) {
SqlCommand cmdIns = new SqlCommand("psInsertTitre", LaConnexion);
cmdIns.CommandType = CommandType.StoredProcedure ;
cmdIns.Parameters.Add(new SqlParameter("@title_id",
SqlDbType.NVarChar, 50, "title_id")) ;
cmdIns.Parameters.Add(new SqlParameter("@title",
SqlDbType.NVarChar, 80, "title"));
cmdIns.Parameters.Add(new SqlParameter("@type",
SqlDbType.NVarChar, 12, "type"));
cmdIns.Parameters.Add(new SqlParameter("@pub_id",
SqlDbType.NVarChar, 4, "pub_id"));
cmdIns.Parameters.Add(new SqlParameter("@price", SqlDbType.Money,
4, "price"));
cmdIns.Parameters.Add(new SqlParameter("@royalty", SqlDbType.Int,
4, "royalty"));
cmdIns.Parameters.Add(new SqlParameter("@ytd_sales",
SqlDbType.Int, 4, "ytd_sales"));
cmdIns.Parameters.Add(new SqlParameter("@notes",
SqlDbType.NVarChar, 200, "notes"));
cmdIns.Parameters.Add(new SqlParameter("@pubdate",
SqlDbType.DateTime, 8, "pubdate"));
return cmdIns;
}
Notez que dans ce cas j'utilise des paramtres nomms. L'ordre d'ajout la collection n'a plus aucune
importance.
104/130
Modification
CREATE PROCEDURE dbo.psUpdateTitre
(
@title_id nvarchar(50),
@title nvarchar(80),
@type nchar(12),
@pub_id nchar(4),
@price money,
@royalty int,
@ytd_sales int,
@notes nvarchar(200),
@pubdate datetime,
@Original_title_id nvarchar(50),
@Original_notes nvarchar(200),
@Original_price money,
@Original_pub_id nchar(4),
@Original_pubdate datetime,
@Original_royalty int,
@Original_title nvarchar(80),
@Original_type nchar(12),
@Original_ytd_sales int
)
AS
SET NOCOUNT OFF;
UPDATE titles SET title_id = @title_id, title = @title, type = @type, pub_id = @pub_id, price = @price,
royalty = @royalty, ytd_sales = @ytd_sales, notes = @notes, pubdate = @pubdate WHERE (title_id =
@Original_title_id) AND (notes = @Original_notes OR @Original_notes IS NULL AND notes IS NULL)
AND (price = @Original_price OR @Original_price IS NULL AND price IS NULL) AND (pub_id =
@Original_pub_id OR @Original_pub_id IS NULL AND pub_id IS NULL) AND (pubdate =
@Original_pubdate) AND (royalty = @Original_royalty OR @Original_royalty IS NULL AND royalty IS
NULL) AND (title = @Original_title) AND (type = @Original_type) AND (ytd_sales =
@Original_ytd_sales OR @Original_ytd_sales IS NULL AND ytd_sales IS NULL);
SELECT title_id, title, type, pub_id, price, royalty, ytd_sales, notes, pubdate FROM titles WHERE
(title_id = @title_id)
GO
Maintenant vous n'avez plus besoin d'explication donc :
private SqlCommand CreateUpdateCommand(SqlConnection LaConnexion) {
SqlCommand cmdUpd = new SqlCommand("psInsertTitre",
LaConnexion) ;
cmdUpd.CommandType = CommandType.StoredProcedure ;
cmdUpd.Parameters.Add(new SqlParameter("@RETURN_VALUE",
SqlDbType.Int, 4, ParameterDirection.ReturnValue, false, (byte)0,
(byte)0, "", DataRowVersion.Current, null));
cmdUpd.Parameters.Add(new SqlParameter("@title_id",
SqlDbType.NVarChar, 6, "title_id"));
cmdUpd.Parameters.Add(new SqlParameter("@title",
SqlDbType.NVarChar, 80, "title"));
cmdUpd.Parameters.Add(new SqlParameter("@type",
SqlDbType.NVarChar, 12, "type"));
cmdUpd.Parameters.Add(new SqlParameter("@pub_id",
SqlDbType.NVarChar, 4, "pub_id"));
cmdUpd.Parameters.Add(new SqlParameter("@price", SqlDbType.Money,
8, "price"));
105/130
106/130
cmdUpd.Parameters.Add(new SqlParameter("@advance", SqlDbType.Money, 8,
"advance"));
cmdUpd.Parameters.Add(new SqlParameter("@royalty", SqlDbType.Int,
4, "royalty"));
cmdUpd.Parameters.Add(new SqlParameter("@ytd_sales",
SqlDbType.Int, 4, "ytd_sales"));
cmdUpd.Parameters.Add(new SqlParameter("@notes",
SqlDbType.NVarChar, 200, "notes"));
cmdUpd.Parameters.Add(new SqlParameter("@pubdate",
SqlDbType.DateTime, 8, "pubdate"));
cmdUpd.Parameters.Add(new SqlParameter("@Original_title_id",
SqlDbType.NVarChar, 6, ParameterDirection.Input, false, (byte)0, (byte)0,
"title_id", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_advance",
SqlDbType.Money, 8, ParameterDirection.Input, false, (byte)0, (byte)0,
"advance", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_notes",
SqlDbType.NVarChar, 200, ParameterDirection.Input, false, (byte)0,
(byte)0, "notes", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_price",
SqlDbType.Money, 8, ParameterDirection.Input, false, (byte)0, (byte)0,
"price", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_pub_id",
SqlDbType.NVarChar, 4, ParameterDirection.Input, false, (byte)0, (byte)0,
"pub_id", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_pubdate",
SqlDbType.DateTime, 8, ParameterDirection.Input, false, (byte)0, (byte)0,
"pubdate", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_royalty",
SqlDbType.Int, 4, ParameterDirection.Input, false, (byte)0, (byte)0,
"royalty", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_title",
(byte)0, "title", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_type",
(byte)0, "type", DataRowVersion.Original, null));
cmdUpd.Parameters.Add(new SqlParameter("@Original_ytd_sales",
SqlDbType.Int, 4, ParameterDirection.Input, false, (byte)0, (byte)0,
"ytd_sales", DataRowVersion.Original, null));
return cmdUpd;
}
Remarquons tout de mme qu'il y a moins besoin de paramtres dans la collection puisque nous
travaillons avec des paramtres nomms et plus avec des espaces rservs.
U
107/130
Gestion des modifications
Comme je vous le disais prcdemment, lors de l'appel de sa mthode Update, le DataAdapter va
parcourir la collection des DataRow de ma table. Ds qu'il trouve une ligne dont le RowState n'est pas
'Unchanged', il appelle la commande correspondante l'tat de la ligne, valorise les paramtres et excute la
commande. La de deux choses l'une. Ou il rcupre une valeur positive pour le nombre de lignes modifies
par la commande et celle-ci est considre comme ayant aboutie ; ou il rcupre 0 et il considre celle-ci
comme un chec.
La mthode Update
Regardons plus en dtail la mthode Update de l'objet DataAdapter. Comme nous l'avons dj vu, un
Dataset n'est jamais li une source de donnes donc jamais un DataAdapter. L'appel de la mthode
Update doit donc toujours faire rfrence sa cible. Je vous ai dit plus haut que l'on utilise gnralement un
DataAdapter par table. Cela est trs vrai pour les composants mais la gestion par le code peut tre diffrente.
Il s'agit alors de savoir si on prfre crer de nombreux DataAdapter et grer moins de code ou en crer
moins et manipuler plus de commandes.
Les surcharges possibles de la mthode sont :
public int Update(DataRow[] dataRows)
La cible est un tableau d'objet DataRow, souvent obtenu l'aide de la mthode Select. Un tableau d'objet
DataRow ne doit pas tre vu comme autre chose qu'un tableau de pointeur visant les lignes de la table dont
elles sont issues. Toutes modifications des lignes du tableau sont en fait des modifications des lignes de la
table.
public int Update(DataSet dataSet)
Celle-l est un peu plus sournoise. Passer un Dataset comme cible prsuppose que l'on a correctement
gr le TableMapping du Dataset. En effet, c'est grce cette collection que le Dataset saura quelle table
fournir.
public int Update(DataTable dataTable)
C'est la surcharge la plus utilise. Attention, elle attend l'objet DataTable, pas le nom de la table
public int Update(DataRow[] dataRows, DataTableMapping tableMapping)
Plus rarement utilise, elle attend un tableau d'objets DataRow et un DataTableMapping.
public int Update(DataSet dataSet, string srcTable)
C'est srement la plus utilise. Globalement on travaille principalement avec la premire, la troisime et
celle-ci.
Donc maintenant j'appelle ma mthode.
Comme je vous l'ai dj dit, il y a parcours de la Table la recherche des lignes ayant des modifications
en attentes. Si votre table contient un million d'enregistrements et que vous en avez chang trois, ce n'est pas
bien rentable. Il existe deux mthodes pour restreindre ce comportement.
108/130
Restriction par Select
C'est une mthode trs efficace que nous allons revoir bientt. La mthode permet de mettre un filtre sur
l'tat / version des lignes. Prenons l'exemple suivant :
DataRow MaLign;object[] objTabTemp(6) = new object[6];
for(int compteur = 1 ; compteur <= 2 ; compteur++) {
objTabTemp(0) = string.Concat(compteur.ToString(),
compteur.ToString(), compteur.ToString(), compteur.ToString());
objTabTemp(1) = Choose(compteur, "Oui-Oui fait du ski", "inside the
actor's studio") ;
objTabTemp(2) = Choose(compteur, 1996, 2000) ;
objTabTemp(3) = DBNull.Value ;
objTabTemp(4) = "pas de description" ;
objTabTemp(5) = "mauvaise note" ;
objTabTemp(6) = 192 ;
MaLigne = tblTitres.NewRow();
MaLigne.ItemArray = objTabTemp;
tblTitres.Rows.Add(MaLigne);
}
int NbModif = dtAdTitre.Update(tblTitres.Select("", "",
DataViewRowState.Added)) ;
Dans ce cas mon DataAdapter ne va parcourir que les lignes ajoutes. Cela permet non seulement de
rduire considrablement le temps de travail du DataAdapter, mais aussi de pouvoir hirarchiser les actions
(Ajouter avant de supprimer par exemple). N'oubliez pas qu'il est possible de combiner les conditions, par
exemple la ligne ci-dessous est valide :
int NbModif = dtAdTitre.Update(tblTitres.Select("", "",
DataViewRowState.Added | DataViewRowState.Deleted));
Restriction par GetChanges

La mthode GetChanges renvoie une copie du Dataset ne contenant que les lignes modifies et les lignes
ncessaires l'intgrit rfrentielle de celles-ci. Attention, le rsultat et un Dataset. Contrairement un
tableau de DataRow, il vhicule aussi des contraintes, des relations et peut tre synchronis avec un
XMLDataDocument.
Il est aussi possible de restreindre le type de changement en passant un paramtre ou une combinaison
GetChanges
int NbModif = dtAdTitre.Update(dtsBiblio.GetChanges(DataRowState.Added));
Ces deux mthodes ont pourtant d'autres diffrences lors de la rcupration des informations que nous
allons voir maintenant.
Rcupration des informations de mise jour

U
Update : Une opration globale

Il existe une certaine dualit dans le fonctionnement de la mthode Update. Il s'agit d'une opration
globale qui regroupe une somme d'oprations atomiques. Votre premier choix dans l'laboration de votre
stratgie de mise jour est : "quel comportement adopter lors de l'chec d'une mise jour ?".
Dans la gestion des exceptions nous verrons un certain nombre de problmes que vous pouvez
rencontrer, mais si vous travaillez correctement, seule l'exception 'DBConcurrencyException' peut intervenir
lors d'une opration de mise jour.
Dans toute cette partie, je ne vous donne que les aspects techniques de la mise jour. A ma
connaissance, il n'y a pas de bonnes ou de mauvaises stratgies de mise jour tant que l'intgrit et la
cohrence de la source de donnes sont respectes. Le choix final peut dpendre, de votre application, des
droits que vous possdez, de votre vision de la problmatique mais nullement d'une conduite que je vous
aurais suggre, car selon mes applications, je ne procde pas toujours au mme choix.
109/130
Interrompre ou poursuivre
Lorsqu'une des commandes du DataAdapter obtient zro modification lors de l'excution de la requte, il
y a lecture de la proprit ContinueUpdateOnError. Celle-ci dfinit le comportement global que vous avez
dcid d'adopter.
Si la valeur est 'True', il y a remonte d'un message d'erreur vers la proprit RowError de la ligne et
poursuite ventuelle de l'opration.
Si sa valeur est 'False', il y a leve de l'exception 'DBConcurrencyException' (normalement) et
l'opration de mise jour est interrompue. Il existe alors deux possibilits :
Poursuivre l'opration en corrigeant ventuellement l'erreur
Arrter l'opration et invalider les modifications
Il existe un troisime choix, inacceptable mes yeux, qui consisterait laisser les donnes en
l'tat et d'interrompre l'opration. Comme dans un contexte de concurrence il n'est pas possible
de prvoir o se produiront les erreurs, cela reviendrait laisser la source dans un tat
incohrent.
Les deux modes de fonctionnement reposent sur une stratgie assez diffrente mme si le comportement
final est similaire. Pour ma part, je prfre travailler en mode continu et avec des vnements de ligne que de
lever une exception. Toutefois lorsque je travaille en transaction globale, j'utilise aussi la leve d'exception.
Je vais vous donner un exemple dans le paragraphe suivant.
Transaction globale, transactions partielles
Je ne vais pas dtailler ici ce qu'est une transaction ni ce qu'elle implique. Pour schmatiser, disons
qu'une transaction permet de traiter un groupe d'actions comme une entit atomique (non-divisible) ; c'est
dire que toutes les modifications seront acceptes ou toutes seront rejetes. Ceci permet une approche
scurise d'un groupe d'actions. Maintenant il existe plusieurs approches utilisant les transactions.
La transaction globale
Ceci consiste traiter l'opration Update comme une entit atomique. En gnral on utilise alors la leve
d'exception pour annuler la transaction. L'objet DataAdapter n'expose pas de proprits Transaction, vous
devez donc la spcifier pour tout ou partie de ces objets Command.
OleDbTransaction MaTransac = MaConn.BeginTransaction() ;
dtAdTitre.DeleteCommand.Transaction = MaTransac ;
dtAdTitre.InsertCommand.Transaction = MaTransac ;
dtAdTitre.UpdateCommand.Transaction = MaTransac ;
try {
dtAdTitre.Update(tblTitres) ;
MaTransac.Commit() ;
tblTitres.AcceptChanges() ;
MessageBox.Show("Modifications acceptes", "MODIFICATION",
MessageBoxButtons.OK, MessageBoxIcon.Information);
catch(DBConcurrencyException ConcOptEx) {
MaTransac.Rollback();
tblTitres.RejectChanges() ;
MessageBox.Show("Modifications rejetes, les tables ont t remises
dans l'tat d'origine", "ERREUR", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
catch(Exception Ex) {
//gestion des autres erreurs
}
110/130
Si vous utilisez le CommandBuilder, vous devez le forcer gnrer ses commandes explicitement pour
les attribuer la transaction.
OleDbCommandBuilder CmdBuild = new OleDbCommandBuilder(dtAdTitre);
CmdBuild.GetDeleteCommand.Transaction = MaTransac;
CmdBuild.GetInsertCommand.Transaction = MaTransac;
CmdBuild.GetUpdateCommand.Transaction = MaTransac;
Par dfaut, le CommandBuilder ne gnre ses commandes que lors de l'appel Update, d'o la ncessit
de cette criture.
Les transactions partielles
Ceci englobe deux notions diffrentes, les transactions successives et les transactions imbriques.
Les transactions successives consistent grer des lots Update comme des transactions indpendantes.
On peut dcider de faire une transaction pour les ajouts puis une pour les modifications.
Les transactions imbriques induisent une hirarchie dans la transaction. Elles sont en gnrale dans le
traitement par ligne. On cre une transaction mre qui contient d'autres transactions. Il convient alors d'tre
particulirement vigilant au niveau d'isolation utilis.
Update : Une succession d'opration atomique
A chaque ligne ayant des modifications en attente, la suite d'vnements suivants va se produire :
1. Le DataAdapter examine l'tat de la ligne et slectionne la commande utiliser. Si celle-ci n'est
pas dfinie, il y a appel du CommandBuilder. Si celui-ci n'est pas dfini, il y a leve d'une
exception 'InvalidOperationException'.
2. Les paramtres dont la proprit 'SourceColumn' est dfinie sont valoriss
3. L'vnement 'OnRowUpdating' est dclench. Dans les arguments de l'vnement vous pouvez
rcuprer
Command Obtient ou dfinit l'objet Command excuter en mme temps que Update.
Errors Obtient les erreurs gnres par le fournisseur de donnes .NET Framework lors de
l'excution de Command.
Row Obtient le DataRow envoyer par l'intermdiaire de Update.
StatementType Obtient le type de l'instruction SQL excuter (Insert, Update ou Delete)
TableMapping Obtient le DataTableMapping envoyer par l'intermdiaire de Update.
4. La commande s'excute
5. Il y a lecture de la proprit UpdateStatus de la commande utilise. Selon celle-ci, il y a retour
des informations vers la ligne
6. L'vnement 'OnRowUpdated' est dclench. Dans les arguments de l'vnement vous pouvez
rcuprer les mmes arguments que prcdemment plus le nombre de lignes modifies dans
'RecordsAffected'
7. La mthode AcceptChanges est appele
Il y a donc possibilit d'exercer un contrle sur chaque opration de ligne grce la gestion des deux
vnements RowUpdating et RowUpdated. Cette gestion est une alternative la transaction globale.
Elle est particulirement puissante et permet de construire des stratgies particulires pour chaque
application, mais elle peut tre lourde mettre en place.
Mettre jour le Dataset

U
Dans deux cas au moins il y a ncessit de rcuprer des informations supplmentaires du SGBD.
Les valeurs de version (TimeStamp) : Lorsque la mise jour est russie, le SGBD cre une
nouvelle valeur de version pour la ligne. Si vous ne rcuprez pas celle-ci, vous vous mettez
dans l'impossibilit de modifier une nouvelle fois la ligne.
Les cls gnres : De mme que pour les valeurs de versions, avec en plus le besoin de
connatre la valeur pour la communiquer aux enregistrements enfants.
111/130
Comprendre les cls gnres
Il nous faut dj comprendre correctement comment fonctionnent les proprits des colonnes de l'objet
DataTable. Lorsque je remplis ma table, je peux prciser au DataAdapter de rcuprer des informations sur
la cl en fixant la proprit MissingSchemaAction la valeur AddWithKey. Si je fais cela sur une table
possdant une colonne auto-incrmente comme cl primaire, le DataAdapter va attribuer une valeur
transparente pour la base de l'incrment, celle-ci n'tant plus modifiable. Un exemple va vous expliquer plus
clairement le problme.
OleDbCommand MaCommand = new OleDbCommand("SELECT Au_Id, Author, [year
born] FROM Authors", MaConn);
DataSet dtsBiblio = New DataSet();
OleDbDataAdapter dtAdAuteur = new OleDbDataAdapter() ;
//remplissage de la table
dtAdAuteur.SelectCommand = MaCommand ;
dtAdAuteur.MissingSchemaAction = MissingSchemaAction.AddWithKey ;
dtAdAuteur.Fill(dtsBiblio, "Auteurs") ;
//paramtrage supplmentaire
DataTable tblAuteurs = dtsBiblio.Tables("Auteurs");
tblAuteurs.Columns(0).AutoIncrementSeed = -1;
tblAuteurs.Columns(0).AutoIncrementStep = -1;
//ajout des lignes
DataRow MaLigne;
for(int cmpt = 1 ; cmpt <= 2 ; cmpt++) {
MaLigne = tblAuteurs.NewRow() ;
MaLigne("Author") = Choose(cmpt, "Bidou", "Voltaire");
MaLigne("year born") = Choose(cmpt, 1967, 1694);
tblAuteurs.Rows.Add(MaLigne) ;
}
Ce code va dclencher une erreur sur la ligne tblAuteurs.Rows.Add(MaLigne)
En effet, au moment de l'appel de NewRow, la colonne Au_Id tant de type auto-incrmente, il y a
attribution d'une valeur tant gale au numro maximum de la colonne +1. Malheureusement comme on a
fix le pas 1, le numro cr est le numro maximum prsent dans la colonne qui existe forcment dj,
donc leve d'une exception due la contrainte d'unicit. Pour faire bref, si vous utilisez AddWithKey, vous
ne devez pas modifier les proprits 'AutoIncrementSeed' et ' AutoIncrementStep'.
Il y a pourtant ncessit ne pas laisser le DataAdapter grer les numros de cl sa guise, comme nous
le verrons un peu plus loin.
Donc quand nous travaillons sur des colonnes de ce type, nous devons suivre les rgles suivantes :
Toujours veiller intgrer explicitement la colonne dans la requte select
Ne jamais fixer la valeur de MissingSchemaAction la valeur AddWithKey
Grer les valeurs de l'incrment
Toujours utiliser NewRow pour ajouter des lignes
Toute ces difficults sont intrinsques au modle dconnect.
Replacons le problme. C'est le SGBD qui gnre la valeur de cl des lignes ajoutes dans la base de
donnes. Dans le modle dconnect, vous rcuprer une table dans un tat donn, puis la liaison avec la
source est coupe. Vous avez donc d'un cot une colonne auto-incrmente dans la source et de l'autre une
colonne de type integer, de type auto-incrmente ou non dans votre DataTable. La colonne ayant la
contrainte d'unicit vous devez seulement veiller ce qu'une ligne ajoute dans votre table n'ait pas un
numro existant. Gnralement, on utilise une colonne auto-incrmente dans la DataTable laquelle on
attribue des valeurs ngatives afin de dtecter les ventuels conflits qui peuvent survenir avec l'utilisation de
la mthode Merge.
112/130
Mais cela permet aussi de se couvrir contre une faute de priorit dans la programmation. Imaginons le
cas suivant :

private void Form1_Load(object sender, System.EventArgs e){
this.DtsPubs1.EnforceConstraints = true;
Dim MaLigEd As dtsPubs.PublishersRow =
this.DtsPubs1.Publishers.AddPublishersRow("bidou", "bidou SARL", null,
"69001", "lyon", "france", null, null, null);
Dim MaLigTit As dtsPubs.TitlesRow =
this.DtsPubs1.Titles.AddTitlesRow("1111", "My sister is not a boy",
MaLigEd.PubID, null, 2000, null, null, null);
this.OleDbDATitles.Update(this.DtsPubs1.Titles);
}
Dans mon Dataset, je laisse le DataAdapter attribuer le numro ma ligne Editeur. Ce numro est
ensuite attribu comme cl trangre de ma ligne de titre. En l'tat, lors de l'appel de la mthode Update sur
ma table 'titres', je doit obtenir une erreur puisque je n'ai pas encore ajout ma ligne diteur la source de
donnes. Pourtant si un autre utilisateur a ajout un diteur dans ce laps de temps, la commande va passer et
mon livre sera attribu un autre diteur. Cela ne pourrait tre possible si j'avais gnr une cl ngative.
Car le deuxime problme vient des donnes relationnelles. Lorsque j'ajoute des donnes dans des tables
lies, mes valeurs de cl primaires gnres par ADO vont tre utilises comme cl trangre dans la table
fille. Ces valeurs gnres ne seront srement pas celles qui seront attribues par le SGBD. Je vais donc
devoir instaurer une hirarchie mes ordres de mise jour, ce qui est normal, mais aussi utiliser une relation
en cascade pour que les bonnes valeurs soient attribues lors des mises jour;
Nous reverront en dtail toutes ces techniques.
Utiliser des requtes
Commenons par le plus compliqu. Access ne gre ni les paramtres de sortie, ni les procdures
stockes, ni les lots de requtes. Dans ce cas, nous devons grer le travail de rcupration. Le seul moment
ou cela est possible, c'est dans la gestion de l'vnement OnRowUpdated. Dans notre exemple, il faut utiliser
Access 2000 ou suprieur car Access 97 ne supporte pas les requtes de rcupration d'identit.
Le principe consiste aller rcuprer la valeur de cl gnre l'aide de la requte "SELECT
@@IDENTITY". Celle-ci est sans risque avec Access puisqu'elle rcupre le dernier numro attribu sur la
connexion, et qu'Access ne risque pas d'tre perturb par un trigger, ceux-ci n'existant pas.
Un exemple serait :

OleDbCommand MaCommand = new OleDbCommand("SELECT Au_Id, Author, [year
DataSet dtsBiblio = new DataSet();
OleDbDataAdapter dtAdAuteur = new OleDbDataAdapter();
//remplissage de la table
dtAdAuteur.SelectCommand = MaCommand ;
dtAdAuteur.Fill(dtsBiblio, "Auteurs") ;
//paramtrage supplmentaire
DataTable tblAuteurs = dtsBiblio.Tables("Auteurs") ;
tblAuteurs.Columns(0).AutoIncrement = true;
tblAuteurs.Columns(0).AutoIncrementSeed = -1;
113/130
tblAuteurs.Columns(0).AutoIncrementStep = -1;
tblAuteurs.Columns(0).Unique = true;
tblAuteurs.Columns(0).AllowDBNull = false;
//cration de la commande d'insertion
dtAdAuteur.InsertCommand = new OleDbCommand("INSERT INTO Authors
(Author,[year born]) VALUES (?,?)", MaConn);
dtAdAuteur.InsertCommand.Parameters.Add("Auteur", OleDbType.VarWChar, 50,
"Author");
dtAdAuteur.InsertCommand.Parameters.Add("Annee", OleDbType.SmallInt, 0,
"year born");
dtAdAuteur.InsertCommand.UpdatedRowSource = UpdateRowSource.None;
//ajout des lignes
DataRow MaLigne;
for(int cmpt=0; cmpt<2;cmpt++){
MaLigne = tblAuteurs.NewRow() ;
MaLigne("Author") = Choose(cmpt, "Bidou", "Voltaire");
MaLigne("year born") = Choose(cmpt, 1967, 1694);
tblAuteurs.Rows.Add(MaLigne);
}
//ajout de l'vnement
dtAdAuteur.RowUpdated += new
OleDbRowUpdatedEventHandler(dtAdAuteur_RowUpdated);
dtAdAuteur.Update(tblAuteurs);
DataView VueAuteurs = new DataView(tblAuteurs);
VueAuteurs.Sort = "Au_Id DESC";
this.DataGrid1.DataSource = VueAuteurs;
}
private static void dtAdAuteur_RowUpdated(object sender,

OleDbRowUpdatedEventArgs args){
if(args.RecordsAffected == 1 && args.StatementType ==
StatementType.Insert){
OleDbCommand ComRecup = new OleDbCommand("SELECT @@IDENTITY",
args.Command.Connection);
args.Row("Au_Id") = (int)(ComRecup.ExecuteScalar());
args.Row.AcceptChanges();
}
}
Notez bien que dans la ligne
OleDbCommand ComRecup = new OleDbCommand("SELECT @@IDENTITY",
args.Command.Connection)
J'utilise bien la connexion de la commande utilise. Ceci est indispensable au bon fonctionnement de la
requte IDENTITY.
Pensez mettre la proprit UpdatedRowSource de la commande None puisque dans ce cas elle n'est
pas utilise.
114/130
Utiliser des Procdures stockes
Dans ce cas, c'est nettement plus simple car globalement il n'y a rien dautre faire que d'crire
correctement la procdure. Si vous reprenez les procdures que nous avons utilises plus haut, vous verrez
que toutes finissent par une requte SELECT rcuprant la ligne. On pourrait aussi rcuprer que certains
champs avec des paramtres de sortie. Grce cela, nul besoin de gestion vnementielle, il suffit de
configurer correctement la proprit UpdatedRowSource. Ainsi pour reprendre mon exemple, il faudrait
crire :
dtAdTitre.DeleteCommand = CreateDeleteCommand(MaConn);
dtAdTitre.DeleteCommand.UpdatedRowSource = UpdateRowSource.None;
dtAdTitre.InsertCommand = CreateInsertCommand(MaConn);
dtAdTitre.InsertCommand.UpdatedRowSource =
UpdateRowSource.FirstReturnedRecord;
dtAdTitre.UpdateCommand = CreateUpdateCommand(MaConn);
dtAdTitre.UpdateCommand.UpdatedRowSource =
UpdateRowSource.FirstReturnedRecord;
Notez qu'au niveau des performances, il est toujours un peu meilleur d'utiliser des paramtres de sortie
plutt qu'un lot de requtes.
Grer les checs

U
Malheureusement, il n'y a pas que les succs qui renvoient des informations. Dans l'ensemble la gestion
des checs suit trois cheminements possibles, si j'omets l'annulation par transaction
Informer et rendre la main l'utilisateur
C'est probablement le cas le plus frquent. Comme seul l'utilisateur connat la signification des
modifications, on transmet un rapport d'erreur qui peut prendre la forme de votre choix. Voici le code de
l'numration dtaille des erreurs
this.cmdMAJ.Click += new System.EventHandler(cmdMAJ_Click);
private sub cmdMAJ_Click(object sender, System.EventArgs e){
this.OleDbDATitles.ContinueUpdateOnError = true;
this.OleDbDATitles.Update(this.DtsPubs1.Titles);
this.OleDbDAPublishers.Update(this.DtsPubs1.Publishers);
if(this.DtsPubs1.HasErrors == true){
DataRow[] RowsErr();
foreach(DataTable TableTemp in this.DtsPubs1.Tables){
if(TableTemp.HasErrors == true){
RowsErr = TableTemp.GetErrors();
for(int cmpt=0;cmpt<RowsErr.GetUpperBound(0);cmpt++){
MessageBox.Show("Erreur sur la ligne : " +
RowsErr(cmpt).Item(TableTemp.PrimaryKey(0)) + " : " +
RowsErr(cmpt).RowError);
if(RowsErr(cmpt).GetColumnsInError.GetLength(0) > 0){
foreach(DataColumn ColErr in TableTemp.Columns) {
MessageBox.Show(ColErr.ColumnName + "A
rencontr l'erreur : " + RowsErr(cmpt).GetColumnError(ColErr));
}
}
RowsErr(cmpt).ClearErrors();
}
}
}
}
}
Dans ce cas j'efface l'erreur, mais ceci n'a rien d'obligatoire.
115/130
Correction dynamique
Autrement plus complexe est la gestion du traitement dynamique. En fait, elle ne peut concerner que de
rares cas ou la correction peut tre devine. N'oubliez pas que nous parlons d'erreur de concurrence optimiste
c'est dire de grer le comportement de votre application en fonction d'actions d'autres utilisateurs par nature
imprdictibles. Dans certain cas de modifications relatives de la valeur d'un champ, il est possible d'anticiper
sur l'erreur pour lgrement fausser le comportement concurrentiel et s'assurer que la modification va tre
accepte. Pour cela on utilise l'vnement 'OnRowUpdating' qui se produit avant l'envoi de la commande.
Je ne vais pas vous donner ce genre d'exemple car il s'agit de cas trs particuliers, demandant un codage
particulirement rigoureux.
Rejet partiel
Le rejet partiel est un mode trs simple et trs fonctionnel de comportement prdictif. Il revient dire
que lorsqu'une ligne particulire est rejete, toutes les lignes tant des modifications connexes doivent tre
rejetes aussi. On l'utilise principalement dans les mises jour relationnelles que nous allons voir
maintenant.
Mise jour relationnelle

U
Les mises jours relationnelles suivent des rgles strictes, aussi ne sont-elles pas difficiles grer, pour
peu que l'on ait correctement compris le principe.
Pour ne pas violer l'intgrit rfrentielle, on ne peut pas soumettre les modifications de tables parent-
enfant n'importe comment. La soumission d'une table complte mme n'est pas viable puisque l'ordre de
soumission dpend de la nature de la commande. Je vais dans cette partie reprendre le Dataset fortement typ
que nous avons construit auparavant.
Supposons que je veuille ajouter, modifier et supprimer des diteurs ainsi que des titres, la table titre
tant fille de la table diteurs. Si je fais un Update de la table titre complte, j'aurais des erreurs car je ne
pourrais pas ajouter de titre ayant pour diteur un enregistrement non encore envoy vers la source. De
mme, si je fais mon Update sur la table Editeurs, j'aurais des erreurs car je ne peux pas supprimer un
diteurs ayant des livres. Je dois donc toujours suivre le scnario suivant.
I. Envoyer les enregistrements ajouts la table mre
II. Envoyer les enregistrements ajouts la table fille
III. Envoyer les enregistrements modifis de la table mre
IV. Envoyer les enregistrements modifis de la table fille
V. Envoyer les enregistrements supprims de la table fille
VI. Envoyer les enregistrements supprims de la table mre
Et ne jamais droger cet ordre sous peine de dysfonctionnements majeurs. Bien sur, il y a la possibilit
d'utiliser des relations en cascade mais trs souvent celles-ci dpassent nos esprances et je vous conseille de
les viter.
Pour illustrer mon propos, je vais enlever l'diteur n192 de mon dataset fortement typ.
Donc j'utilise le code suivant :
dtsPubs.PublishersRow MaLigEd =
this.DtsPubs1.Publishers.FindByPubID(192);
DataRow MesLigTitres[] =
MaLigEd.GetChildRows(MaLigEd.Table.ChildRelations(0));
for(int cmpt=0; cmpt<MesLigTitres.GetUpperBound(0);cmpt++){
MesLigTitres(cmpt).Delete();
}
116/130
Ds prsent, j'aurais une erreur sur l'appel de la mthode Delete. Ceci sans avoir tent de mise jour.
Cette erreur est normale puisque mes titres sont engags dans une relation plusieurs plusieurs avec les
auteurs. Cette erreur est aussi le signe que mon Dataset fortement typ est bien construit. En effet, si j'avais
cr des relations en cascade, je n'aurais pas eu l'erreur maintenant, mais lors de la tentative de mise jour.
C'est pourquoi il faut toujours avoir un Schma au moins aussi restrictif que la source.
Notez au passage la plus grande simplicit du code utilisant un Dataset fortement typ.
Il nous faut donc supprimer les titres de la relation titres-auteurs. Mais pour travailler proprement, nous
devons retirer les auteurs qui n'auront plus de titre aprs la suppression. Si cet exercice n'est pas difficile
raliser c'est parce que nous connaissons le schma la cration; mais s'il nous fallait traiter tout cela
l'excution de faon gnrique, ce serait une autre paire de manche.
Je vais en profiter pour ajouter aussi une ligne chaque table et les mettre toutes en relations.

'Exemple de suppression
dtsPubs.PublishersRow MaLigEd =
this.DtsPubs1.Publishers.FindByPubID(192);
dtsPubs.TitlesRow MesLigTitres() =
MaLigEd.GetChildRows(MaLigEd.Table.ChildRelations(0));
int cmpt, cmpt1;
dtsPubs.Title_AuthorRow[] MesLigRelat;
for(cmpt=0;cmpt<MesLigTitres.GetUpperBound(0);cmpt++){
MesLigRelat =
MesLigTitres(cmpt).GetChildRows("TitlesTitle_x0020_Author");
For(cmpt1=0;cmpt<MesLigRelat.GetUpperBound(0);cmpt1++){
MesLigRelat(cmpt1).Delete();
}
MesLigTitres(cmpt).Delete();
}
MaLigEd.Delete();
dtsPubs.AuthorsRow mesLigAuteurs() =
this.DtsPubs1.Authors.Select("count(child(AuthorsTitle_x0020_Author).Au_I
d)=0");
for(cmpt=0;cmpt<mesLigAuteurs.GetUpperBound(0);cmpt++){
mesLigAuteurs(cmpt).Delete() ;
}
'exemple d'ajout
dtsPubs.AuthorsRow MaLigAut = this.DtsPubs1.Authors.NewAuthorsRow;
dtsPubs.TitlesRow MaLigTit = this.DtsPubs1.Titles.NewTitlesRow;
MaLigEd = this.DtsPubs1.Publishers.NewPublishersRow;
MaLigEd.Address = "2 rue du Castor";
MaLigEd.City = "Paris";
MaLigEd.Company_Name = "Edition du Castor";
MaLigEd.Name = "ECSARL";
MaLigEd.SetCommentsNull();
MaLigEd.SetFaxNull();
MaLigEd.SetTelephoneNull();
MaLigEd.State = "FRANCE";
MaLigEd.Zip = "75012";
117/130
this.DtsPubs1.Publishers.AddPublishersRow(MaLigEd);
MaLigAut.Author = "Bidou";
MaLigAut.Year_Born = 1967;
this.DtsPubs1.Authors.AddAuthorsRow(MaLigAut);
MaLigTit.Description = "c'est un bon livre" ;
MaLigTit.ISBN = "1111-2222" ;
MaLigTit.Notes = "si si!" ;
MaLigTit.PubID = MaLigEd.PubID;
MaLigTit.SetCommentsNull();
MaLigTit.Subject = "livre" ;
MaLigTit.Title = "le vin se sifflera trois fois" ;
MaLigTit.Year_Published = "2000";
this.DtsPubs1.Titles.AddTitlesRow(MaLigTit);
this.DtsPubs1.Title_Author.AddTitle_AuthorRow(MaLigAut, MaLigTit);
}
this.cmdMAJ.Click += new System.EventHandler(cmdMAJ_Click);
private void cmdMAJ_Click(object sender, System.EventArgs e){

//les suppressions
this.OleDbDATitAut.Update(this.DtsPubs1.Title_Author.Select("", "",
DataViewRowState.Deleted));
this.OleDbDAAuthors.Update(Me.DtsPubs1.Authors.Select("", "",
this.OleDbDATitles.Update(this.DtsPubs1.Titles.Select("", "",
Me.OleDbDAPublishers.Update(Me.DtsPubs1.Publishers.Select("", "",
DataViewRowState.Deleted))
//les ajouts
this.OleDbDAPublishers.Update(this.DtsPubs1.Publishers.Select("", "",
DataViewRowState.Added));
this.OleDbDAAuthors.Update(this.DtsPubs1.Authors.Select("", "",
this.OleDbDATitles.Update(this.DtsPubs1.Titles.Select("", "",
this.OleDbDATitAut.Update(this.DtsPubs1.Title_Author.Select("", "",
}
this.OleDbDAPublishers.RowUpdated += new
OleDbRowUpdatedEventHandler(OleDbDAPublishers_RowUpdated) ;
private void OleDbDAPublishers_RowUpdated(object sender,

System.Data.OleDb.OleDbRowUpdatedEventArgs e){
if (e.StatementType == StatementType.Insert){
OleDb.OleDbCommand MaComRecup = new OleDb.OleDbCommand("SELECT
@@IDENTITY", e.Command.Connection);
e.Row.Item("PubId") = MaComRecup.ExecuteScalar();
e.Row.AcceptChanges();
}
}
this.OleDbDAAuthors.RowUpdated += new
OleDbRowUpdatedEventHandler(OleDbDAAuthors_RowUpdated) ;
118/130
private void OleDbDAAuthors_RowUpdated(object sender,
System.Data.OleDb.OleDbRowUpdatedEventArgs e){
if (e.StatementType == StatementType.Insert){
OleDb.OleDbCommand MaComRecup = new OleDb.OleDbCommand("SELECT
@@IDENTITY", e.Command.Connection);
e.Row.Item("Au_Id") = MaComRecup.ExecuteScalar();
e.Row.AcceptChanges();
}
}
Ce code fonctionnera maintenant parfaitement pour les suppressions. Par contre vous pouvez rencontrer
des problmes lors des insertions. Pourquoi ?
Je rcupre bien les valeurs de cls gnres par le SGBD dans l'vnement RowUpdated. Mais ces
valeurs ne vont pas forcment tre mises jour dans les tables filles. Dans le cas que je prends, la proprit
UpdateRule vaut Cascade dans toutes les relations, les enregistrements lis rcuprent donc bien la bonne
valeur avant d'tre envoys vers la source. Mais si ces relations valaient None cela ne fonctionnerait pas.
J'aurais alors une erreur lors de l'insertion puisque la valeur de cl trangre fournie n'existerait pas. Cette
erreur pourrait tre facilement contourne dans l'vnement RowUdpated par une gestion des
enregistrements enfants.
Mise jour distante

U
Tout cela est donc parfait dans une application Client / Serveur. Mais il en va autrement pour les
architectures n-tiers. Comme je vous l'ai dj dit dans ce type d'architecture, le fournisseur manag est
gnralement dans une couche mtier distante, et il y a change XML entre la couche Mtier et la couche
prsentation (votre application).
Si je reprends mon exemple prcdent, vous voyez que je vais communiquer toute une base de donnes
pour modifier six enregistrements. Il est probable que vous aurez rapidement un change de vue un peu vif
avec le Rottweiler de l'administrateur si vous travaillez ainsi. Heureusement, ADO.NET propose une
solution pour ceux qui n'aiment pas les chiens.
Comme le but est d'conomiser la bande passante, vous pouvez appeler la mthode GetChanges de
l'objet Dataset. Celle-ci cre un nouveau Dataset contenant toutes les lignes ayant une modification en attente
(dont l'tat n'est pas 'Unchanged') plus toutes les lignes ncessaires la garantie de l'intgrit rfrentielle.
Vous ne trouverez pas de code dans cette partie puisque celui n'a rien de particulier, c'est le mcanisme
qu'il faut bien comprendre. Donc je passe mon petit Dataset ma couche mtier, celle-ci applique les
modifications et renvoie le Dataset. Je dispose donc de deux objets Dataset, le Dataset principal, et le Dataset
entrant. Pour n'en obtenir plus qu'un je vais utiliser la mthode Merge.
Les rgles de la fusion sont les suivantes :
Les tables du Dataset entrant sont compares aux tables du Dataset principale, s'il y a identit de
nom les tables sont fusionnes, sinon la table est ajoute.
Quand deux tables sont fusionnes, il y a recherche d'identit de la cl primaire. Si la colonne
porte le mme nom, il y a fusion, sinon l'vnement MergeFailed est lev.
Pour les lignes ayant la mme valeur de cl primaire dans les deux Dataset, il y a crasement des
valeurs originales par les valeurs originales du Dataset entrant.
Les lignes du Dataset entrant n'ayant pas de ligne quivalente sont ajoutes.
Comme dans notre cas, le Dataset entrant est un clone partiel du Dataset principal, il y aura identit
complte. Donc il faut veiller :
Vrifier les lignes en erreurs du Dataset entrant afin de dupliquer l'erreur sur le Dataset
principal et/ou d'appliquer RejectChanges sur ces lignes
Appeler la mthode AcceptChanges sur les autres lignes pour remettre leurs tats
'Unchanged'.
Eviter de se faire couillonner par les cls gnres.
Je vais dtailler ce dernier point. Lorsque vous avez appel la mthode GetChanges, votre Dataset
modifi contenait les valeurs de cls gnres par ADO.
119/130
Votre Dataset entrant contient lui les valeurs gnres par le SGBD. Comme il n'y aura certainement pas
identit entre les deux cls, les lignes entrantes vont tre ajoutes la table. Et nous voil les heureux
possesseurs d'un doublon, qui plus est non existant dans la table source.
Il convient ds lors de rcuprer les lignes d'origines pour les supprimer. Si vous avez suivi mes
conseils, vos lignes ont une valeur de cl ngative, et les identifier ne devrait pas poser de problmes.
Pensez les supprimer l'aide de la mthode Remove ou appliquez successivement Delete et
AcceptChanges.
Il est possible de modifier le comportement de la mthode Merge en utilisant une de ces surcharges.
public void Merge(Dataset dataSet, bool preserveChanges, MissingSchemaAction
missingSchemaAction)
Dans ce cas vous pouvez contrler plus facilement le comportement de la fusion en prservant ou non
les changements.
Notions de liaisons de donnes

Gnralits
U
Dans cette partie nous allons tudier la liaison de donnes principalement pour les contrles de feuilles.
Les contrles lis se prsentent en deux familles, ceux qui n'en affichent qu'une (de donne) et les autres.
La liaison des donnes aux contrles est un trs vaste sujet que nous allons peine aborder dans ce
cours. Je vous conseille vivement de lire l'aide sur ce sujet.
Les contrles pouvant tre lis utilisent des objets Binding pour se lier avec des donnes. Un objet
Binding dfini :
La proprit du contrle devant tre lie
La source de donne (DataView, DataTable)
Le chemin de navigation
Prenez l'habitude de travailler sur des objets DataView. Ceux-ci sont fondamentalement faits pour
exposer les donnes. Les modifications faites sur ces objets sont transmises aux objets de donnes sous-
jacents.
Le chemin de navigation peut permettre de spcifier le nom d'un champ ou le nom d'un champ fils au
travers d'une relation ou d'autres formes plus complexes. Gnralement, on ne manipule pas directement les
objets Binding par le code ; ils sont crs par la dfinition des proprits des contrles en mode cration /
excution.
Les contrles qui n'affichent qu'une donne simultanment (TextBox par ex.) sont appels contrles
liaison simple. Ils exposent gnralement une proprit DataBindings qui est la collection d'objet Binding du
contrle. Les contrles liaison complexe (ListBox, DataGrid) utilisent plutt des proprits DataSource et
DataMember.
Bien que ce ne soit pas le sujet ici, les contrles peuvent tre lis autre chose qu'une source de
donnes.
Il n'y a pas grand intrt lier un contrle liaison simple une seule donne. Le but est souvent de
pouvoir naviguer dans les enregistrements pour que ces contrles affichent les donnes de l'enregistrement
en cours. Je vous ai expliqu plus avant la navigation dans un DataView, mais celle-ci n'induit pas le
changement d'enregistrement en cours pour les objets Binding. Pour grer celle-ci, on utilise l'objet
CurrencyManager.
U
120/130
CurrencyManager
L'objet CurrencyManager est une couche entre un objet DataView et les contrles lis. Il prend en
charge des notions de position qui permettent aux contrles dpendant d'afficher l'tat d'un enregistrement
'courant'. Attention toutefois avec ce concept. Il ne faut pas le voir comme la gestion de position du moteur
de curseur client ADO. L'objet CurrencyManager est li une table, pour grer les CurrencyManager d'un
Dataset, on utilise un objet BindingContext.
Proprit
Bindings (BindingCollection)
Renvoie la collection des objets Binding gr par le CurrencyManager
Current (object / DataRowView)
Renvoie l'objet en cours. Dans le cas qui nous intresse de la liaison aux donnes d'un Dataset, celui-ci
est toujours un DataRowView.
Position (Integer)
Renvoie ou dfinit la position de l'objet dsign par les contrles dpendants. C'est par l'intermdiaire de
cette proprit que se gre la navigation
Mthodes
Refresh
Force le remplissage des contrles dpendants.
ResumeBinding, SuspendBinding
Arrte ou reprend la liaison de donnes.
Evnements
CurrentChange
Se produit lorsque les valeurs lies changent.
MetaDataChanged
Se produit lors de la modification du schma (Ajout d'une colonne, transtypage)
PositionChanged
Se produit lors du changement de la position.
U
121/130
Navigation
La navigation est assez facile grer. Ce code peut paratre lourd car je cre les liaisons de contrle par
le code alors qu'habituellement on le fait directement dans l'environnement de dveloppement.
Notez aussi qu'il faut tester la position dans les boutons Next et Previous.
public CurrencyManager VueTable;
this.Form1.Load += new System.EventHandler(this.Form1_Load);

OleDbCommand MaCommand = new OleDbCommand("SELECT Au_Id, Author,
[year born] FROM Authors", MaConn);
DataSet dtsBiblio = new DataSet();
DataView tblAuteurVue;
dtAdAuteur.SelectCommand = MaCommand;
dtAdAuteur.Fill(dtsBiblio, "Auteurs");
tblAuteurVue = new DataView(dtsBiblio.Tables(0));
this.txtAuteur.DataBindings.Add("Text", tblAuteurVue, "Author");
this.txtID.DataBindings.Add("Text", tblAuteurVue, "Au_Id");
this.txtYear.DataBindings.Add("Text", tblAuteurVue, "year born");
VueTable = (CurrencyManager)(BindingContext(dtsBiblio,
"Auteurs"));
}
this.cmdFirst.Click += new System.EventHandler(this.cmdFirst_Click);

private void cmdFirst_Click(object sender, System.EventArgs e){
VueTable.Position = 0;
}
this.cmdNext.Click += new System.EventHandler(this.cmdNext_Click);

private void cmdNext_Click(object sender, System.EventArgs e){
if (VueTable.Position < VueTable.Count 1) VueTable.Position++;
}
this.cmdPrev.Click += new System.EventHandler(this.cmdPrev_Click);

private void cmdPrev_Click(object sender, System.EventArgs e){
if (VueTable.Position > 0) VueTable.Position--;
}
this.cmdLast.Click += new System.EventHandler(this.cmdLast_Click);

private void cmdLast_Click(object sender, System.EventArgs e){
VueTable.Position = VueTable.Count 1 ;
}
122/130
Gestion des exceptions
Jusqu'ici je n'ai pas gr tellement d'exceptions dans les codes que je vous ai fournis. C'est uniquement
pour donner un code plus lisible car malheureusement, il faut grer des exceptions dans un environnement de
base de donnes. Nous allons voir ici les exceptions leves dans ADO.NET.
ConstraintException
Se produit lors d'un conflit autour d'une contrainte. Elle doit tre gre lorsque l'utilisateur saisit les
donnes.
DeletedRowInaccessibleException
Se produit lorsqu'on cherche agir sur un DataRow supprim. Rarement utilis hors de la phase de
conception.
DuplicateNameException
Leve si on duplique un nom dans un Dataset. Gnralement nom de table, relation ou colonne.
InRowChangingEventException
Jamais utilise. Pour la dclencher, il faut appeler la mthode EndEdit au sein de l'vnement
RowChanging.
InvalidConstraintException
InvalidConstraintException est lev lorsque vous appelez les mthodes suivantes de manire incorrecte
pendant une tentative de cration ou d'accs une relation.
DataRelationCollection.Add : peut tre leve lorsqu'une relation ne peut pas tre cre en se basant
sur les valeurs fournies
DataRowCollection.Clear : peut tre leve si ForeignKeyConstraint est applique
DataRowCollection
DataRow.GetParentRow : peut tre leve si les colonnes possdent des types de donnes diffrents
ou si les tables n'appartiennent pas au mme DataSet.
InvalidExpressionException
Se dclenche si vous ajoutez votre table une colonne contenant une expression invalide. Contient les
deux sous erreurs suivantes
SyntaxErrorException
Erreur de syntaxe dans l'expression
EvaluateException
L'expression ne peut pas tre value
MissingPrimaryKeyException
Est leve si vous appelez la mthode Contains ou Find de DataRowCollection et que la cl primaire n'est
pas dfinie.
NoNullAllowedException
Celle ci est assez frquente. Elle se produit dans les cas o on passe une valeur NULL dans une colonne
qui ne l'accepte pas. Elle peut tre leve avec retard si vous dsactivez temporairement les contraintes. Les
cas les plus frquents sont lors de l'appel des mthodes :
DatarowCollection.Add
DataRow.EndEdit
DataRow.ItemArray
DataTable.LoadDataRow
Mais une opration Fill peut la dclencher aussi.
ReadOnlyException
Comme son nom l'indique, leve sur une tentative de modification d'une valeur en lecture seule.
123/130
RowNotInTableException
Dclenche si vous appelez une des mthodes suivantes sur une ligne qui a t supprime l'aide des
mthodes Delete ou Remove.
DataRow.AcceptChanges
DataRow.GetChildRows
DataRow.GetParentRow
DataRow.GetParentRows
DataRow.RejectChanges
DataRow.SetParentRow
VersionNotFoundException
Leve lors de l'appel d'une version inexistante de l'objet DataRow. Par exemple l'appel de la version
originale d'une ligne ajoute lve cette exception.
DBConcurrencyException
Celle-l vous la verrez souvent, nous en avons dj parle.
Exception du serveur
U
Toutes les erreurs que le fournisseur rencontre comme erreurs dues au serveur arrive sous la forme
OleDbException, OdbcException, SqlException etc..
Sauf si vous tes l'administrateur de la source, il ne vous appartient pas de grer ces exceptions sauf au
moment de l'ouverture de la connexion.
Exception Gnrale
U
Un grand nombre d'exceptions qui n'appartiennent pas l'espace de nom system.data peuvent se
produire du fait de votre code. Celles-ci proviennent gnralement de fautes de types ou d'opration
invalides. la plupart du temps, on ne les rencontre qu'en phase de conception.
Manipulation du Dataset
Utiliser une source non sure
U
Je n'entends pas le terme de source non sure du fait qu'elle prsente des risques.
Dans tous les exemples prcdents, j'ai construit des Dataset en rcuprant des donnes de SGBD ayant
eux aussi des donnes types, des contraintes, des relations etc
Mais il est aussi possible de rcuprer des donnes d'une source qui ne soit pas un SGBD ou un fichier
XML. Dans ce cas, la stratgie de rcupration se doit d'tre diffrente.
Dans cet exemple nous allons importer les donnes d'une feuille Microsoft Excel.
Il faut tout d'abord utiliser un fournisseur qui puisse attaquer la cible dsire, dans notre cas MS-Jet.
Pour la suite, il convient de dfinir si l'on souhaite anticiper les erreurs ou adapter les donnes un
schma.
124/130
Identifier un schma
C'est srement le plus hasardeux, sauf utiliser un pilotage d'Excel. En effet rien n'est plus risqu que
d'infrer un schma en fonction de donnes. Toutefois cela fonctionne si on rcupre des donnes bien
formates. Mais dans le moindre doute, Jet typera la colonne comme une chane.
Le code de rcupration est assez simple.

private sub Form1_Load(object sender, System.EventArgs e){
System.Data.DataSet DSExcel;
System.Data.OleDb.OleDbDataAdapter dAdExcel;
System.Data.OleDb.OleDbConnection MaConn;
MaConn = new
System.Data.OleDb.OleDbConnection(@"provider=Microsoft.Jet.OLEDB.4.0;data
source=C:\\tutoriel\\tuto.XLS;Extended Properties=Excel 8.0;");
dAdExcel = new System.Data.OleDb.OleDbDataAdapter("select * from
[Test$]", MaConn);
DSExcel = new System.Data.DataSet();
dAdExcel.Fill(DSExcel);
foreach(DataColumn MaCol in DSExcel.Tables(0).Columns){
MessageBox.Show(MaCol.DataType.ToString);
}
}
Avec ce code je rcupre bien le contenu de la feuille dans mon Dataset, mais le DataAdapter a typ
comme il lui semblait bon, bref je n'ai aucun contrle sur les donnes entrantes.
Travailler avec FillError
C'est le cas le plus frquent. Nous avons dj cr l'objet DataTable et nous voulons insrer les donnes
de notre feuille Excel dans cette table. Pour ce faire nous allons devoir intercepter l'vnement FillError.
En quoi celui-ci nous intresse-t-il ?
Il va permettre de continuer le remplissage malgr les erreurs, et il peut aussi rcuprer les lignes ne
correspondant pas au schma afin que l'utilisateur puisse les corriger. Enfin il permet d'ajouter des
contraintes sur la table.

System.Data.DataSet DSExcel;
System.Data.OleDb.OleDbDataAdapter dAdExcel;
System.Data.OleDb.OleDbConnection MaConn;
MaConn = new
System.Data.OleDb.OleDbConnection(@"provider=Microsoft.Jet.OLEDB.4.0;data
source=C:\\tutoriel\\tuto.XLS;Extended Properties=Excel 8.0;");
dAdExcel = new System.Data.OleDb.OleDbDataAdapter("select * from
[Test$]", MaConn);
DSExcel = new System.Data.DataSet();
DataTable TableExcel = new DataTable("Excel");
TableExcel.Columns.Add("Ident",
System.Type.GetType("System.Int32"));
TableExcel.Columns.Add("Nom",
System.Type.GetType("System.String"));
TableExcel.Columns.Add("DateNaissance",
System.Type.GetType("System.DateTime"));
125/130
TableExcel.Columns.Add("Habilit",
System.Type.GetType("System.Boolean"));
TableExcel.Constraints.Add("pk1", TableExcel.Columns(0), true);
DSExcel.Tables.Add(TableExcel);
System.Data.Common.DataTableMapping MonMap = new
System.Data.Common.DataTableMapping();
MonMap = dAdExcel.TableMappings.Add("Excel", "Excel");
MonMap.ColumnMappings.Add("Chiffre", "Ident");
MonMap.ColumnMappings.Add("Nom", "Nom");
MonMap.ColumnMappings.Add("Date", "DateNaissance");
MonMap.ColumnMappings.Add("Bool", "Habilit");
dAdExcel.FillError += new
System.Data.FillErrorEventHandler(this.dAdExcel_FillError);
dAdExcel.Fill(DSExcel, "Excel");
MaConn.Close();
foreach(DataColumn macol in DSExcel.Tables(0).Columns){
MessageBox.Show(macol.ColumnName.ToString);
}
this.DataGrid1.DataSource = DSExcel.Tables(0);
}
private static void dAdExcel_FillError(object sender,

System.Data.FillErrorEventArgs args){
args.Continue = true;
}
Transfrer une table

U
Le principe de l'exercice consiste transfrer une table d'une base de donnes dans une autre base. Pour
cela nous allons pouvoir utiliser le mode dconnect et le remplissage sans validation. En effet, l'objet
DataAdapter expose une proprit AcceptChangesDuringFill qui par dfaut est vraie. Celle-ci fait que sur
chaque ligne ajoute dans DataTable, il y a appel de la mthode AcceptChanges. Si je change la valeur d'tat
de chacune de mes lignes ajoutes va rester 'Added'. Ds lors, un appel de la mthode Update sur un
DataAdapter. Toutefois ceci ne transfre que les lignes. Il faut ncessairement crer la table auparavant. Pour
cela, soit-on utilise l'interop COM et un modle de gestion de structure comme ADOX ou SQL-DMO, soit-
on passe par une requte DDL.
J'utilise donc le code suivant avec ADOX :
this.Button1.Click += new System.EventHandler(this.Button1_Click);

private void Button1_Click(System.Object sender, System.EventArgs e){
ADOX.Catalog MonCat = new ADOX.Catalog();
MonCat.Create(@"Provider=Microsoft.Jet.OLEDB.4.0;Data
source=C:\\tutoriel\\Essai.mdb");
ADOX.Table MaTable = new ADOX.Table();
ADOX.Column MaColId = new ADOX.Column();
ADOX.Column MaColAut = new ADOX.Column();
ADOX.Column MaColYear = new ADOX.Column();
MaColId.Name = "Au_Id";
MaColId.Type = ADOX.DataTypeEnum.adInteger;
MaTable.Columns.Append(MaColId);
MaColAut.Name = "Author";
MaColAut.Type = ADOX.DataTypeEnum.adVarWChar;
MaColAut.DefinedSize = 50;
MaTable.Columns.Append(MaColAut);
126/130
MaColYear.Name = "year born";
MaColYear.Type = ADOX.DataTypeEnum.adSmallInt;
MaTable.Columns.Append(MaColYear);
MaTable.Name = "Authors";
MonCat.Tables.Append(MaTable);
MonCat = null;
OleDbCommand MaSelCommand = new OleDbCommand("SELECT Au_Id,
Author, [year born] FROM Authors", MaConn);
dtAdAuteur.SelectCommand = MaSelCommand;
dtAdAuteur.AcceptChangesDuringFill = false;
dtAdAuteur.Fill(dtsBiblio, "Authors");
OleDbConnection MaNewConn = new
Source=C:\\tutoriel\\essai.mdb;");
OleDbCommand MaUpdCommand = new OleDbCommand("Select * From
authors", MaNewConn);
OleDbDataAdapter dtAdCopie = new OleDbDataAdapter();
dtAdCopie.SelectCommand = MaUpdCommand;
OleDbCommandBuilder MonBuild = new
OleDbCommandBuilder(dtAdCopie);
dtAdCopie.Update(dtsBiblio, "Authors");
MessageBox.Show("done");
}
Un peu de XML
Nous avons vu que la fabrication d'un schma n'tait pas complique. Attention de ne pas confondre
schma et Dataset fortement typ. Un Dataset fortement typ est une classe base sur un schma XSD.
L'intgration du XML dans ADO.NET permet de nombreuses oprations. Nous allons en voir trois,
souvent utilises mais il en existe de nombreuses autres.
Synchroniser
U
La synchronisation se fait toujours entre un Dataset et un XMLDataDocument. Synchroniser signifie

que toute modification faite dans l'un est rpercute dans l'autre. L'intrt est double. Cela permet de grer la
persistance n'importe quel moment et cela donne accs simultanment toutes les fonctionnalits d'un
Dataset et au service d'un XML. La mthode de synchronisation la plus simple consiste crer un
XMLDataDocument sur un Dataset existant
OleDbCommand MaSelCommand = new OleDbCommand("SELECT Au_Id, Author, [year
dtAdAuteur.FillSchema(dtsBiblio);
dtAdAuteur.Fill(dtsBiblio, "Authors") ;
System.Xml.XmlDataDocument xmlDoc = new
System.Xml.XmlDataDocument(dtsBiblio) ;
N'oubliez pas que le schma est primordial. Un fichier XMLDataDocument offre une vue hirarchique
de donnes relationnelles. Il existe deux nombreuses faons de rdiger un schma en XML. Vous devez
avoir le schma le plus complet possible avant de synchroniser.
127/130
La deuxime mthode consiste crer le schma du Dataset, synchroniser ce schma avec le
XMLDataDocument puis charger le document XML Contenant les donnes. Vous devez vous assurer de la
concordance du schma.
OleDbCommand MaSelCommand = new OleDbCommand("SELECT Au_Id, Author, [year
dtAdAuteur.FillSchema(dtsBiblio);
System.Xml.XmlDataDocument xmlDoc = new
System.Xml.XmlDataDocument(dtsBiblio);
xmlDoc.Load("MonDoc.xml");
Enfin il est possible de procder dans le sens inverse. C'est dire, charger un document XML dans le
XMLDataDocument, crer un Dataset ayant le schma correspondant et remplir le Dataset en utilisant la
proprit Dataset du XMLDataDocument
Annoter le schma
U
Les annotations de schma permettent dans une certaine mesure une manipulation plus aise de vos
Dataset fortement typs. Cela revient modifier les noms utiliss dans le Dataset et donc ceux apparaissant
dans la fonction Intellisense. Les annotations possibles sont les suivantes :
Annotation Description
typedName Nom de l'objet.
typedPlural Nom d'une collection d'objets.
typedParent Nom de l'objet lorsqu'il y est fait rfrence dans une relation parente.
typedChildren Nom de la mthode permettant de retourner des objets d'une relation enfant.
Valeur utiliser si la valeur sous-jacente est DBNull. Consultez le tableau suivant pour
nullValue
les annotations nullValue. La valeur par dfaut est _throw.
Il est aussi possible d'annoter nullValue avec les valeurs suivantes :
nullValue Description
Spcifie une valeur retourner. La valeur retourne doit correspondre au type de l'lment.
Valeur Par exemple, utilisez nullValue="0" pour retourner 0 pour les champs de type null integer
(entier nul).
_throw Leve d'une exception. Il s'agit de la valeur par dfaut.
_null Retourner une rfrence null ou lever une exception si un type primitif est rencontr.
Pour des chanes, retourner String.Empty, dans les autres cas, retourner un objet cr partir
_empty
d'un constructeur vide. Si un type primitif est rencontr, lever une exception.
Pour utiliser des annotations de DataSet typ, vous devez inclure la rfrence xmlns suivante dans votre
schma : xmlns:codegen="urn:schemas-microsoft-com:xml-msprop"
Optimisation du code
Les optimisations de codage sont toujours les mmes, je n'y reviendrai pas. Nous allons parler ici
uniquement des rgles d'optimisation engendres par ADO.NET ou les SGBD. N'oubliez pas que votre
source de donnes doit tre bien construite. Aucune optimisation d'aucune sorte ne saura vous faire gagner ce
qu'une source mal conue peut vous faire perdre.
U
128/130
Connexion
Ne travaillez pas en connexion maintenue. N'oubliez pas que mme dans une architecture client serveur,
maintenir une connexion ouverte un cot. A contrario, ouvrez parfois explicitement pour contrer le
fonctionnement par dfaut.
Regardons le code suivant :
Ce code n'est pas optimis. En effet je vous ai dit que le DataAdapter restituait la connexion dans l'tat
d'origine. Dans mon exemple, la connexion est ferme au dbut. Lors du premier appel de Fill, le
DataAdapter l'ouvre puis la referme. Au second appel, le processus recommence. J'ai donc ouvert et ferm
deux fois ma connexion.
Si j'ouvre explicitement ma connexion avant les oprations de remplissage, les appels Fill ne la
referment pas. J'aurais donc ouvert et ferm ma connexion une seule fois.
MaConn.Open();
MaConn.Close();
N'utilisez pas la mise en pool de connexion sur des architectures de type client / serveur.
Ouvrez toujours la connexion explicitement avant de dmarrer une transaction
Command
U
Les objets Command sont des objets lgers, trs efficaces dans le cadre d'une optimisation.
Utilisez ExecuteNonQuery chaque fois que possible. Utilisez toujours ExecuteScalar quand vous n'avez
qu'un rsultat rcuprer.
Utilisez 'prepare' sur les requtes excutes plusieurs fois.
DataReader
U
Prfrez l'utilisation d'un DataReader plutt que d'un Dataset si vous n'avez pas besoin de maintenir les
donnes en mmoire.
Utilisez le aussi pour les trs gros jeu d'enregistrements.
Fermez toujours le DataReader ds que vous ne vous en servez plus.
Utilisez la rcupration type (GetString, GetInt32.) plutt que GetValue.
Utiliser l'accs squentiel (SequentialAccess) lorsque vous n'avez pas besoin de rcuprer toute la ligne
d'un coup.
Si vous ne lisez pas tous les enregistrements renvoys, appelez la mthode Cancel de l'objet Command
avant de fermer le DataReader.
U
129/130
DataAdapter et DataReader
Evitez d'utiliser le CommandBuilder.
Rapatriez les champs ncessaires et les enregistrements ncessaires. Tout rapatrier est souvent une
solution de facilit coteuse.
Ne rcuprez pas le schma l'excution si vous pouvez l'viter.
Privilgiez la rcupration de tables spares plutt que de rcuprer une table cre sur une jointure.
Rcuprez les champs longs avec parcimonie.
Utilisez plutt des Dataset typs.
Ecrasez plutt que reconstruire. Si votre table une cl primaire, re faites un Fill pour remettre jour
votre table. Si vous ne voulez pas perdre vos modifications, utilisez Merge.
Grez vos TableMappings.
Utilisez des DataView pour les fonctionnalits de recherche ou de filtre. Les DataView crent des index
qui amliore grandement la vitesse.
Rduisez les lignes transmises par GetChanges ou Select.
Et surtout, utilisez l'objet plutt que la position ordinale, la position ordinale plutt que le nom.
Conclusion
Voil, nous avons vu les bases de la programmation ADO.NET. Il y aurait encore de nombreux sujets
aborder. Nanmoins vous avez maintenant toutes les connaissances pour dvelopper des applications
orientes donnes. Je vous conseille vivement d'aller fouiller un peu dans l'aide, il y a de nombreux exemples
que je n'ai pas traits car ils taient dj dedans.
Bonne programmation.
130/130

ADO .NET (Version C#)

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ADO .NET (Version C#)

Uploaded by

Copyright:

Available Formats

ADO.

NET (version C#)

HTU www.developpez.com. Reproduction, copie, publication sur un UTH

autre site Web interdite sans l'autorisation des auteurs.

PASSER D'ADO A ADO.NET .......................................................................................6

Les limitations du modle ADO ............................................................................................................................... 6

ADO.NET la rvolution ............................................................................................................................................ 6

ADO.NET remplace compltement ADO .............................................................................................................. 6

Il faut tout rapprendre pour passer d'ADO ADO.NET....................................................................................... 6

ADO.NET une volution ncessaire ........................................................................................................................ 7

Une nouvelle architecture ....................................................................................................................................... 9

Fournisseur manag ............................................................................................................................................... 13

Objet Connection .................................................................................................................................................. 13

Objet Command ................................................................................................................................................... 14

Objet DataReader ................................................................................................................................................. 14

L'objet DataAdapter ............................................................................................................................................. 15

Intgration du XML ............................................................................................................................................... 15

Document XML ................................................................................................................................................... 15

XML Schema (XSD) ............................................................................................................................................ 16

Utiliser ADO avec les langages DotNet ................................................................................................................. 17

Comment utiliser ADO ? ...................................................................................................................................... 19

Considrations sur les performances .................................................................................................................... 21

Cration ou excution ........................................................................................................................................... 21

Programmation des SGBD administrs ................................................................................................................ 22

Proprits des objets et login ................................................................................................................................ 22

Requtes et procdures stockes........................................................................................................................... 22

Considrations sur les procdures stockes .......................................................................................................... 23

Gestion des erreurs du SGBD............................................................................................................................... 23

LES CLASSES ADO.NET ...........................................................................................24

Les espaces de nom dans DotNet ........................................................................................................................... 24

La classe Dataset ..................................................................................................................................................... 25

ExtendedProperties & PropertyCollection ........................................................................................................... 25

Proprits & mthodes lies au XML................................................................................................................... 29

La classe DataTable ................................................................................................................................................ 32

Construction d'une table par le code ..................................................................................................................... 32

Mise jour des tables ........................................................................................................................................... 32

Mthodes de DataTableCollection ....................................................................................................................... 33

Proprits de DataTable ....................................................................................................................................... 34

Mthodes de DataTable ........................................................................................................................................ 34

Evnements de DataTable .................................................................................................................................... 36

La classe DataColumn ............................................................................................................................................ 36

Colonne auto-incrmente .................................................................................................................................... 37

Type de donnes ................................................................................................................................................... 37

Mthode Add de DataColumnCollection ............................................................................................................. 38

Proprits de DataColumn .................................................................................................................................... 38

La classe DataRow .................................................................................................................................................. 42

Les valeurs de la ligne .......................................................................................................................................... 42

L'tat d'une ligne................................................................................................................................................... 42

Remonte des erreurs ........................................................................................................................................... 42

Ajout et modification de ligne .............................................................................................................................. 43

Mthode de DataRowCollection .......................................................................................................................... 43

Proprits de l'objet DataRow .............................................................................................................................. 44

Mthode de DataRow ........................................................................................................................................... 45

La Classe Constraint .............................................................................................................................................. 47

La classe DataRelation ........................................................................................................................................... 49

Proprits de DataRelation ................................................................................................................................... 51

Les classes DataView & DataViewManager ......................................................................................................... 52

Proprits de DataView ........................................................................................................................................ 54

Mthodes du DataView ........................................................................................................................................ 54

Les fournisseurs manags ...................................................................................................................................... 56

Lot de requtes ..................................................................................................................................................... 56

Procdures stockes & Requtes stockes............................................................................................................ 56

Objet Transaction ................................................................................................................................................. 62

Les commandes ....................................................................................................................................................... 62