ADO.NET

10/02/2012
M19 : Programmation Cl/Sr

ADO.Net / C#
Formateur : Driouch B.
(cfmoti.driouch@gmail.com)
Etablissement : OFPPT/GC/CFMOTI
Année Scolaire : 2011/2012 (10/02/2012
(10/02/2012))
http://www.ista--ntic.net
http://www.ista ntic.net//
DRIOUCH B. www.ista--ntic.net
www.ista 1
Plan du Cours
Définition (Généralité, Architecture N-
N-tier
tier))
Framework .Net / ADO.Net
Connexion à une BD (Connection
(Connection))
Mode Connecté (Commad
(Commad,, DataReader)
DataReader)
Mode Déconnecté (DataSet
(DataSet,, DataAdapter)
DataAdapter)
Mode Déconnecté (DataTable
(DataTable,, DataColumns,
DataColumns,
DataRows,, DataRelation,
DataRows DataRelation, DataView)
DataView)
Contrôle utilisateur
Utilisation Procédure Stocker et Transaction
DataSet Typé (fichier XSD)
Édition des états (CrystalReport
(CrystalReport))
Déploiement
www.ista 2
http://www.ista-ntic.net/ 1
10/02/2012
Présentation
De nombreuses applications fonctionnent selon un
environnement client/serveur, cela signifie que des machines
clientes contactent un serveur
serveur,, une machine généralement très
puissante en terme de capacités d'entrée
d'entrée--sortie, qui leur fournit
des services
services.. Ces services sont des programmes fournissant des
données telles que l'heure, des fichiers, une connexion,
connexion,… …
Les services sont exploités par des programmes, appelés
programmes clients,
clients, s'exécutant sur les machines clientes
clientes.. On
parle ainsi de client FTP, client de messagerie, ... ...,, lorsque l'on
désigne un programme, tournant sur une machine cliente,
capable de traiter des informations qu'il récupère auprès du
serveur (dans le cas du client FTP il s'agit de fichiers, tandis que
pour le client messagerie il s'agit de courrier électronique)
électronique)..
www.ista 3
Avantages / Inconvénients
Le modèle client/serveur est particulièrement
recommandé pour des réseaux nécessitant un grand
niveau de fiabilité, ses principaux atouts sont:
• des ressources centralisées
• une meilleure sécurité
• une administration au niveau serveur
• un réseau évolutif
L'architecture client/serveur a tout de même quelques
lacunes parmi lesquelles:
• un coût élevé
• une maillon faible
www.ista 4
10/02/2012
Fonctionnement
Un système client/serveur fonctionne selon le
schéma suivant:
Le client émet une requête vers le serveur

grâce à son adresse et le port,
port, qui désigne un
service particulier du serveur
Le serveur reçoit la demande et répond à l'aide
de l'adresse de la machine client et son port
www.ista 5
Architecture à 2 et 3 niveaux
L'architecture à deux niveaux

caractérise les systèmes
clients/serveurs dans lesquels le
client demande une ressource et le
serveur la lui fournit directement.
directement.
Dans l'architecture à 3 niveaux (appelées architecture 3-

tier),
tier), il existe un niveau intermédiaire, c'est
c'est--à-dire que l'on
a généralement une architecture partagée entre:
entre:
• Le client
client:: le demandeur de ressources
• Le serveur d'application (appelé aussi middleware
middleware)):
le serveur chargé de fournir la ressource mais faisant
appel à un autre serveur
• Le serveur secondaire (généralement un serveur de
base de données), fournissant un service au premier
serveur
www.ista 6
10/02/2012
Architecture multi-
multi-niveaux
Dans l'architecture à 3
niveaux, chaque serveur
(niveaux 1 et 2) effectue une
tâche (un service) spécialisée.
spécialisée.
Ainsi, un serveur peut utiliser
les services d'un ou plusieurs
autres serveurs afin de fournir
son propre service.
service. Par
conséquence, l'architecture à
trois niveaux est
potentiellement une
architecture à N niveaux...
niveaux...
www.ista 7
Framework Dotnet
.NET est une plate forme complète pour développer, déployer et exécuter
des applications Web, Windows, Mobiles et serveur
serveur.. La plate forme repose
sur la notion de framework qui est un cadre de travail offrant des outils et
spécifications nécessaires pour développer et déployer des applications
applications..
Le Framework .NET est conçu pour remplir les objectifs suivants :

• Fournir un environnement cohérent de programmation orientée objet que le
code objet soit stocké et exécuté localement, exécuté localement mais distribué
sur Internet ou exécuté à distance
distance..
• Fournir un environnement d'exécution de code qui minimise le déploiement de
logiciels..
logiciels
• Fournir au développeur un environnement cohérent entre une grande variété de
types d'applications comme les applications Windows et les applications Web
Web..
• Générer toutes les communications à partir des normes d'industries pour
s'assurer que le code basé sur le Framework .NET peut s'intégrer à n'importe
quel autre code
code..
www.ista 8
10/02/2012
Composants de .Net
Le CLR (Common language Runtime) : il représente la machine virtuelle
de la plate forme (un peu comme la JVM pour java).java). Il est responsable de
l’exécution des applications et gère tous les aspects de sécurité : le garbage
Collector, la gestion des événements etc
etc..
Un ensemble de librairie de classes : située au dessus de la CLR, cette
rubrique offre une couche pour la gestion des données
données.. On y retrouve les
Windows Forms (WinForms), ensemble de classes permettant la
conception d’IHM pour Windows (un peu comme AWT ou Swing). Swing).
Adonet (Data and xml):
xml): une nouvelle génération de composants d'accès aux
bases de données
Nous avons ASP
ASP..NET qui fournit un ensemble de classe pour la conception
de site dynamique, la création d’IHM pour le web, les WebForms et la
conception de services web.
web.
Au sommet de la pile nous avons les langages supportés par .NET tels C#,
VB
VB..NET, C++, J# qui sont des produits de Microsoft et d’autres tels que
Cobol, Delphi, etc
etc…… ; .NET offre ainsi un choix de langage contrairement
à son concurrent J2EE.
EE.
www.ista 9
Composants de .Net
www.ista 10
10/02/2012
ADO.Net
Que nous apporte ADO .NET ?
Une architecture plus optimisée
optimisée:: Avec .Net, de nouveaux
fournisseurs de données voient le jour
jour.. Par exemple le .NET
Framework comprend le fournisseur de données SQL Server
.NET en mode natif via le namespace System
System..Data
Data..SqlClient
SqlClient..
Un meilleur support du mode déconnecté : Aujourd'hui
Microsoft encourage le mode déconnecté et propose des
classes spécialisées supportant les deux modes : connecté (via
l'objet DataReader) et déconnecté (via l'objet DataSet)
DataSet)..
Un meilleur support de XML : Le XML est utilisé au sein du
Framework .NET comme le standard de description et de
persistance des données.
données.
www.ista 11
Choix d'un fournisseur de

données .NET
Pour pouvoir faire appel aux classes proposées par ADO .Net il est
nécessaire d'inclure une référence à l'espace de noms correspondant
correspondant.. Vous
pouvez soit inclure l'espace System
System..Data soit inclure des classes de cet
espace comme System.
System.Data
Data..OleDb ou System.
System.Data
Data..SqlClient ; tout dépend
de la source de données utilisée
utilisée..
'Inclusion d'un namespace
using System.Data
using System.Data.SqlClient
www.ista 12
10/02/2012
Le modèle objet ADO .NET
www.ista 13
Le modèle objet ADO .NET

Regardons de plus près chacun de ces objets.
www.ista 14
10/02/2012
Connexion à une base de données

Modes de connexion
L’évolutions d’ d’ADO
ADO..Net est plus importante du coté mode
déconnecté afin de soulager d'une part le serveur BD et d'autre
part d'épargner la bande passante, Le mode "déconnecté" permet
au client d'effectuer des fonctions telles que le tri, le filtrage, sans
avoir recours au serveur BD, grâce à une copie locale des
données..
données
L'avantage du mode "déconnecté" sur le mode "connecté" est
évident, ce dernier utilisant une connexion permanente avec la
base de données
données..
Ce qui nous permet d’avoir deux modes de connexion (Mode

connecté et Mode déconnecté)
www.ista 15
Création de la connexion
Pour déplacer des données entre une base de données et votre application,
vous devez disposer d’une connexion préalable à la base de donnéesdonnées.. Pour
créer une connexion à une base de données, vous devez identifier le nom du
serveur de base de données, le nom de la base de données et les informations
de connexion requises
requises..
En fonction du type de base de données à laquelle vous accédez, vous
pouvez utiliser un objet SqlConnection ou OleDbConnection
OleDbConnection.. Utilisez un
objet SqlConnection pour la connexion aux bases de données SQL Server
version 7.0 ou ultérieure et un objet OleDbConnection pour la connexion à
toutes les autres bases de données
données..
Pour créer un objet SqlConnection
SqlConnection,, passez une chaîne de connexion qui
fournit les paramètres requis pour créer une connexion à une source de
données..
données
string strConn = ‘’data source=localhost
source=localhost ; initial catalog=
catalog=GestStg ;
integrated security=true’’;
Sqlconnection conn = New SqlConnection
SqlConnection((strConn);
strConn);
conn.open();
conn.open ();
conn.close();
conn.close ();
www.ista 16
10/02/2012
Création de la connexion
Paramètres de la chaîne de connexion
www.ista 17
Accès aux données en mode

connecté
L’objet Command
Une fois la connexion vers une base de données effectuée, vous
pouvez exécuter une requête et récupérer son résultat en utilisant
l'objet Command
Command.. La création d'un objet Command nécessite
l'instanciation d'un objet SqlCommand
SqlCommand.. Cet objet expose
différentes méthodes Execute à utiliser selon le résultat attendu :
La méthode ExecuteReader peut être utilisée pour récupérer un

jeu d'enregistrements et retourne un objet DataReader
DataReader..
La méthode ExecuteScalar récupère une valeur unitaire.
unitaire.
La méthode ExecuteNonQuery exécute une commande ne
retournant pas de lignes.
lignes. Mais retourne une valeur numérique
indiquant le nombre de ligne affecté.
affecté.
www.ista 18
10/02/2012
Exemple (Command)
using System;
using System.Data
System.Data..SqlClient ;
class Program
{ static void Main(string[] args
args))
{ string str
str="data
="data source=.\
source=.\\SQLExpress;initial catalog=GestStg;integrated
catalog=GestStg;integrated
security=true";
string sql="INSERT
sql="INSERT INTO Matiere VALUES (11,'ADO.Net',3)";
SqlConnection oCon
oCon=new
=new SqlConnection(
SqlConnection(str
str);
);
SqlCommand oComd=new
oComd=new SqlCommand(
SqlCommand(sql,oCon);
sql,oCon);
try
try{
{
oCon.Open();
oCon.Open ();
oComd.ExecuteNonQuery();
oComd.ExecuteNonQuery ();
oCon.Close();
oCon.Close ();
Console.WriteLine(("la
Console.WriteLine (("la commande est bien exécuté"));}
catch(Exception e){
Console.WriteLine(("L'erreur
Console.WriteLine (("L'erreur suivante a été rencontrée :" + e.Message));
e.Message));
}
Console.ReadKey();
Console.ReadKey ();
}
}
www.ista 19
Mode connecté
l’objet DataReader
L'objet DataReader permet de récupérer d'une source de données
un flux en lecture seule en avant seulement (read only, forward
only).. Il résulte de l'exécution de la méthode ExecuteReader
only)
sur un objet Command.
Command.
L'objet DataReader ne stocke en mémoire qu'une seule ligne à la
fois, permettant ainsi d'augmenter les performances d'une
application et d'en réduire la charge
charge..
Il est recommandé d'utiliser cet objet si :
• Vous n'avez pas besoin de réaliser un cache des données
• Vous traitez un jeu d'enregistrements trop important pour être stocké en
mémoire
• Vous souhaitez accéder à des données rapidement en lecture seule en
avant seulement
www.ista 20
10/02/2012
Mode connecté
Par défaut, un DataReader charge une ligne entière en
mémoire à chaque appel de la méthode Read Read.. Il est possible
d'accéder aux valeurs de colonnes soit par leurs noms soit par
leurs références ordinales.
ordinales. Une solution plus performante est
proposée permettant d'accéder aux valeurs dans leurs types de
données natifs (GetInt32
(GetInt32,, GetDouble, GetString) Par exemple
si la première colonne de la ligne indicée par 0 est de type int,
alors il est possible de la récupérer à l'aide de la méthode
GetInt32
GetInt 32 de l'objet DataReader
DataReader..
La méthode Close ferme un objet DataReader
DataReader.. Précisons que
si l'objet Command utilisé contient des paramètres en sortie ou
des valeurs de retours, ils ne pourront être récupérés qu'a
l'issue de la fermeture du DataReader.
DataReader.
www.ista 21
Exemple (DataReader)
//Création de la connexion et de l’objet Command
SqlConnection conn
conn=new
=new SqlConnection("data
SqlConnection("data source=localhost
source=localhost\\SQLExpress ;
integrated security=true ; initial catalog=GestStg
catalog=GestStg");
");
SqlCommand cmdStg = new SqlCommand("select
SqlCommand("select * from Stagiaire",
Stagiaire", conn
conn);
);
conn.Open();
conn.Open ();
//Création d’un DataReader et affichage des données
SqlDataReader dr dr;;
dr
dr==cmdStg.ExecuteReader
cmdStg.ExecuteReader(); ();
while(
while(dr.Read
dr.Read()){
()){
Console.WriteLine((dr
Console.WriteLine dr["nom"]
["nom"] + " - " + dr
dr["moyenne"]);
["moyenne"]);
}
//Fermeture de DataReader et de la connexion
dr.Close();
dr.Close ();
conn.Close();
conn.Close ();
Console.ReadKey();
Console.ReadKey ();
www.ista 22
10/02/2012
Gestion des erreurs

Lors de l’utilisation de connexions avec l’objet DataReader,
DataReader, vous devriez
toujours utiliser une instruction Try…
Try…catch…
catch…Finally pour garantir la
fermeture des connexions en cas d’échec quelconque
quelconque.. Sinon, la connexion
peut demeurer indéfiniment ouverte
ouverte..
Le code suivant d’un objet DataReader intercepte des erreurs et ferme la
connexion
try
try{{
conn.Open();
conn.Open();
dr
dr==cmdStg.ExecuteReader
cmdStg.ExecuteReader();();
//utilisation des données retournées dans les dataReader }
catch (Exception e){
//Gestion de l’erreur }
finally {
//Fermeture de DataReader et de la connexion
dr.Close();
dr.Close ();
conn.Close();
conn.Close (); }
www.ista 23
Utilisation ComboBox
try
{
oCon.Open();
oCon.Open ();
oComd.CommandText = "Select idstg,nom from stagiaire";
oRdr = GLB.oComd.ExecuteReader();
GLB.oComd.ExecuteReader();
while (oRdr.Read
oRdr.Read())
())
{
comboBox1.Items.Add
comboBox1. Items.Add((oRdr["
oRdr["idstg
idstg"]);
"]);
}
oRdr.Close();
oRdr.Close ();
}
catch (Exception e1)
{
MessageBox.Show("Erreur
MessageBox.Show ("Erreur : " + e1.Message);
}
finally {
if ((oCon.State
oCon.State == ConnectionState.Open)
ConnectionState.Open) oCon.Close();
oCon.Close();
}
www.ista 24
10/02/2012
Utilisation DataGridView
try {
GLB.oCon.Open();
GLB.oCon.Open ();
GLB.oComd.CommandText = "Select m.idmat,libelle,coeff,note from note n inner join matiere m on
n.idmat=
n.idmat=m.idmat where idstg="
idstg=" + comboBox1.SelectedItem.ToString
comboBox1.SelectedItem.ToString(); ();
GLB.oRdr = GLB.oComd.ExecuteReader();
GLB.oComd.ExecuteReader();
dataGridView1.Columns.Clear
dataGridView1. Columns.Clear();();
dataGridView1.Rows.Clear
dataGridView1. Rows.Clear();
();
dataGridView1.Columns.Add
dataGridView1. Columns.Add(" ("id","ID
id","ID");
");
dataGridView1. Columns.Add(" ("libelle","Matiere
libelle","Matiere");
");
dataGridView1. Columns.Add(" ("coeff
coeff","Coefficient");
","Coefficient");
dataGridView1. Columns.Add(" ("note","Note
note","Note");
");
while (GLB.oRdr.Read
GLB.oRdr.Read())
())
{dataGridView1.Rows.Add
{dataGridView1. Rows.Add((GLB.oRdr
GLB.oRdr[" ["idmat
idmat"],
"], GLB.oRdr["libelle"],
GLB.oRdr["libelle"], GLB.oRdr
GLB.oRdr["
["coeff
coeff"],
"], GLB.oRdr["note"]);
GLB.oRdr["note"]);
}
GLB.oRdr.Close();
GLB.oRdr.Close ();
}
catch (Exception e2){
MessageBox.Show("Erreur
MessageBox.Show ("Erreur : " + e2.Message);
}
Finally {
if ((GLB.oCon.State
GLB.oCon.State == ConnectionState.Open)
ConnectionState.Open) GLB.oCon.Close();
GLB.oCon.Close();
}
www.ista 25
Exercice
Réaliser une application avec le schéma relationnel suivant
Stagiaire (IdStg
(IdStg,, nom, prenom,
prenom, DateN,
DateN, Groupe, moyenne)
Matiere (IdMat,
IdMat, Libelle, Coeff)
Coeff)
Note (IdStg
(IdStg,, IdMat,
IdMat, Note)
Et la conception de fenêtre suivant (DataGridview
(DataGridview,, ComboBox)
ComboBox)
Page Accueille
Menu
Liste Stagiaire Liste Module

Supprimer Supprimer
Liste Note/Module
Modifier Ajouter Modifier Ajouter
Supprimer
Ajouter Modifier
www.ista 26
10/02/2012
Mode Déconnecté
DataSet:
L’objet DataSet représente une copie locale des données provenant d’au
moins une source de données.
données. L’objet DataSet peut utiliser un objet
DataAdapter pour charger des données à partir d’une source de données et
peut se déconnecter ensuite de cette dernière.
dernière. L’utilisateur peut ensuite
utiliser et manipuler les données.
données. Lorsque les données doivent être mises à
jour dans la source de données, un objet DataAdapter est utilisé pour se
reconnecter à la source de données et la mettre à jour
jour..
www.ista 27
DataSet
La collection "DataTableCollection
"DataTableCollection""
Cette collection peut contenir de zéro à n objets de type DataTable.
DataTable. Chaque
objet DataTable représente une table d'une source de données. données. Chaque
DataTable est constituée d'une collection Columns et d'une collection Rows
qui peuvent contenir respectivement de zéro à n objets DataRow et
DataColumn..
DataColumn
La collection "DataRelationCollection
"DataRelationCollection""
Cette collection peut contenir de zéro à n objets de type DataRelation.
DataRelation. Un
objet DataRelation définit une relation parent-
parent-enfant entre deux tables à
partir des valeurs des clés étrangères.
étrangères.
La collection "ExtendedProperties
"ExtendedProperties""
Cette collection correspond à un objet de type PropertyCollection qui peut
contenir de zéro à n propriétés définies par un utilisateur.
utilisateur. Cette collection
peut être utilisée afin de stocker des informations personnalisées liées au
DataSet utilisé (date et heure de génération des données, ordre select passé
pour générer les données.
données.).
www.ista 28
10/02/2012
DataAdapter
Un objet DataSet doit être capable d'interagir avec une ou plusieurs sources de
données.. Pour réaliser cette action le framework Microsoft .Net fournit un objet
données
nommé DataAdapter.
DataAdapter. L'objet DataAdapter sert de liaison entre un objet
DataSet et une source de données.
données. Un fournisseur de données .NET va se
servir d'un objet DataAdapter pour remplir de données un DataSet puis
répercuter les modifications réalisées sur une source de données.
données. Il est
possible de définir les actions à réaliser par le DataAdapter en utilisant l'une
des quatre propriétés suivantes.
suivantes. Chaque propriété exécutera soit un ordre SQL
soit une procédure stockée.
stockée.
www.ista 29
Remplissage d'un DataSet

La méthode Fill de l'objet DataAdapter permet d'extraire les données d'une source de
données en exécutant la requête SQL spécifiée dans la propriété SelectCommand.

SelectCommand. Elle
prend en paramètre le DataSet et le nom du DataTable à remplir avec les données
retournées..
retournées
// Création d'un objet SqlDataAdapter
SqlDataAdapter oSqlDataAdapter =new SqlDataAdapter("select
SqlDataAdapter("select * from Stagiaire",
oConnection);
oConnection );
DataSet oDataSet = new DataSet("GestStg");
oSqlDataAdapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
MissingSchemaAction.AddWithKey;
oSqlDataAdapter.Fill((oDataSet,
oSqlDataAdapter.Fill oDataSet, "Stagiaire");
La mise à jour de données avec un DataAdapter et un DataSet :
La méthode Update de l'objet DataAdapter permet de répercuter sur une source de
données les modifications effectuées dans un DataSet.
DataSet. Cette méthode admet un objet
DataSet qui contient les données modifiées et un objet DataTable optionnel qui contient
les modifications à extraire.
extraire.
oSqlDataAdapter..Update(
oSqlDataAdapter Update(oDataSet.
oDataSet.Tables[
Tables["stagiaire
stagiaire""]);
]);
En réalité, lorsque la méthode Update est invoquée l'objet DataAdapter analyse les
modifications effectuées au niveau de la collection DataRow
DataRow.. En fonction des
modifications rencontrées, les commandes InsertCommand,
InsertCommand, UpdateCommand et
DeleteCommand sont appelées par l'objet DataAdapter.
DataAdapter.
www.ista 30
10/02/2012
Création d’un DataSet

Pour créer une copie locale d’une base de données, créez et remplissez un
objet DataSet au moyen d’objets DataTable
DataTable.. Pour créer un objet DataSet,
DataSet,
vous devez d’abord déclarer le nom de l’objet DataSet.
DataSet. Le code suivant crée
un objet DataSet nommé ds : DataSet ds = new DataSet()
DataSet();;
Remplissage du DataSet
Après avoir crée un objet DataSet,
DataSet, remplissez les objets DataTable en créant
un objet DataAdapter.
DataAdapter. Vous pouvez appeler la méthode Fill de l’objet
DataAdapter,, puis préciser l’objet DataTable à remplir.
DataAdapter remplir. Le code suivant
remplit la table Authors (Auteurs) de l’objet DataSet intitulé ds en utilisant un
DataAdapter nommé da : da da..Fill(
Fill(ds,’’Stagiaire’’)
ds,’’Stagiaire’’);;
Accès à un DataTable
chaque objet DataSet se compose d’au moins un objet DataTable que vous
pouvez référencer par nom ou par position ordinale :
ds.Tables[’’Stagiaire’’];
ds.Tables [’’Stagiaire’’];
-Ou
Ou--
ds.Tables[0];
ds.Tables [0];
www.ista 31
CommandBuilder
Après remplissage d’un DataSet avec DataAdapter en utilisant l’objet SelectCommand, on peut
utiliser les donnée pour les traitements de MAJ (Ajouter, Modifier et supprimer), et a la fin des
différent traitements il faut faire appelle une 2eme fois le DataAdapter pour répercuter les
modification du DataSet sur la base de donnée source, qui fait appel au trois autre objet
(InsertCommand, UpdateCommand et DeleteCommand) selon l’etat(ligne Ajouter, Modifier ou
supprimer) de chaque ligne du DataTable utilisé
Pour effectuer cet opération, il faut construire les trois objets (InsertCommand, UpdateCommand et
DeleteCommand), la difficulté de leur construction nous oblige a faire appel a un autre objet
CommandBuilder qui permet leur construction a partir de SelectCommand
Utilisation de CommandBuilder
SqlConnection StgCon = new SqlConnection("Data source=.\SQLExpress; integrated
security=true;initial catalog=GestStg");
SqlDataAdapter StgDA = new SqlDataAdapter("", StgCon);
DataSet StgDS = new DataSet;
SqlCommandBuilder StgCB ;
StgDA.SelectCommand = new SqlCommand("Select idstg,nom,moyenne from stagiaire", StgCon);
StgDA.Fill(StgDS, "stg");
//Modification des donnée dans le DataSet
StgCB = new SqlCommandBuilder(StgDA);
StgDA.Update(StgDS.Tables("stg"));
www.ista 32
10/02/2012
DataRow et DataColumn
Utiliser un objet DataRow et ses propriétés et méthodes pour extraire et
évaluer les valeurs d’un objet DataTable.
DataTable. Le DataRowCollection représente les
objets DataRow réels présents dans l’objet DataColumn qui décrivent le
schéma de l’objet DataTable.
DataTable. La propriété Rows de l’objet DataTable fournit
un accès par programmation au DataRowCollection.
DataRowCollection. La propriété Columns de
l’objet DataTable fournit un accès par programmation au
DataColumnCollection..
DataColumnCollection
DataColumn col;
col;
ForEach (col In ds.Tables[0].Columns){
ds.Tables[0].Columns){
LstItems.Items.Add((col.ColumnName);
LstItems.Items.Add col.ColumnName);
}
le nombre de lignes ou de colonnes d’un objet DataTable
DataTable::
ds.Tables[[’’Stagiaire’’].
ds.Tables ’’Stagiaire’’].Rows.Count
Rows.Count;;
ds.Tables[[’’Stagiaire’’].
ds.Tables ’’Stagiaire’’].Columns.count
Columns.count;;
accéder à ces champs par position ordinale (de base 0) Ou par nom :
DSet.Tables[0].
DSet.Tables [0].Rows
Rows[x][1]
[x][1]
DSet.Tables[0].
DSet.Tables [0].Rows
Rows[x][’’
[x][’’nom_champ
nom_champ’’]’’]
www.ista 33
DataTable (AutoIncrement)
DataTable Matable = new DataTable("stagiaire");
DataTable("stagiaire");
DataColumn MaColonne = new DataColumn("
DataColumn("idstg
idstg",
", Type.GetType("
Type.GetType("System.Int32
System.Int32")
") );
//typeof
//typeof((int));
int)); //Ajout de colonne
MaColonne.Unique = truetrue;;
MaColonne.AutoIncrement = true true;;
MaColonne.AutoIncrementSeed = 1;
MaColonne.AutoIncrementStep = 1;
MaColonne.AllowDBNull = false;
MaColonne.ReadOnly = true true;;
Matable.Columns.Add((MaColonne);
Matable.Columns.Add MaColonne);
MaColonne = new DataColumn("nom",
DataColumn("nom", typeof(string));
typeof(string)); //Ajout de colonne
DataRow MaLigne;
MaLigne; //Ajout de ligne
MaLigne = Matable.NewRow();
Matable.NewRow();
MaLigne["nom"]
MaLigne ["nom"] = "Ali";
Matable.Rows.Add((MaLigne);
Matable.Rows.Add MaLigne);
Matable.NewRow(); //Ajout de ligne
MaLigne["nom"]
MaLigne ["nom"] = "Ahmed";
dataGridView1.DataSource
dataGridView1. DataSource = Matable;
Matable; //affichage dans DataGrid
www.ista 34
10/02/2012
DataRelation
DataSet MonData = new DataSet();
DataSet();
MonData.Tables.Add((Matable);
MonData.Tables.Add Matable); //Définition d'une clé primaire
MonData.Tables["
MonData.Tables ["stagiaire
stagiaire"].
"].PrimaryKey
PrimaryKey = new DataColumn[]
DataColumn[]
{MonData.Tables["
MonData.Tables["stagiaire
stagiaire"].Columns["
"].Columns["idstg
idstg"]
"] };
Matable = new DataTable("note");
DataTable("note");
MaColonne = new DataColumn("
DataColumn("idstg
idstg",
", typeof(
typeof(int));
int));
MaColonne = new DataColumn("note",
DataColumn("note", typeof(float));
typeof(float));
MaLigne["
MaLigne ["idstg
idstg"]
"] = "1";
MaLigne["note"]
MaLigne ["note"] = "12";
MaLigne["
MaLigne ["idstg
idstg"]
"] = "1";
www.ista 35
DataRelation
MaLigne["note"] = "13";
MaLigne["note"]
MonData.Tables.Add((Matable);
MonData.Tables.Add Matable);
DataRelation Relation; // Définition de relation
Relation = new DataRelation("
DataRelation("stgnote
stgnote",
",
MonData.Tables["stagiaire"].
MonData.Tables ["stagiaire"].Columns
Columns["["idstg
idstg"],
"],
MonData.Tables["note"].
MonData.Tables ["note"].Columns
Columns["
["idstg
idstg"]);
"]);
MonData.Relations.Add(Relation);
MonData.Relations.Add (Relation);
DataRow Stgligne;
Stgligne; //utilisation de Relation
DataRow[]
DataRow [] Noteligne;
Noteligne;
Relation = MonData.Tables["stagiaire"].
MonData.Tables["stagiaire"].ChildRelations
ChildRelations["
["stgnote
stgnote"];
"];
Stgligne = MonData.Tables["stagiaire"].
MonData.Tables["stagiaire"].Rows
Rows[0];
[0];
Noteligne = Stgligne.GetChildRows(Relation);
Stgligne.GetChildRows(Relation);
dataGridView1.DataSource
dataGridView1. DataSource = MonData.Tables["stagiaire"];
MonData.Tables["stagiaire"];
dataGrid1.DataSource
dataGrid1. DataSource = MonData.Tables["stagiaire"];
MonData.Tables["stagiaire"];
www.ista 36
10/02/2012
DataView
Représente une vue de DataTable personnalisée pouvant
faire l'objet de liaisons de données pour le tri, la recherche,
la modification et la navigation.
Constructeur DataView(
DataView(DataTable,
DataTable, String, String,
DataViewRowState)) : Initialise une nouvelle instance de la
DataViewRowState
classe DataView avec les DataTable,
DataTable, RowFilter,
RowFilter, Sort et
DataViewRowState spécifiés.
DataView view = new DataView(

DataView(dataSet.Tables["stagiaire"],
dataSet.Tables["stagiaire"], "Nom Like 'A%'",
"nom", DataViewRowState.CurrentRows);
DataViewRowState.CurrentRows);
view.AllowEdit = true
true;;
view.AllowNew = true
true;;
view.AllowDelete = true
true;;
www.ista 37
DataBinding
www.ista 38
10/02/2012
DataSet et XML
XML est une format de source de donnée quand peut utilisé
pour exporter et importer les données d’un DataSet
Si en prend l’exemple cité précédemment, DataSet avec les
deux tables Stagiaire et note:
Enregistrement dans un fichier XML avec le schéma

(structure):
MonData.WriteXml("GestSTG.XML",
MonData.WriteXml ("GestSTG.XML",XmlWriteMode.WriteSchema
XmlWriteMode.WriteSchema );
La Récupération :
MonData = new DataSet();
DataSet(); //DataSet
//DataSet vide
MonData.ReadXml("GestSTG.XML",
MonData.ReadXml ("GestSTG.XML", XmlReadMode.ReadSchema);
XmlReadMode.ReadSchema);
www.ista 39
try
try{{
Gestion Erreur
SqlConnection conn = new SqlConnection("...");
SqlConnection("...");
SqlDataAdapter da = new SqlDataAdapter("...",
SqlDataAdapter("...", conn
conn);
);
DataSet ds = new DataSet();
DataSet();
da.Fill((ds);
da.Fill ds);
}
catch(
catch(SqlException
SqlException ex1){
switch(ex1.
switch(ex1.Number
Number){){
case 17:
LblErrors.Text = lblErrors.Text + "nom de serveur non valide";
case 156, 170: //syntaxe SQL incorrecte
LblErrors.Text = lblErrors.Text + "syntaxe incorrecte";
case 207: //nom de champ incorrect dans select
LblErrors.Text = lblErrors.Text + "nom de colonne non valide";
case 208: //nom de table incorrect dans select
LblErrors.Text = lblErrors.Text + "nom d’objet non valide";
case 18452:
LblErrors.Text = lblErrors.Text + "nom de l’utilisateur non valide";
case 18456:
LblErrors.Text = lblErrors.Text + "mot de passe non valide";
case 4060:
LblErrors.Text = lblErrors.Text + "base de données non valide";
} }
catch(Exception ex2){
LblErrors.Text = lblErrors.Text + "Exception inattendue : " + ex2.Message + " , ";
}
www.ista 40
10/02/2012
Gestion Erreur
L’exemple suivant montre comment parcourir la collection
Errors pour rechercher les détails sur les erreurs SQLServer
survenues :
SqlErrorCollection erData = ex1.Errors

ex1.Errors;;
for(
for(int
int i = 0;i<=erData.Count
0;i<=erData.Count--1;i++){
lbErrors.Text += "Erreur " + i + " : " +
erData(i).
erData (i).Number
Number + " , " +
erData(i).Class
erData (i).Class & " , " +
erData(i).Message;
erData (i).Message;
}
www.ista 41
Exercice
Quel est le résultat du code suivant :
DataRow r;
String str
str;;
ForEach(( r in ds.Tables[‘’
ForEach ds.Tables[‘’Stagiaire
Stagiaire’’].Rows){
’’].Rows){
Str +=r[1];
Str +=r[‘’nom’’];
}
DataTable dt =ds.Tables[‘’
ds.Tables[‘’Stagiaire
Stagiaire’’];
’’];
CBmtr.ValueMember = "idstg
"idstg " ;
CBmtr.DisplayMember = "nom
"nom " ;
CBmtr.DataSource = dt;
Reproduire la Série M22 N1 en mode déconnecté.
www.ista 42
10/02/2012
Contrôle Utilisateur(Composant)
En programmation, le terme composant est généralement utilisé
pour désigner un objet qui est réutilisable et qui peut interagir avec
d'autres objets.
Un composant doit définir des propriétés à la place de champs
publics, car les concepteurs visuels, tels que Visual Studio .NET,
affichent des propriétés et non des champs dans la fenêtre de
propriétés.
Les propriétés sont comme des champs intelligents. Une propriété
possède généralement une donnée membre privée accompagnée de
fonctions d'accesseur et est accédée du point de vue syntaxique
comme un champ d'une classe
Voire Atelier UserControle (Horloge) sur la partie téléchargement
du site :
http://www.ista-ntic.net/ Téléchargement
www.ista 43
Atelier UserContrôle
1- étape lancer VS.net et créer un projet de type "application Windows "
et l'enregistrer sous le nom MonPremierControle Le VS.net crée un formulaire qui va
servir pour tester notre Horloge
2- ajouter un contrôle utilisateur vide
Lui affecter le nom Horloge.cs

Question : quelle est la différence entre les deux classes Form1 et Horloge?
3- créer notre Horloge.
On a besoin de deux contrôles minimum, oui c'est ça un label et un Timer. Ajoutons les
alors. Après nous modifions les propriétés du Timer pour qu'il rafraîchir l'heure chaque
seconde, donc il faut choisir comme intervalle 1000ms (millet seconde) et enabled à
true.
est ce que c'est suffisant? Non, il faut l'activer pour que l'événement Tick se déclenche
chaque intervalle (ici 1000).
Je rappelle que l'événement tick se déclenche chaque 1000 millet seconde. Donc, ajouter
une méthode et l'associer à l'événement tick (vous double cliquez sur le contrôle Timer)
Ajouter le code suivant: Label1.text="il est : " + Date.now;
www.ista 44
10/02/2012
Atelier UserContrôle
4- tester le contrôle.
Pour tester le contrôle, vous devez compiler le projet, et il va créer sur la boite
d'outils votre contrôle Horloge que vous pouvez insérer ensuite dans le formulaire
'Form1'
Afficher le formulaire Form1 et regarder dans la palette des contrôles, est ce que
vous voyez votre contrôle
Ajouter la dans votre formulaire

et exécuter le (optionnel).
www.ista 45
Intégrer les Transactions

Les transactions sont des groupes d'opérations combinées en unités de travail
logiques. Elles sont utilisées pour contrôler et conserver la cohérence et
l'intégrité de chaque action d'une transaction, malgré les éventuelles erreurs
rencontrées sur le système.
Avec un SGBDR qui prend en charge la gestion des transactions vous pouvez
créer des transactions explicites à l'aide d'instructions SQL BEGIN
TRANSACTION, COMMIT TRANSACTION ou ROLLBACK TRANSACTION
Pour effectuer une transaction :
1. Appelez la méthode BeginTransaction de l'objet SqlConnection pour marquer
le début de la transaction. La méthode BeginTransaction retourne une
référence à la transaction.
2. Assignez l'objet Transaction à la propriété Transaction du SqlCommand à
exécuter. Si une commande est exécutée sur une connexion sur laquelle une
transaction est active et si l'objet Transaction n'a pas été affecté à la
propriété Transaction de l'objet Command, une exception est levée.
3. Exécutez les commandes requises.
4. Appelez la méthode Commit de l'objet SqlTransaction pour terminer la
transaction, ou la méthode Rollback pour l'annuler. Si la connexion est fermée
ou libérée avant que l'une des méthodes Commit ou Rollback ait été
exécutée, la transaction est annulée.
www.ista 46
10/02/2012
Intégrer les Transactions (Exp)

SqlConnection connection= new SqlConnection(connectString);
connection.Open();
// Début d’une transaction local.
SqlTransaction sqlTran = connection.BeginTransaction();
// liaison du command avec la transaction courante.
SqlCommand command = connection.CreateCommand();
command.Transaction =sqlTran ;
try{
command.CommandText="INSERT INTO Stagiaire(Nom) VALUES('Ali')";
command.ExecuteNonQuery();
command.CommandText="INSERT INTO Stagiaire(Nom) VALUES('Ahmed')";
command.ExecuteNonQuery();
sqlTran.Commit();
}
catch(Exception ee){
sqlTran.Rollback();
MessageBox.Show("Erreur :" + ee.ToString());
}
NB: Pour une utilisation avancé des transaction, cherche l’utilisation des
transaction distribué avec l’API dans le name space System.Transaction
www.ista 47
Procédure Stocké (Exécution)

Puisque l’utilisation des procédures stocké avec les SGBDR permet l’optimisation et la centralisation du
code SQL au niveau du SGBD, il faut pas négligé leur utilisation dans une application client serveur
(ADO.Net), les mêmes objets pour exécuter une instruction SQL sont réutilisé pour l’exécution d’une
procédure stocké, en plus d’un objet Parameter pour définir explicitement les paramètres à une PS
Exp:soit AffNote une procédure qui affiche la liste des notes d’un stagiaire donnée en paramètre
SqlConnection conn =new SqlConnection(@"data source=.\SQLExpress;initial catalog=GestStg; integrated
security=true");
SqlCommand cmd = new SqlCommand("AffNote", conn); create proc AffNote
cmd.CommandType=CommandType.StoredProcedure ; @idstg int
// Création d'un paramètre en entrée as
SqlParameter oParam= cmd.Parameters.Add("@idstg", SqlDbType.Int, 32); begin
oParam.Value="1";
conn.Open(); select m.*, nt_note
SqlDataReader dr = cmd.ExecuteReader(); from matiere m, note n
while(dr.Read()) where
{ for (int i=0; i < dr.FieldCount; i++) m.mt_id=n.mt_id and
{ richTextBox1.Text = richTextBox1.Text + dr[i].ToString() + " " ; } st_id=@idstg
richTextBox1.Text = richTextBox1.Text + "\n« ;}
dr.Close(); end
conn.Close();
www.ista 48
10/02/2012
Procédure Stocké (Paramètre OUTPUT)

Pour une procédure avec paramètre de sortie (output) il faut spécifié la
direction du paramètre avec ParametresDirection.Output,
ParametresDirection.Output, ici on a un exemple
avec la procédure AffMoy (@idstg
(@idstg,@
,@Moy
Moy OUTPUT) qui retourne la moyenne
dans @moy
@moy pour le stagiaire avec @idstg
@idstg
SqlConnection conn = new SqlConnection(@"data

SqlConnection(@"data source=.\
source=.\SQLExpress;initial catalog=GestStg0;
integrated security=true");
SqlCommand cmd = new SqlCommand("
SqlCommand("Affmoy
Affmoy",
", conn
conn);
); create proc affmoy
cmd.CommandType = CommandType.StoredProcedure;
CommandType.StoredProcedure; @idstg int, @moy
// Création d'un paramètre en entrée
SqlParameter oParam = cmd.Parameters.Add("@
cmd.Parameters.Add("@idstg
idstg",
", SqlDbType.Int);
SqlDbType.Int);
real output
oParam.Value = "1"; as
oParam = cmd.Parameters.Add("@
cmd.Parameters.Add("@Moy Moy",
", SqlDbType.Float);
SqlDbType.Float); begin
oParam.Direction = ParameterDirection.Output;
ParameterDirection.Output; select @moy=(select
conn.Open();
conn.Open ();
cmd.ExecuteNonQuery();
cmd.ExecuteNonQuery ();
top 1 st_moyenne
conn.Close();
conn.Close (); from stagiaire where
st_id=@idstg)
richTextBox1.Text =
richTextBox1.Text end
"Moyenne : " + cmd.Parameters["@
cmd.Parameters["@Moy
Moy"].
"].Value.ToString
Value.ToString();
();
www.ista 49
les schémas XSD (DataSet typé)

Le DataSet est en fait un fichier XML qui définit les différentes tables qui
composeront les sources de donnée de votre travail (ComboBox, DataGrid,
CrystalReport…). Ce qui évite tout problème lié au changement de connexion
a la base de donné.
Pour ça en ajoute un nouveau élément

dans le projet de type DataSet (ext
xsd), après en ajoute des tables via une
connexion dans l’explorateur de serveur,
ou bien, en ajoute un nouveau
DataAdapter avec une requête SQL
spécifique et une chaîne de connexion,
un DataTable s’ajoute automatiquement,
avec un assistant qui permet de créer
les autres objets du DataAdapter
(InsertCommand, DeleteCommand,
UpdateCommande)
www.ista 50
10/02/2012
États (CrystalReports)
Dans toute application en a besoin de rapport de sortie imprimable, soit des rapports
de listing, de calcule ou de graphe.
Pour ça en ajoute un nouveau élément de type CrystalReport (ext rpt rpt),
), dans
l’explorateur des champs en peut tous paramétré, champs de base de donnée, champs
de formule, champs de paramètre, champs de nom de groupe, champs de total cumulé
et autre.
Exemple : pour avoir un état de tous les stagiaires avec leur notes et matière, en
commence par paramétré le champs base de donnée avec le DataSet typé, en paramètre
le champs de nom de groupe pour spécifié le regroupement par id_stg et en glisse les
éléments dont en a besoin sur le CrystalReport,
CrystalReport, pour affiché ce rapport, il faut utilisé un
CrystalReportViewer dans une Forms et ajouté le code suivant au démarrage de la
Forms::
Forms
using GestionSTG.GestStgDSTableAdapters
GestionSTG.GestStgDSTableAdapters;;
GestStgDS DS=new GestStgDS()

GestStgDS() ; // instanciation du dataSet typé
StagiaireTableAdapter DAstg
DAstg=new
=new StagiaireTableAdapter()
StagiaireTableAdapter() ;
MatiereTableAdapter DAmat=new
DAmat=new MatiereTableAdapter()
MatiereTableAdapter() ;
NoteTableAdapter DAnote = new NoteTableAdapter()
NoteTableAdapter() ;
STGListeNote etatn
etatn=new
=new STGListeNote()
STGListeNote() ; // remplisssage des Datatables dans le DataSet
DAstg.Fill((DS.Stagiaire
DAstg.Fill DS.Stagiaire);
);
DAmat.Fill((DS.Matiere);
DAmat.Fill DS.Matiere);
DAnote.Fill((DS.Note);
DAnote.Fill DS.Note);
etatn.SetDataSource(DS);
etatn.SetDataSource (DS); // lien entre CR et DataSet
crystalReportViewer1.ReportSource
crystalReportViewer1. ReportSource = etatn
etatn;; // lien entre CRViewer et CR
www.ista 51
Pour afficher un seule relevé pour un
seule stagiaire, il faut travailler le
champs de paramètre pour créer un
paramètre. Donnez lui un nom et un
type
Click droit dans un emplacement vide
dans le rapport pour affiche l’Expert
Sélection, après le chois de l’élément
cliquez sur OK pour précisé l’égalité
entre l’élément sélectionné et le
paramètre créer
www.ista 52
10/02/2012
Et pour le programme, il faut faire les changement suivant pour
prendre en considération le paramètre:
GestStgDS DS=new GestStgDS()

GestStgDS() ; // instanciation du dataSet typé
StagiaireTableAdapter DAstg=new
DAstg=new StagiaireTableAdapter()
StagiaireTableAdapter() ;
MatiereTableAdapter DAmat=new
DAmat=new MatiereTableAdapter()
MatiereTableAdapter() ;
NoteTableAdapter DAnote = new NoteTableAdapter()
NoteTableAdapter() ;
STGListeNote etatn
etatn=new
=new STGListeNote()
STGListeNote() ;// remplisssage des Datatables dans le
DataSet
DAstg.Fill((DS.Stagiaire
DAstg.Fill DS.Stagiaire);
);
DAmat.Fill((DS.Matiere);
DAmat.Fill DS.Matiere);
DAnote.Fill((DS.Note);
DAnote.Fill DS.Note);
etatn.SetDataSource(DS); // lien entre CR et DataSet

etatn.SetDataSource(DS);
etatn.SetParameterValue("
etatn.SetParameterValue ("idstg
idstg",
", idstg);
idstg); //
//idstg
idstg:: valeur du paramètre
crystalReportViewer1.ReportSource
crystalReportViewer1. ReportSource = etatn
etatn;; // lien entre CRViewer et CR
www.ista 53
Finalement en peut
accompagné notre rapport
par un diagramme
(Histogramme)
Click droit-> Insertion…
Exmp: Note par Module
dans relevé Stagiaire.
www.ista 54
10/02/2012
Déploiement (Install)
Il y as plusieurs méthode de publication( publication
normal, avec projet de déploiement, autres outils
externes…)
Dans la page de propriété de votre projet il y as une partie
Publier qu’il faut configuré avant le lancement de votre
publication
• Emplacement du dossier de publication : dossier de sortie

• Fichiers d’application: ajouter les fichier de ressource de votre
application (base de donnée, image, Icon, ficher text, …)
• Composants requis: composant utilisé dans votre application
(rendre les outils utilisé comme CrystalReport, SQLExpress, …)
installable à partir de votre application
• Mise a Jour: l’application cherche la MAJ ou non(si oui indiqué
le lien Web)
• Options : autres information
www.ista 55
www.ista 56

ADO.NET

Transféré par

Informations du documentcliquez pour développer les informations du document

Droits d'auteur :

Formats disponibles

ADO.NET

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

ADO.NET

Transféré par

Droits d'auteur :

Formats disponibles

10/02/2012

M19 : Programmation Cl/Sr

Le client émet une requête vers le serveur

L'architecture à deux niveaux

Dans l'architecture à 3 niveaux (appelées architecture 3-

Le Framework .NET est conçu pour remplir les objectifs suivants :

Choix d'un fournisseur de

Le modèle objet ADO .NET

Le modèle objet ADO .NET

Connexion à une base de données

Ce qui nous permet d’avoir deux modes de connexion (Mode

Accès aux données en mode

La méthode ExecuteReader peut être utilisée pour récupérer un

Gestion des erreurs

Liste Stagiaire Liste Module

Remplissage d'un DataSet

données en exécutant la requête SQL spécifiée dans la propriété SelectCommand.

Création d’un DataSet

DataView view = new DataView(

Enregistrement dans un fichier XML avec le schéma

SqlErrorCollection erData = ex1.Errors

Lui affecter le nom Horloge.cs

Ajouter la dans votre formulaire

Intégrer les Transactions

Intégrer les Transactions (Exp)

Procédure Stocké (Exécution)

Procédure Stocké (Paramètre OUTPUT)

SqlConnection conn = new SqlConnection(@"data

les schémas XSD (DataSet typé)

Pour ça en ajoute un nouveau élément

GestStgDS DS=new GestStgDS()

GestStgDS DS=new GestStgDS()

etatn.SetDataSource(DS); // lien entre CR et DataSet

• Emplacement du dossier de publication : dossier de sortie

Vous aimerez peut-être aussi