2025/2026

Base de données ([Link])

Spécialité : GL 3

Armand KODJO
ING MANAGER DES SYSTÈMES
D’INFORMATION ET D’INFRASTRUCTURE
(MS2I)
 BASE DE DONNÉES ([Link])

[Link] Base de Données

Sommaire
1 Introduction .............................................................................................................................. 2
2 Les bases dedonnées ............................................................................................................. 2
2.1 Les fournisseurs de données ............................................................................................2
2.2 Accéder à la base de données ......................................................................................... 7
2.3 Interface portable ..............................................................................................................8
2.4 Mode connecté / Mode déconnecté ................................................................................11
3 Etablir une connexion .............................................................................................................13
3.1 Les chaînes deconnexions .............................................................................................13
3.2 Les pools deconnexions ................................................................................................ 16
3.3 Déconnexion .................................................................................................................. 17
4 Mode connecté ...................................................................................................................... 18
4.1 Les commandes ............................................................................................................. 18
4.2 Utiliser des commandes ................................................................................................. 20
4.3 Les paramètres de commandes SQL............................................................................. 25
4.4 Les types de paramètres ................................................................................................ 25
4.5 Créer un paramètre ........................................................................................................ 25
4.8 Copier un grand nombre de données ............................................................................. 28
4.9 Les transactions ............................................................................................................. 29
5 Mode déconnecté .................................................................................................................. 32
5.7 Exemples ........................................................................................................................43
6 Conclusion ............................................................................................................................. 47

Page 1 sur 46
 BASE DE DONNÉES ([Link])

1 Introduction

Ce chapitre porte sur la gestion de base de données grâce à l’[Link]. L’[Link] permet de relié une
application à une base de données. La nouveauté de l’[Link] par rapport à son ancêtre l’ADO est la gestion
de données dans une application dans un environnement déconnecté. Ce mode, par rapport au mode connecté
classique, possède plusieurs avantages et inconvénients. Ces deux modes sont utilisables avec les fournisseurs
de base de données qui seront cités plus loin dans le chapitre.

2 Les bases de données

2.1 Les fournisseurs de données

Chaque fournisseur de données permet la communication avec un type de base de données au travers
d’une API. Une API (Application Programming Interface) est l’interface qui permet l’accès de logiciel par un
autre. Ces fournisseurs permettent de récupérer et de transférer des modifications entre l’application et une
base de données. Toutes les classes permettant d’utiliser ces fournisseurs se trouvent dans l’espace de nom
[Link]. Sur le Framework 3.5, il existe quatre types de fournisseurs :
 Sql Server
 OLE DB
 OBDC
 Oracle

Page 2 sur 46
 BASE DE DONNÉES ([Link])

Chaque fournisseur est relié à une base de données propre, c'est-à-dire qu’il est compatible à l’API de sa base
de données. Cependant, les bases de données peuvent implémenter plusieurs API (par exemple en installant
certains pilotes comme ODBC pour l’ODBC) :

Fournisseur Description
Les classes de ce fournisseur se trouvent dans l’espace de nom [Link], chaque nom
SQL Server de ces classes est préfixé par Sql. SQLServer à accès au serveur sans utiliser d’autres couches
logicielles le rendant plus performant.
Les classes de ce fournisseur se trouvent dans l’espace de nom [Link], chaque nom
deces classes est préfixé par OleDb. Ce fournisseur exige l’installation de MDAC (Microsoft Data
Access Components). L’avantage de ce fournisseur est qu’il peut dialoguer avec n’importe quelle
OLE DB base de données le temps que le pilote OLE DB est installé dessus, mais par rapport à SQL server,
OLEDB utilise une couche logicielle nommée OLEDB ; il requiert donc plus de ressources
diminuant par conséquent les performances.
Les classes de ce fournisseur se trouvent dans l’espace de nom [Link], chaque nom de
ces classes est préfixé par Odbc. Tout comme l’OLEDB, ODBC exige l’installation de MDAC. Il
ODBC fonctionne avec le même principe qu’OLE DB mais au lieu d’utiliser une couche logicielle, il utilise
le pilote ODBC.
Les classes de ce fournisseur se trouvent dans l’espace de nom [Link], chaque
Oracle nom de ces classes est préfixé par Oracle. Il permet simplement de se connecter à une source de
données Oracle.

Remarque: SQL Server et Oracle sont tous deux des fournisseurs de données managés. C'est-à-dire qu’ils sont
optimisés pour certains types de bases de données. Afin que l’accès aux données soit sûr, les fournisseurs de
données doivent être disponibles sur le poste de travail. La méthode GetFactoryClasses de la classe
DbProviderFactories permet de donner les fournisseurs disponibles sur le poste de travail en question. Il faut,
par contre, ajouter l’espace de nom [Link]. Par exemple :

Page 3 sur 46
BASE DE DONNÉES ([Link])

Page 4 sur 46
 BASE DE DONNÉES ([Link])
Vous devriez avoir un résultat semblable à :

Page 5 sur 46
 BASE DE DONNÉES ([Link])

2.2 Accéder à la base de données

Pour dialoguer avec la base de données, tous ces fournisseurs implémentent six classes de bases:

Classe Description
Stocke les informations sur la commande et permet son exécution sur le serveur
Command
de base de données.
Permet de générer automatiquement des commandes ainsi que des paramètres
CommandBuilder
pour un DataAdapter.
Connection Permet d’établir une connexion à une source de données spécifiée.

Permet le transfert de données de la base de données vers l'application et

DataAdapter inversement (par exemple pour une mise à jour, suppression ou modification de
données). Il est utilisé en mode déconnecté (voir partie 5.4).

DataReader Permet un accès en lecture seule à une source de données.

Transaction Représente une transaction dans le serveur de la base de données.

Remarque: La classe Connection n’apparaît pas dans le Framework 3.5. En effet, les classes des fournisseurs
managés ont leur propre classe tel que SqlConnection.

Page 6 sur 46
 BASE DE DONNÉES ([Link])

2.3 Interface portable

Les classes de chaque fournisseur varient, et donc par conséquence, le code devient spécifique
à un fournisseur. Mais il existe une solution pour remédier à ce problème : on peut utiliser
comme type de données les interfaces qu’elles implémentent. En effet, les classes spécifiques
aux fournisseurs permettront juste d’établir la connexion, on pourra ensuite utiliser que ces
interfaces. Les six classes données dans le tableau précédent implémentent leurs interfaces
respectives :

Interface Description
IDataAdapter Permet de remplir et actualiser un objet DataSet et de mettre à jour une source de données.

Permet de lire un ou plusieurs flux de données en lecture seule à la suite de l’exécution d’une
IDataReader
commande.
Permet d’implémenter un paramètre pour une commande.
IDataParameter
Permet de donner une commande qui s’exécutera au moment de la connexion à une source de
IDbCommand
données.

IDbConnection Représente une connexion unique avec une source de données.

Représente un jeu de méthodes qui permet d’exécuter des opérations sur des bases de données
IDbDataAdapter
relationnelles (insertion, sélection,…).
Représente une transaction à exécuter au niveau d’une source de données.
IDbTransaction

Ces interfaces ne montrent pas l’étendue des possibilités que peut donner un fournisseur managé. En effet, les
fournisseurs managés comprennent leurs propres classes permettant plus d’actions ou en les améliorant.

Page 7 sur 46
 BASE DE DONNÉES ([Link])

Voici un exemple de code utilisant ces interfaces

Page 10 sur 46
 BASE DE DONNÉES ([Link])

Cela donnera quelque chose de semblable à :

2.4 Mode connecté / Mode déconnecté

L’[Link]éparerlesactionsd’accèsoudemodificationd’unebasede données. En effet, il est possible

de manipuler une base de données sans être connecté à celle-ci, il suffit juste de se connecter pendant un court

Page 11 sur 46
 BASE DE DONNÉES ([Link])
laps de temps afin de faire une mise à jour. Ceci est possible grâce au DataSet. C’est pourquoi, il existe deux
types de fonctionnements :
 Le mode connecté
 Le mode déconnecté

Ci-après, la différence par avantages et inconvénients :

Mode Avantages Inconvénients

Avec un mode connecté, la connexion est L’inconvénient se trouve surtout au niveau des
permanente, par conséquence les données sont ressources. En effet, tous les utilisateurs ont
toujours à jour. De plus il est facile de voir une connexion permanente avec le serveur.
Connecté quels sont les utilisateurs connectés et sur quoi Même si l’utilisateur n’y fait rien la connexion
ils travaillent. Enfin, la gestion est simple, il y gaspille beaucoup de ressource entrainant
a connexion au début de l’application puis aussi des problèmes d’accès au réseau.
déconnexion à la fin.
L’avantage est qu’il est possible de brancher Les données ne sont pas toujours à jour, ce qui
un nombre important peut aussi entrainer des conflits lors des mises
d’utilisateurs sur le même serveur. En effet, ils à jour. Il faut aussi penser à prévoir du code
se connectent le moins souvent et durant la pour savoir ce que va faire l’utilisateur en cas
Déconnecté plus courte durée possible. De plus, avec cet de conflits.
environnement déconnecté, l’application
gagne en performance par la disponibilité des
ressources pour les connexions.

Il n’existe pas un mode meilleur que l’autre, tout dépend de l’utilisation que l’on compte en faire.

Page 12 sur 46
 BASE DE DONNÉES ([Link])

3 Établir une connexion

3.1 Les chaînes déconnexions

Dans un mode connecté, il faut tout d’abord connecter l’application à la base de données. Nous
utiliserons SQL Server 2005 pour la suite. Pour ouvrir cette connexion il faut d’abord déclarer un variable,
ici ce sera « connexion » :
La propriété ConnectionString permet d’indiquer les paramètres de connexion. Cela se fait sous
forme de chaîne de caractères, tel que par exemple :

Voici les différents paramètres disponibles dans une ConnectionString :

Paramètre Description
Indique le temps d’attente de connexion en seconde. Ce laps de temps dépassé,
Connect Timeout
une exception est levée.
Indique la durée de vie d’une connexion dans un pool, la valeur 0 (zéro)
Connection LifeTime
correspond à l’infini.

Connection Reset Indique si la connexion a été réinitialisée lors de son retour dans un pool.

Data Source Indique le nom ou l’adresse réseau du serveur.

Initial Catalog Indique le nom de la base de données où l’application doit se connecter.

Page 13 sur 46
 BASE DE DONNÉES ([Link])

Indique s’il faut un nom et un mot de passe. Si la valeur et sur False, un login et
Integrated Security
password seront demandés.
Indique le nombre maximum de connexion dans un pool. Par défaut, le nombre
Max Pool Size
maximum de connexions est 100.

Min Pool Size Indique le nombre minimum de connexion dans un pool.

Persist Security Info Indique si le nom et le mot depasse est visible par la connexion.

Pwd Indique le mot de passe associé au compte SQL Server.

Pooling Indique si une connexion peut être sortie d’un pool.

User ID Indique le nom du compte SQL Server.

Afin de vérifier l’état d’une connexion, [Link] propose l’énumération ConnectionState. Il possède
différentes propriétés :

Propriété Description
Permet de savoir si la connexion est interrompue, cette connexion peux se fermer
Broken
puis se rouvrir.

Closed Permet de savoir si l’objet connexion est fermé.

Connecting Permet de savoir si l’objet connexion est en cours déconnexion.

Executing Permet de savoir si une commande est en train de s’exécuter.

Fetching Permet de savoir si l’objet connexion est en train de récupérer des données.

Open Permet de savoir si l’objet connexion est ouvert.

Page 14 sur 46
 BASE DE DONNÉES ([Link])
Voici, par exemple :

Page 15 sur 46
 BASE DE DONNÉES ([Link])

3.2 Les pools déconnexions

Afin de réduire le coût en ressource engendré par les connexions à des bases de données, l’[Link]
propose une technique d’optimisation : le pool de connexion. Lorsque qu’une application ouvre une nouvelle
connexion, un pool est créé. Les pools permettent de stocker toutes les requêtes récurrentes. Chaque fois
qu’un utilisateur ouvre une connexion avec la même ConnectionString qu’un pool, le dispositif de
connexion vérifie s’il y a une place disponible dans ce pool, si le MaxPoolSize n’est pas atteint, la connexion
rentre dans l’ensemble. Un pool est effacé lorsqu’une erreur critique est levée.
Les pools sont paramétrables dans le ConnectionString et une connexion est retirée d’un pool lorsqu’elle est
inactive depuis une certaine durée.
Voici les mots-clés de connexion de votre pool de connexion :

Nom Par défaut Description

Quand une connexion tente de rejoindre le pool, si son temps de

Connection Lifetime 0 connexion dure plus de x secondes (x étant la valeur de la

propriété), la connexion est stoppée.
Détermine si la connexion est remise à zéro lors de la création
Connection Reset True d’un ensemble de connexion.
Si vous utilisez une connexion dans le cadre d’une transaction,
Enlist True vous pouvez définir ce mot-clé sur True.
Indique le nombre de secondes d’une connexion avant qu’elle
Load Balance Timeout 0 soit détruite de l’ensemble.
Indique le nombre maximum de connexions autorisées dans un
ensemble pour une chaîne déconnexion spécifique. En d’autres
termes si votre connexion demande sans cesse de se connecter à
Max Pool Size 100 la base de données, vous pourriez avoir besoin d’augmenter votre
Max Pool Size (par défaut 100 connexions autorisés).

Page 16 sur 46
 BASE DE DONNÉES ([Link])

Détermine le nombre minimum de connexions autorisées.

Min Pool Size 0
Indique une valeur booléenne si la connexion être
Pooling True groupée (True) ou si elle est ouverte à chaque demande
de connexion.

En plus des mots-clés permettant de contrôler le comportement des Connection Pool, il existe des méthodes
qui ont des incidences sur un ensemble :

Nom Object Description

SqlConnection et OracleConnection Réinitialise toutes les Connection Pool.

ClearAllPool
SqlConnection et OracleConnection Réinitialise une Connection Pool spécifique.
ClearPool
Spécifie au pool de connexions qu'il peut être
détruit lorsque la dernière connexion qu'il
ReleaseObjectPool OleDbConnection et Odbcconnection
contenait a été détruite.

3.3 Déconnexion

Pour couper la connexion entre l’application et la base de données, il

suffit d’écrire :

Page 17 sur 46
 BASE DE DONNÉES ([Link])

4 Mode connecté

4.1 Les commandes

Contrairement à une base de données, les requêtes SQL et les procédures stockées sont exécutées à partir de
commandes. Les commandes contiennent toutes les informations nécessaires à leur exécution et effectuent des
opérations telles que créer, modifier ou encore supprimer des données d’une base de données. Vous utilisez
ainsi des commandes pour faire des exécutions de requêtes SQL qui renvoient les données nécessaires.
Remarque: les requêtes SQL et les procédures stockées sont deux choses différentes. En effet les procédures
stockées sont des requêtes SQL déjà enregistrées dans la mémoire cache du serveur. Chaque fournisseur de
base de données possède leurs propres objets Command qui sont les suivantes :

Nom Type de sources de données

SqlCommand SQL Server
OleDbCommand OLE DB
OdbcCommand ODBC
OracleCommand Oracle

Il existe plusieurs propriétés et méthodes communes à chaque fournisseur pour gérer des commandes, voici les
principales :

Propriétés

Nom Description

Permet de définir l’instruction de requêtes SQL ou de procédures stockées à

CommandText
exécuter. Lié à la propriété CommandType.
Permet d’indiquer le temps en secondes avant de mettre fin à l’exécution de la
CommandTimeout
commande.

Permet d’indiquer ou de spécifier la manière dont la propriété

CommandType
CommandText doit être exécutée.
Permet d’établit une connexion.
Connection
C’est la collection des paramètres de commandes. Lors de l’exécution de
Parameters requêtes paramétrées ou de procédures stockées, vous devez ajouter les
paramètres objet dans la collection.

Page 18 sur 46
 Permet
BASEdeDEdéfinir
DONNÉESla SqlTransaction
([Link]) dans laquelle la SqlCommand
Transaction
s’exécute.

Page 19 sur 46
 BASE DE DONNÉES ([Link])

Méthodes

Nom Description
Cancel Permet de tenter l’annulation de l’exécution d’une commande.
Permet d’exécuter des requêtes ou des procédures stockées qui ne retournent
ExecuteNonQuery
pas de valeurs.
Permet d’exécuter des commandes et les retourne sous forme de tableau de
ExecuteReader
données (ou des lignes).
Permet d‘exécuter les requêtes ou les procédures stockées en retournant une
ExecuteScalar
valeur unique.
Permet de retourner les données sous le format XML.
ExecuteXMLReader

Vous pouvez aussi manipuler des événements. Voici les deux principaux :

Evènements Description
Disposed Permet d’appeler la dernière méthode avant que l’objet ne soit détruit.

StatementCompleted (seulement pour Se produit lorsque l’exécution d’une instruction se

SqlCommand)
termine.

4.2 Utiliser des commandes

Une fois la connexion établie, la classe SqlCommand permet d’appeler la méthode

CreateCommand qui permettra l’exécution decommandes SQL. Il existe trois méthodes afin de créer une
commande :
 Vous pouvez directement utiliser un des constructeurs dela classe SqlCommand. Par contre
cela nécessite l’utilisation de deux propriétés : CommandText et Connection. Voici un
exemple utilisant cette méthode :

Page 20 sur 46
 BASE DE DONNÉES ([Link])

 La deuxième méthode est l’utilisation d’un constructeur surchargé, voici par exemple :

 La dernière méthode est d’utiliser la méthode CreateCommand de l'objet de connexion comme

dans l’exemple ci-dessous :

Page 21 sur 46
 BASE DE DONNÉES ([Link])

Le fonctionnement pour exécuter une procédure stockée est quasiment identique à l’exécution d’une requête
SQL classique. Il faut que la propriété CommandText contienne le nom de la procédure, par contre la propriété
CommandType doit prendre la valeur StoredProcedure au lieu de Text. L’avantage d’une procédure stockée est
une amélioration de la performance car la procédure se trouve précompilée dans le cache du serveur. Voici un
exemple qui permet d’afficher toutes les informations d’un utilisateur de la table Employe :
‘VB

Dim connexion As SqlConnection = New SqlConnection("Data

Source=.\SQLServeur;Initial Catalog=DotNetFrance;Integrated
Security=True")
Dim Command As SqlCommand = [Link]()
[Link]()

Dim id As String
Dim requete As String = "RecupInformation"

[Link] = requete
[Link] = [Link]

[Link]("Quel est l'id de la personne sur laquelle vous voulez

les informations ?")
id = [Link]()

Dim paramIdToKnow As SqlParameter = New SqlParameter("@IdToKnow", id)

[Link](paramIdToKnow)

Dim lecture As IDataReader = [Link]()

While ([Link]())
[Link]("Id : {0} Nom : {1} Prenom : {2} Role : {3}",
lecture("ID"), [Link](1), [Link](2),
lecture.GetInt32(3))
End While

[Link]()
[Link]()

Page 22 sur 46
 BASE DE DONNÉES ([Link])

Afin d’exécuter une instruction SQL qui renvoie plusieurs valeurs, onpeututiliser la méthode ExecuteReader;
elle va retourner l’objet Datareader qui va permettre la lecture des données. Si l’instruction SQL ne doit
renvoyer qu’une valeur unique, on peut utiliser la méthode ExecuteScalar qui va à la fois s’occuper de
l’exécution et retourner la valeur.

Page 23 sur 46
 BASE DE DONNÉES ([Link])

Voici, par exemple, un code permettant d’afficher la base de données Dot-Net France :

‘VB

Dim connexion As SqlConnection = New SqlConnection("Data

Source=.\SQLServeur;Initial Catalog=DotNetFrance;Integrated
Security=True")
Dim Command As SqlCommand = [Link]()
Dim requete As String = "SELECT [Link] 'ID', [Link], [Link], [Link] FROM
Employe e, Role r WHERE([Link] = [Link]) "
[Link] = requete

[Link]()
Dim lire As SqlDataReader = [Link]()

[Link]("Lecture du DataReader" + vbNewLine + vbNewLine)

' Lit les informations de la base de données

While ([Link]())
[Link]("Id : {0} Nom : {1} Prenom : {2} Role : {3}",
lire("ID"), [Link](1), [Link](2), [Link](3))
End While
' Permet d'afficher

[Link]()
[Link]()

//C#

SqlConnection connexion = new SqlConnection(@"Data

Source=.\SQLServeur;Initial Catalog=DotNetFrance;Integrated
Security=True");
SqlCommand command = [Link]();
string requete = "SELECT [Link] 'ID', [Link], [Link], [Link] FROM Employe
e, Role r WHERE([Link] = [Link]) ";
[Link] = requete;

[Link]();
SqlDataReader lire = [Link]();
// Lit les informations de la base de données

[Link]("Lecture du DataReader \n\n");

while ([Link]())
{
[Link]("Id : {0} Nom : {1} Prenom : {2} Role : {3}",
lire["ID"], [Link](1), [Link](2), [Link](3));
}
// Permet d'afficher

[Link]();
[Link]();

Page 24 sur 46
 BASE DE DONNÉES ([Link])

Vous devriez obtenir un affichage semblable à :

Vous pouvez également exécuter des commandes qui vous renvoient les données au format XML. Pour cela
vous devez régler la propriété CommandText de votre instruction SQL au format XML puis faire appel à la
méthode ExecuteXMLReader qui retourne unobjet XmlReader (dont la classe est stockée dans [Link]).
Lorsque vous configurez votre commande, vous pouvezutiliser le Query Designer afin de créer et
depersonnaliser vos requêtes. Donc vous devez sélectionner votre base dedonnées dans le Server Explorer puis
cliquer sur New Query. Vous ouvrez ainsi le Query Designer et pourrez alors non seulement créer votre
requête mais en plus la personnaliser (tableau, affichage…).

Durant unéchange entre une application et unebase de données, l’application est bloquée durant l’attente de la
réponse du serveur. Pour remédier à ce problème, l’[Link] propose les commandes asynchrones. En effet,
ces commandes permettent à l’application de faire autre chose en attendant la réponse du serveur.
Voici les méthodes qui sont utilisées lors d’un processus asynchrone :

Méthodes Description

Commence la version asynchrone de la méthode

BeginExecuteNonQuery
ExecuteNonQuery.

Commence la version asynchrone de la méthode

BeginExecuteReader
ExecuteReader.

Commence la version asynchrone de la méthode

BeginExecuteXmlReader
ExecuteXmlReader.

Appeler cette méthode après l’événement

EndExecuteNonQuery StatementCompleted afin d’achever l’exécution de la
commande.

Appeler cette méthode après l’événement

EndExecuteReader StatementCompleted afin de renvoyer le DataReader avec
les données retournées par la commande.

Appeler cette méthode après l’événement

EndExecuteXmlReader StatementCompleted afin de renvoyer le XmlReader avec
les données retournées par la commande.

Page 25 sur 46
 BASE DE DONNÉES ([Link])

4.3 Les paramètres de commandes SQL

Un paramètre peut être considéré comme un type de variable qui permet de transmettre des valeurs et des
retours entre votre demande et la base de données. Comme toute variable dans une application, les paramètres
sont créés pour contenir un certain type dedonnées. Les types dedonnées des paramètres sontassignés
enutilisant les typesdéfinis dans l’énumération de l’objet [Link]. Cette énumération contient
toute une liste des types disponibles dans SQL Server.
Vous définissez unparamètre à une requêtes SQL (ou à une procédure stockée) lorsque vous changez les
critères de votre requêtes rapidement. Par exemple l’utilisation typique d’utilisation d’un paramètre est dans la
clause WHERE de votre requête SQL. Les paramètres vous permettent aussi de contrôler la façon dont est
entré un utilisateur dans une requête.
Remarque : Pour SQL Server le symbole @ est utilisé pour créer des paramètres nommés. Le symbole point
d’interrogation ? (paramètre anonyme) est utilisé dans les autres types de base de données.

4.4 Les types de paramètres

La modification des informations contenue dans votre base de données est faite par les instructions
SQL. Il existe quatre types de paramètres :

- le premier est de type Input, c'est-à-dire que vous voulez utiliser un paramètre pour
envoyer des données à la base de données.

- le second est le type Output qui lui est utilisé lorsqu’on veut récupérer des données.

- le troisième est l’InputOutput qui est exploité pour faire les deux actions
précédentes, c'est-à-dire envoyer et récupérer des données.

- enfin le dernier type est le ReturnValue qui retourne simplement une valeur
assignée.

4.5 Créer un paramètre

Paramétrer vos requêtes sert aussi à les rendre génériques. Les paramètres servent à prendre unemplacement
dansune requête qui sera plus tard utilisé dans votre code.

Page 26 sur 46
 BASE DE DONNÉES ([Link])

La classe SqlParameter permet de créer des objets de type Sqlparameter contenant : le nom, la valeur et
la direction d’utilisation du paramètre.

Voici un exemple permettant d’ajouter un utilisateur dans la base de données DotNetFrance :

‘VB

Dim connexion As SqlConnection = New SqlConnection("Data

Source=.\SQLServeur;Initial Catalog=DotNetFrance;Integrated
Security=True")
Dim Command As SqlCommand = [Link]()
Dim nom, prenom, requete, role As String

[Link]("Entrez les données suivantes :" + vbNewLine)

’ Ecrit directement dans la console
[Link]("Nom : ")
nom = [Link]()
’ Permet de lire la valeur donnée
[Link](vbNewLine + "Prenom : ")
prenom = [Link]()
[Link](vbNewLine + "Role (0 Stagiaire | 1 Manager) : ")
role = [Link]()
requete = "INSERT INTO Employe VALUES(@nom, '" + prenom + "'," + role +
")"
Dim param As SqlParameter = New SqlParameter("@nom",
nom) ’ Permet de paramétrer "nom"
[Link](param)
’ Ajoute le paramètre param à la collection Parameters
[Link] = requete

[Link]()
Dim nbrEnregistrementAffecte As String =
[Link]().ToString()
[Link](vbNewLine + nom + " " + prenom + " " + role + " a ete
ajoute.")
[Link]("Il y a " + nbrEnregistrementAffecte + "
enregistrement(s) affecte par la requete")

Page 27 sur 46
 BASE DE DONNÉES ([Link])

//C#

SqlConnection connexion = new SqlConnection(@"Data

Source=.\SQLServeur;Initial Catalog=DotNetFrance;Integrated
Security=True");
SqlCommand command = [Link]();
string nom, prenom, requete;
int role;

[Link]("Entrez les données suivantes :\n");

// Ecrit directement dans la console
[Link]("Nom : ");
nom = [Link]();
// Permet de lire la valeur donnée
[Link]("\nPrenom : ");
prenom = [Link]();
[Link]("\nRole (0 Stagiaire | 1 Manager) : ");
role = [Link]([Link]());
requete = "INSERT INTO Employe VALUES(@nom, '" + prenom + "'," + role +
")";
SqlParameter param = new SqlParameter("@nom", nom);
// Permet de paramétrer "nom"
[Link](param);
// Ajoute le paramètre param à la collection Parameters
[Link] = requete;

[Link]();
int nbrEnregistrementAffecte = [Link]();
[Link]("\n" + nom + " " + prenom + " " + role + " a ete
ajoute.");
[Link]("Il y a " + nbrEnregistrementAffecte + "
enregistrement(s) affecte par la requete");

Remarque: Vous pouvez aussi ajouter des paramètres àvos Command Object ensaisissant
la méthode GetCostCommand.

Page 28 sur 46
 BASE DE DONNÉES ([Link])

4.6 Les BLOBs

Les BLOBs dans unebase dedonnées nesontpas desimples données detypeschaines de caractères, ce sont des
les types dedonnéesbinaires du type graphiques, photos, documents enregistrés en format binaire ou bien des
exécutables (ils peuvent contenir tous les types), par conséquence leur utilisation est plus complexe.
La taille d’un BLOB peut dépasser plusieurs Go et par conséquence peut nuire aux performances au moment
d’un chargement. En revanche le .NET Framework fournit des classes permettant le déplacement de grosses
quantités de données binaires. Ces classes (comme BinaryReader ou BinaryWriter) se trouvent dans l’espace
de nom [Link].

4.7 Le DataReader

Le DataReader permet un accès en lecture seule à des enregistrements, c'est-à-dire qu’il est impossible de
revenir en arrière sur les enregistrements lus. Il n’a été créé que pour la lecture pure et simple de données. Le
DataReader doit toujours être associé à une connexion active, c'est-à-dire qu’il ne peut pas se déconnecter,
effectuer quelque chose puis se reconnecter pour une mise à jour.
Il existe plusieurs Datareader suivant le fournisseur utilisé, par exemple nous avons SqlDataReader ou encore
OracleDataReader.
Le DataReader comprend plusieurs méthodes : GetBytes, GetChars ou [Link] servent pour les
données caractères ; GetBytes et GetChars permettent de retourner une valeur de type long, qui représente le
nombre de caractères ou d’octets retournés.

4.8 Copier un grand nombre de données

Pour copier un grand nombre de données vers une table de données de façon performante (c'est-à-dire sans trop
utiliser de ressources et de temps) il existe deux applications :

 Le Framework .NET qui propose dans le namespace [Link]

l’objet SqlBulkCopy.

 SQL Server qui propose la requête BULK INSERT SQL.

Ces solutions permettent dans la majorité des cas de rendre plusperformant le transfert.

Page 29 sur 46
 BASE DE DONNÉES ([Link])

4.9 Les transactions

Les transactions permettent de regrouper des commandes SQL dans une même entité. La transaction permettra
que si une des commandes échoue alors l’opération sera arrêtée et la base de données retrouvera son état initial.
Pour créer une transaction, il suffit d’instancier votre Transaction puis de l’assigner en appelant la méthode
BeginTransaction à la connexion. Voici un exemple de création d’une transaction :

De plus les transactions reposent sur le principe de quatre caractéristiques appelé ACID qui
apporte plus de clarté sur la définition d’une transaction :

- Atomicité, qui signifie que la mise à jour de la basededonnéesdoitêtre totale ou

nulle, c’est le principe du “tout ou rien”.

- Cohérence, qui indique que les modifications apportées doivent être valides.

- Isolation, qui définit que les transactions lancées au même moment ne doivent pas
s’interférer entre elles.

- Durabilité, quiassure quetoutes les transactionssont lancéesde manière définitive.

Les transactions sont managées au niveau de la connexion. Par conséquent nous pourrons commencer une
transaction en ouvrant une connexion avec une base de données pour ensuite commencer les transactions en
appelant la méthode BeginTransaction issues d’une instancede la classe SqlTransaction. Puis vous devez
définirquelle commande nécessite une transaction. Enfin à la fin du traitement des données vous avez la
possibilité

Page 30 sur 46
 BASE DE DONNÉES ([Link])

soit de valider vos transactions grâce à la méthode Commit soit de les annuler grâce à la
méthode Rollback.

4.9.1 Niveau d’isolations destransactions

Lesniveaux d’isolationvous permettent degérer les problèmes d’intégrité des

données ainsi que des accès simultanés à celles-ci par le biais des transactions. Vous
trouverez ci-dessous lalistedes propriétés IsolationLevel associés àl’objet Transaction :

Nom Description

Les modifications en attente de transactions très isolés ne

Chaos
peuvent être écrasées.

Les verrouillages partagés sont maintenus pendant que les

données sonten lecture pour éviter tout défaut, mais les
ReadCommitted
données sont modifiables durant la transaction, entrainant une
lecture non répétable ou des données “fantôme”.

Iln’yapas de verrouillage entrainant la possibilité detout

ReadUncommitted
défaut de lecture.

Toutes les données utilisées dans une requête sont

verrouillées. Parconséquenceleslectures nesontpas
RepeatableRead
répétables mais des données “fantôme” peuvent exister et
d’autres utilisateurs ne peuvent mettre à jour les données.

Les verrouillages sont placés sur toutes les données qui sont
Serializable utilisées dans une requête, ce qui empêche d’autres utilisateurs
de mettre à jour les données.

Réduit le blocage par le stockage de données qu’une seul

application peut lire pendant qu’une autre est train de les
Snapshot
modifier. Cela indique que d’une seule transaction vous ne
pouvez voir les modifications faites dans d’autres transactions.

Page 31 sur 46
 BASE DE DONNÉES ([Link])
Aucun niveau ne peut être déterminé. Ainsi si le niveau
d’isolation est définit sur celui-ci alors la transaction exécute
Unspecified
selon le niveau d’isolation par défaut du sous-jacent du type de
base de données.

Page 32 sur 46
 BASE DE DONNÉES ([Link])

4.9.2 Les transactions Distribuées

En plus de créer des nouvelles transactions et de définir des niveaux d’isolation de celles-ci, vous pouvez
configurez votre connexion pour l’engager dans une transaction distribuée. Une transaction distribuée est une
transaction qui s’étend sur de nombreuses ressources, telles que de multiples bases de données SQL.

Exemple de mise en place d’une transaction distribuée :

Page 33 sur 46
 BASE DE DONNÉES ([Link])

5 Mode déconnecté

5.1 Le DataSet

Le DataSet est stocké dans l’espace de nom [Link]. C’est un cache de données en mémoire, c'est-à-dire
qu’il permet de stocker temporairement des données utilisées dans votre application. Le DataSet contient la
collection d’objets DataTable qui peuvent être liés avec les objets DataRelation. Dans le cas du mode
déconnecté, cet objet va nous permettre d'importer la partie désirée de la base dedonnées (fonction de la
requêtede sélection) en local. Ainsi grâce àdesobjetsnécessaire à la connexion classique (commande select,
connections string...) et un DataAdapter, nous pourrons relier ("Binder") un DataSet sur une base dedonnée (en
lecture etenécriture grâcea uneméthode demise a jour de la base de donnée).

Grâce au mot clé foreach, on peut parcourir des DataSet ou les requêter en Linq. La création d’un

DataSet peut se faire via plusieurs méthodes :

 On peut le créer par programmation en créant des objets DataTable, DataRelation (facultatif). Il
suffit ensuite de remplir la ou les base(s) de données.

Vous pouvez aussi utiliser le Designer DataSet et l’assistant de configuration de Data Source afin de
créer unobjet DataSet. Pour cela vous devez mettre en place le processus de connexion
àdesdonnéesen sélectionnant unebase dedonnées disponible, quipermettra demettreenplace
un DataSet typé. Ainsi celagénéra le code nécessaire pour cette création.

Vouspouvezaussiglisserdirectement unDataSetdepuislaToolboxsurvotreForm
(cas pour le WinForm)

Page 34 sur 46
 BASE DE DONNÉES ([Link])

Il existe deux types de DataSet :

 Typed DataSet : Cela permet de créer une instance d’une classe DataSet déjà typée dans
votre projet.

 Untyped Dataset : Cela permet de créer une instance d’une classe DataSet non-typé de la
[Link].

Voici les éléments d’un DataSet :

Objet Description

DataTable Correspond à une table. Contient une collection de DataColumn

et de DataRow.

DataColumn Représente une colonne de la table.

DataRow Correspond à un enregistrement de la table.

5.2 Configurer un DataSet

5.2.1 Créer un DataSet

Pour créer un DataSet, il faut en premier lieu les instancier (vous pouvez aussi définir
leur nom) :

5.2.2 Ajouter des DataTable

Page 35 sur 46
 BASE DE DONNÉES ([Link])
Après avoir créé votre DataSet, vous pouvez lui ajouter des DataTable comme ceci :

Page 36 sur 46
 BASE DE DONNÉES ([Link])

5.2.3 Le DataRelation

L’objet DataRelation représente le lien entre plusieurs tables. Dans un DataSet, il permet la
relation entre les colonnes de plusieurs DataTable. Par exemple, nous pouvons lier les colonnes ID et
Role de nos tables Employe et Role :

Ensuite, grâce à cette relation, vouspouvez naviguer entre les colonnes de vos tables. Le
DataRow propose deux méthodes : le GetParentRow et le GetChildRows :

Méthode Description

GetParentRows Permet d’obtenir les lignes parentes d’un

DataRow attaché à un DataRelation.

GetChildRows Permet d’obtenir les lignes enfants d’un

DataRow attaché à un DataRelation.

Parexemple, nouspouvons afficher les IDdenotre précédente relation « EmployeRole »:

Page 37 sur 46
BASE DE DONNÉES ([Link])

Page 38 sur 46
 BASE DE DONNÉES ([Link])

5.2.4 Fusionner deux DataSet

La méthode Merge permet de fusionner deux DataSet entre eux. On prend un DataSet
source qu’on fusionne avec un DataSet ciblé. Pour des tables identiques, ce sont les données
duDataSetsourcequiremplacerontlesdonnéesduDataSetciblé.Lorsqu’ils’agitdedeux
DataSet différents, vous pouvez paramétrer la méthode Merge avec la propriété
MissingSchemaAction. Voici les différentes valeurs de ce paramètre :

Valeur Description

Add Permet d’ajouter les objets contenus dans le

DataSet source dans le DataSet ciblé.

AddWithKey Permet d’ajouter les objets contenus dans le

DataSet source dans le DataSet ciblé avec
les clés primaires.

Error Une exception sera levée si le mappage

d’une colonne dans les DataSet source et
ciblé estmanquante.

Ignore Toutes les colonnes du DataSet source

supplémentaire sont ignorées.

5.2.5 Copier un DataSet

Vous pouvez par exemple vouloir modifier pour une série de test un DataSet. Pour cela, il est
très simple de copier un DataSet. Il suffit d’utiliser la méthode Copy :

Page 39 sur 46
 BASE DE DONNÉES ([Link])

5.3 Configurer une DataTable

5.3.1 Créer des colonnes contenant des expressions

Dansunebase de données, vous pouvez avoir besoin decréer des colonnes contenant
desexpressions. Ceci fonctionneun peu comme avec untableau Microsoft Excel, vous
pouvezcréerdesexpressionsdansunecolonnequipermetdecalculerunesomme,une
multiplication ou autre plus complexe. Il existe pour cela l’objet Expression :

Remarque : Si vous gérez des nombres à virgules, changez le paramètre Decimal en Double.

5.3.2 L’incrémentation dans une DataTable

L’auto-incrémentation est le fait d’incrémenter (augmenter) un nombre. On peut

l’incrémenter avec un nombre positif ou un nombre négatif. L’incrémentation se fait sur une
[Link] incrémenter, il faut mettre à True la propriété AutoIncrement. Lapropriété
AutoIncrementSeed définit le nombre de départet AutoIncrementStep défini le pas de
l’incrémentation (c’est celui qui peut être positif ou négatif).

Page 40 sur 46
 BASE DE DONNÉES ([Link])

5.3.3 Les contraintes dans uneDataTable

Une DataTable, à l'image des contraintes dans les bases dedonnées relationnelles, peut
également avoir des contraintes appliquées à certaines de ses colonnes.

Rappel : En SQL, une clé primaire permet d’identifier de manière unique chaque ligne d’une
table. Les champs associés à une clé primaire ont une valeur unique dans une table. Une clé
étrangère permet defaire une référence vers une autre colonne de la table ou vers une
autre table, possédant obligatoirement une clé primaire. Par exemple cette base de
données :

Il existe les mêmes deux types de clés : les clés étrangères et les clés primaires.

 Les clés primaires : Pour installer une clé primaire à une valeur unique, il suffit de
créer l’instancedelaclasse UniqueConstraint etd’assigner lacolonne avec lavaleur
unique au constructeur.

 Les clés étrangères : Afin d’ajouter une clé à une ou plusieurs colonnes voir plusieurs
tables parents aux colonnes enfants il faut faire l’instance de la classe
ForeignKeyConstraint. Cette classe possède les propriétés DeleteRule et UpdateRule
qui permet de définir le comportement. Il en existe quatre valeurs :

Valeur Description

Cascade Les modifications se font sur toutes les lignes liées par la
clé.

None Les modifications ne se font pas sur les lignes liées par la
clé.

SetDefault La valeur par défaut est donnée dans les lignes liées.

SetNull La valeur est modifiée par DBNull.

Page 41 sur 46
 BASE DE DONNÉES ([Link])

5.4 Le DataAdapter

L’objet DataAdapter permet de relier un DataSet à une base de données. En revanche

le DataAdapter change suivant le fournisseur, c'est-à-dire, par exemple, pour une base de
donnéesSQL,ce sera SqlDataAdapter. C’est grâceà celaque votre applicationpourra
communiquer avec la base de données et par exemple mettre à jour celle-ci.

5.4.1 Créer un DataAdapter

Pour créer un DataAdapter, il faut tout d’abord instancier celui correspondant à votre
fournisseur. Il a besoin d’une commande pour fonctionner. Par exemple :

5.4.2 Créer des commandes pour un DataAdapter

Il est possible d’ajouter plusieurs commandes à un DataAdapter. Pour cela, il suffit de

créer votre commande puis de l’ajouter à votre DataAdapter. Par exemple, voici une
commande associée àun DataAdapter permettant de modifier le prénom de la table
Employe :

Page 42 sur 46
BASE DE DONNÉES ([Link])

Page 43 sur 46
 BASE DE DONNÉES ([Link])

5.4.3 Le MissingMappingAction

Cette propriété permetde régler certains conflits entre un DataSet etune base de
données. En effet des conflits peuvent arriver si on tente par exemple de remplir un DataSet
(avec une base de données) dans lequel il manque soit des colonnes ou des tables.

L’énumération MissingMappingAction possède ces valeurs possibles :

Valeur Description

Error Permetdeleverl’exception InvalidOperationException si une

colonne estmanquante.

Ignore Permet de retourner une valeur NULL si une table ou une

colonne estmanquante.

Passthrough Permet de créer la colonne et/ou la table manquante.

5.4.4 Le MissingSchemaAction

Cette propriété permet aussi de régler les conflits entre un DataSet et une base de données.
Il permet de spécifier où et comment ajouter des données dans des DataTable et
DataColumn manquante. Voici les valeurs de l’énumération MissingMappingAction :

Valeur Description

Add Permet de créer la colonne et/ou la table manquante.

AddWithKey Permet d’ajouter les clés nécessaires aux colonnes.

Error Permetdeleverl’exception InvalidOperationException si une

colonne estmanquante.

Ignore Permet d’ignorer les colonnes en trop.

Page 44 sur 46
 BASE DE DONNÉES ([Link])

5.5 Gérer une DataTable

5.5.1 Ajouter des données

Afin d’ajouter des données dans une DataTable, il faut tout d’abord créer un nouveau
DataRow. Après avoir créé votre ligne, vous pouvez y ajouter vos valeurs. Par exemple, nous
pouvons ajouter un nouvel utilisateur à notre base de données avec un ID, Nom, Prenom et
le role :

5.5.2 Gérer des données

Vouspouvezaussi éditerousupprimer desdonnéesdans votre DataTable comme ceci :

Langage Modifier Supprimer

C# MaLigne ["ID"] = "Numero" ; [Link]() ;

VB MaLigne ("ID") = "Numero" [Link]

Le RowState vous permet de gérer le statut d’une ligne. Par défaut, il se trouve sur
Unchanged. Voici les valeurs possibles de cette énumération :

Valeur Description

Added Permet à la ligne de s’ajouter dans la collection

DataRowCollection.

Deleted Permet desupprimer la ligne enutilisant laméthode Deletede

DataRow.

Detached Permet de créer la ligne sans qu’elle n’appartienne à la

collection DataRowCollection.

Page 45 sur 46
 BASE DE DONNÉES ([Link])

Modified Permet de modifier la ligne.

Unchanged Permet de ne pas modifier la ligne.

5.5.3 Les évènements d’une DataTable

La DataTable possède ses propres évènements :

Evènement Description

ColumnChanged Sedéclenche lorsqu’une valeur aété

changéedansunDataRowd’une
DataColumn.

ColumnChanging Se déclenche lorsqu’une valeur est en train

d’être changéedansunDataRowd’une
DataColumn.

Disposed Est appelée lorsque la méthode Dispose est

appelée.

Initialized Sedéclenche après quela DataTable soit

initialisée.

RowChanged Se déclenche lorsqu’un DataRow a bien été

modifié.

RowChanging Se déclenche lorsqu’un DataRow est en

modification.

RowDeleted Se déclenche lorsque qu’une ligne a été

supprimée.

RowDeleting Sedéclenche lorsque qu’une ligneest

entrain d’êtresupprimée.

TableCleared Sedéclenche quand une DataTable aété

vidée.

TableClearing Se déclenche quand une DataTable se vide.

TableNewRow Se déclenche lorsqu’un DataRow est ajouté.

Page 46 sur 46
 BASE DE DONNÉES ([Link])

5.6 Le DataView

Un DataView permet d’avoir une « vue » d’une DataTable. Cela permet aussi de
pouvoir la trier, la modifier. La fonction principale de cet objetestde relier unebase de
données aux applications WinForm et WebForm.

5.6.1 Créer un DataView

Afin decréer un DataView, il suffit de créerl’instance de celle-ci etd’yplacer le nom

de la DataTable souhaitée. Par exemple :

5.6.2 Gérer un DataView

La propriété Sort du DataView permet de le trier. On peut le trier de deux façons : ASC
(croissant) et DESC(décroissant). Lafaçon croissante est par défaut utilisée par le DataView.

Le DataRowView permet de modifier les lignes d’une table. Par exemple :

Page 47 sur 46
 BASE DE DONNÉES ([Link])

L’évènement principal d’un DataView est le ListChanged. Cet évènement se déclenche

lorsque qu’il ya un changement dansune DataTable ou DataRelation relié à ce DataView.

5.7 Exemples

5.7.1 Remplissage automatique / Lecture de données

‘VB

Dim requete, connexionString As String

connexionString = "Data Source=.\SQLServeur;Initial Catalog=DotNetFrance;Integrated
Security=true;"
requete = "SELECT * FROM Employe"

Dim ds As DataSet = New DataSet()

Dim da As IDbDataAdapter = New SqlDataAdapter()

Dim connexion As IDbConnection = New SqlConnection(connexionString)

Dim commande As IDbCommand = [Link]()
[Link] = requete
' On choisit la commande qui sera exécuté par le DataAdapter et on rempli le
DataSet
[Link] = commande
[Link](ds)

'Affichage du DataSet
[Link]("Nom de la table : {0} | Il possède {1}
enregistrement(s)" + vbNewLine + vbNewLine + vbNewLine, [Link](0),
[Link]("Table").[Link]) 'On affiche les informations que l’on tire
du DataSet

For Each colonne As DataColumn In [Link](0).Columns 'Affichage des noms des

colonnes
[Link]([Link] + vbTab)
Next
[Link](vbNewLine + vbNewLine)

For Each ligne As DataRow In [Link](0).Rows 'Afichage des enregistrements

Page 48 sur 46
BASE DE DONNÉES ([Link])

Page 49 sur 46
 BASE DE DONNÉES ([Link])

5.7.2 Remplissage manuel duDataSet

‘VB

Module Module1
Sub Main()
Dim ds As DataSet = New DataSet("Dotnet-France")
Dim stagiaires As DataTable = New DataTable("Stagiaires")
' cette table contient trois champs à renseigner pour chaque enregistrement
[Link]("ID", GetType(Integer) ' l'id
[Link]("Nom", GetType(String)) ' le nom
[Link]("Description", GetType(String)) ' description
' méthode du dictionnaire
Dim dnom As Dictionary(Of String, String)= New Dictionary(Of String,
String)()
[Link]("Cédric", "Stagiaire")
[Link]("Christophe", " Stagiaire ") ' pour chaque paire
d'éléments nous allons ajouter des enregistrements
For Each elem As KeyValuePair(Of String, String) In dnom
[Link]([Link], [Link], [Link])
Next
' des listes
Dim nom() As String = {"Jérémy", "Cédric"}
Dim desc As String() = {"Manager ", "Manager"} ' s'il y a beaucoup
de champs pour des raisons de lisibilités il peut etre préférable
' de ranger chaque liste dans un Dictionary<string,List<string>>
For i = 0 To [Link] - 1 Step 1
[Link]([Link], nom(i), desc(i))
Next
' et comme vous l'aurez compris :remplissage brut
' (s'il n'y a que très peut d'entrée peut etre une bonne solution)
[Link]([Link], "Paul", "Stagiaire")
[Link]([Link], "Quentin", "Stagiaire")
' on peut ranger notre table dans notre DataSet
[Link](stagiaires)
' donc nous allons afficher pour prouver le fonctionnement
' les données dans un terminal
For Each row As DataRow In [Link]("stagiaires").Rows
For Each col As DataColumn In [Link]
[Link]([Link]([Link]).ToString() + vbTab)
Next
' retour à la ligne entre chaque enregistrement.
[Link]()
Next
[Link]()
End Sub

Public Class Class1

' on crée une valeur id avec acesseur pour l'auto incrementation
Private Shared _stagiaireid As Int32 = 0
Public Shared ReadOnly Property StagiaireID() As Int32
Get
_stagiaireid += 1
Return _stagiaireid
End Get
End Property
End Class
End Module

Page 50 sur 46
 BASE DE DONNÉES ([Link])

//C#

class MainClass
{
public static void afficheTable(DataSet ds, string tableName)
{
foreach (DataColumn col in [Link][tableName].Columns)
{
[Link]([Link] + "\t");
}
[Link]();
foreach (DataRow row in [Link][tableName].Rows)
{
foreach (DataColumn col in [Link][tableName].Columns)
{
[Link](row[[Link]].ToString() + "\t");
}
[Link]();
}
[Link]("\n");
}
private static int _stagiaireid = 0;
public static int StagiaireID { get { return _stagiaireid++; } }

public static void Main(string[] args)

{
DataSet ds = new DataSet("dotnet-france");
DataTable stagiaires = new DataTable("stagiaires");
// cette table contient trois champs à renseigner pour
// chaque enregistrement l'id, le nom et la description
[Link]("id", typeof(int));
[Link]("nom ", "text".GetType());
[Link]("description", typeof(string));
// Rangement dans une collection générique
Dictionary<string, string> dnom = new Dictionary<string, string>();
[Link]("Cédric", "Stagiaire");
[Link]("Christophe", "Stagiaire");

foreach (KeyValuePair<string, string> elem in dnom)

{
[Link](StagiaireID, [Link], [Link]);
}

// dans des listes

string[] nom = { "Jérémy", "Cédric" };
string[] desc = { "Manager", "Manager" };

for (int i = 0; i < [Link]; i++)

{
[Link](StagiaireID, nom[i], desc[i]);
}

// remplissage brut
[Link](StagiaireID, "Paul", "Stagiaire");
[Link](StagiaireID, "Quentin", "Stagiaire");

[Link](stagiaires);

afficheTable(ds, "stagiaires");
}
}

Page 51 sur 46
 BASE DE DONNÉES ([Link])

6 Conclusion

Vous avez terminé ce chapitre sur la gestion de bases de données avec [Link].
Comme vous avez pu le constater, le mode connecté et déconnecté ont chacun des utilités ainsi
qu’une utilisation différentes.

Page 52 sur 46