Module : Développement d’une application Client/serveur

ADO.NET (VERSION C#)

Introduction
ADO.NET est un ensemble de classes qui exposent des services standardisés d'accès aux
données et qui fait partie intégrante de la nouvelle plate-forme appelée .Net Framework.
Ces classes permettent donc aux programmeurs de concevoir des applications permettant de se
connecter à des sources de données variées et, d’extraire, de manipuler et de mettre à jour ces
données. Une des principales caractéristiques de l’architecture d’ADO.NET, est le fait qu’elle intègre
deux modèles d’accès aux données qui sont :
 Le modèle « connecté » l’application client à un accès direct à la source de données ;
 Le modèle « déconnecté » il est possible de travailler sur des données sans avoir un
accès direct et permanent à la base.
Le Framework .NET est une technologie commune à la plateforme qui permet de rationaliser la
collaboration entre les différents produits. Plusieurs langages sont disponibles comme le C#, le J# et
le Visual Basic.
Les sources de données peuvent être :
 Des SGBD relationnels tels Microsoft SQL Server et Oracle
 Des sources de données exposées via OLE DB.
 Des sources de données exposées via ODBC
 Des sources de données exposées via XML

Les classes d’ADO.net sont divisées en deux composants :

 Les fournisseurs de données managés
 L’objet DataSet + ses collections : qui travail en mode déconnecté du point d'émission

Les Fournisseurs de Données managés

Un fournisseur de données est utilisé pour :
 La connexion à une base de données ;
 l'exécution de commandes;
 l'extraction de résultats.

Pour pouvoir faire appel aux classes proposées par ADO.Net, il nécessaire d’inclure une
référence à l’espace de noms correspondant.
Les Fournisseurs de Données managés namespace
SQL Server managed provider System.Data.SqlClient
OLE DB managed provider (Object Linking and Embedding for Databases System.Data.OLEDB
ODBC managed provider (Open Database Connectivity) System.Data.Odbc

SAIDI AHMED 1
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)

Chaque fournisseur de données de .NET se compose de quatre composants principaux :

 Connection Ouvre une connexion vers une source de données spécifiques

 Command Exécute une commande sur une source de données. cet objet permet d’exécuter
des traitements ou de modifier / lire des données
sur la source, c’est lui qui contiendra la requête SQL

 DataReader Lit un flux de données à partir d'une source de données en mode connecté. Le
mode d'accès est en lecture seule avec un curseur en avant seulement.

 DataAdapter remplir un DataSet et répercute la mise à jour dans la source de données

LE MODE CONNECTE

A. L’objet Connection
L’objet Connection permet de créer une connexion à une source de données. Il représente une
session unique vers une base de données.
ADO.Net propose 3 types d’objet Connection en fonction du type de fournisseur de données
 L’objet SqlConnection pour l’accès à la base de données SQL SERVER
 L’objet OdbcConnection pour l’accès à la base de données de type ODBC
 L’objet OleDBConnection pour l’accès à la base de données de type OleDB
Processus d’utilisation de l’objet Connection

a. Utiliser l’espace de nom correspondant au type de la base de données utilisée

using System.Data.SqlClient //Objet SqlConnection
using System.Data.Odbc //Objet OdbcConnection
using System.Data.OleDb //Objet OleDbConnection

b. Instanciation de l’objet Connection à l’aide du constructeur

Les classes SqlConnection et OleDbConnection proposent deux constructeurs pour
la création d’une instance de l’objet Connection

public OdbcConnection(connectionString As String)

public OleDbConnection (connectionString As String)
public SqlConnection(connectionString As String)

//Objet SqlConnection
SqlConnection con = New SqlConnection(chainedeconnexion)

c. Mise en forme de la chaîne de connexion avec ConnectionString

Cette propriété contient les informations nécessaires d’une connexion à une source de donnée. Elle
consiste en séquence de paramètres délimités par des points-virgules de cette forme :
Nom_paramètre = ‘valeur du paramètre’ ;

//SqlConnection
SqlConnection con = New SqlConnection()

SAIDI AHMED 2
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)
con.ConnectionString = "Data Source= (local);Initial Catalog=ntic; Integrated
Security=True"
ou
con.ConnectionString="server= (local); Initial Catalog=ntic; User ID =sa; pwd=123"

//OleDbConnection
ConnectionString =@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\ntic.mdb"

//OdbcConnection
ConnectionString="DRIVER={MySQL};SERVER=Saidi; DATABASE=ntic; UID=root;PWD=");

La chaîne de connexion
Nom Description
Data Source ou Nom ou adresse réseau de l’instance de SQL Server à laquelle se connecter
Server ou Adresse
Initial Catalog Nom de la base de données
ou Database
False par défaut
Lorsque la valeur est false, l’ID d’utilisateur et le mot de passe sont spécifiés dans la
Integrated Security connexion
Lorsque la valeur est true, les informations actuelles d’identification de compte
Windows sont utilisées pour l’authentification
Password ou Pwd Mot de passe
User ID Compte de connexion

d. Utilisation de la méthode open pour établir la connexion à partir de l’objet Connection

con.Open() //Objet SqlConnection

e. Exécution des instructions sur les données. utilisation de l’objet Command

f. La connexion est fermée à l’aide de la méthode close.
con.Close() //Objet SqlConnection

Méthodes importantes de l’objet sqlConnection (Public)

CreateCommand Crée et retourne un objet sqlCommand associé à sqlConnection

Open Ouvre une connexion à une base de données avec les paramètres de propriété spécifiés par
ConnectionString
Close Ferme la connexion à la base de données. Il s'agit de la méthode privilégiée pour la
fermeture de toute connexion ouverte

Exemple :
Etablir une connexion sur une base donnée SqlServeur avec l’objet SqlConnexion
a. Afficher l’état de la connexion , la base de donnée et le nom su serveur.
b. Traitement :
 Le bouton Connexion permet d’ouvrir la connexion
 Le bouton Déconnexion de la fermer
 Le bouton fin termine l’application
 Dans la zone de texte, afficher l’état de la connexion :

SAIDI AHMED 3
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)

using System.Data.SqlClient;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
SqlConnection con = new SqlConnection();
public Form1()
{
InitializeComponent();
}
//Bouton connexion
private void button1_Click(object sender, EventArgs e)
{
try
{
con.ConnectionString = "Data Source=.\\sqlexpress;Initial Catalog=biblio;Integrated
Security=True";
con.Open();
q3.Text = "etat:"+ con.State.ToString();
q3.Text += "\r\n"+"TimeOut"+ con.ConnectionTimeout.ToString();
q3.Text += "\r\n"+"la base de donnée:" +con.Database.ToString();
q3.Text += "\r\n"+"Data source : "+con.DataSource.ToString();
}
catch (Exception e1)
{
q3.Text="Erreur : " + e1.Message;
}
}
//Bouton déconnexion
private void button2_Click(object sender, EventArgs e)
{
con.Close();
q3.Text = con.State.ToString();
}
//Bouton Fin
private void button3_Click(object sender, EventArgs e)
{
this.Close();
}
}
}

SAIDI AHMED 4
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)
B. L’objet Command
Apres que la connexion à la source de données a été établi, l’objet Command va permettre
d’exécuter des commandes (requêtes, des procédures stockées) sur une base de données. Lorsque la
requête SQL ou procédure retourne un résultat, il est retourné dans un DataReader
Chaque fournisseur possède sa propre version de l’objet Command (SqlCommand,
OdbcCommand, OleDBCommand). La création d’un objet Command nécessite l’instanciation d’un objet
Command
Constructeur de l’objet command
public SqlCommand() ;
SqlCommand public SqlCommand(cmdtext String) ;
public SqlCommand(cmdtext String,Connection SqlConnection)
public OleDbCommand() ;
OleDBCommand public OleDbCommand(cmdtext string) ;
public OleDbCommand(cmdtext String, Connection OleDbConnection )

Argument Description
cmdtext Instruction SQL, nom de procédure stockée
Connection Objet Connetion à référencer pour utiliser l’objet Command

SqlCommand met en œuvre des propriétés et des méthodes permettant l’exécution des
commandes au niveau d’une base de données SQL Server
Propriétés
Nom Description
CommandText Instruction SQL, Transact SQL ou procédure Stockée
CommandType Obtient ou définit une valeur indiquant la manière dont la propriété CommandText doit
être interprétée (instruction SQL ou procédure)
Connection Obtient ou définit l’objet OracleConnection utilisé par cette instance de
OracleCommand.
Parameters Spécifie les paramètres de la requête SQL ou de la procédure stockée

Méthodes
Nom Description
Exécute la commande continue dans la propriété CommandText et
ExecuteReader génère DataReader .
myReader = myCommand.ExecuteReader()
Exécute une requête SQL sur une connexion telles que des instructions SQL INSERT,
ExecuteNonQuery DELETE, UPDATE et SET et retourne le nombre de ligne affectée sous forme d’entier
ligneAffecté = MyCommand.ExecuteNonQuery()
Exécute la requête et retourne la première colonne de la première ligne.
par exemple ; renvoie une valeur comme ceux retournés du COUNT () ou SUM()) d'une
ExecuteScalar base de données..
MyCommand.CaommandText = "SELCT COUNT(*) FROM CANDIDATS";
numbercandidats = myCommand.ExecuteScalar()

Exemple :
 ExecuteNonQuery
SqlConnection con = new SqlConnection (ChaineConnexion );
SqlCommand cmd = New SqlCommand();
cmd.CommandText = "DELETE FROM candidats WHERE nom = 'Ali'";
cmd.CommandType = CommandType.Text ;
cmd.Connection = con;
//ouverture de la connexion
con.Open()
int ligneAffecte ;

SAIDI AHMED 5
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)
ligneAffecte= cmd.ExecuteNonQuery()
MessageBox.Show("nombre d'enregistrement supprimé: " + ligneAffecte)
//fermeture de la connection
con.Close()

 ExecuteReader
SqlConnection con = new SqlConnection (ChaineConnexion );
SqlCommand cmd = New SqlCommand();
cmd.CommandText = "SELECT * FROM candidats"
cmd.CommandType = CommandType.Text
cmd.Connection = con;
con.Open() ;
SqlDataReader MyReader;
MyReader = cmd.ExecuteReader();
while (MyReader.Read)
{
comboBox.Items.Add(MyReader("nom"));
}
con.Close();

 ExecuteScalar
SqlConnection con = new SqlConnection (ChaineConnexion );
SqlCommand cmd = New SqlCommand();
cmd.CommandText = "SELECT COUNT(*) FROM candidats";
cmd.CommandType = CommandType.Text;
cmd.Connection = con;
con.Open();
int icount ;
icount = cmd.ExecuteScalar() ;
MessageBox.Show.Show ("le nombre des candidats est " + icount)
con.Close()

C. L’objet DataReader
Les objets DataReader servent à extraire d'une base de données un flux de données en
lecture seule et dont le défilement se fera par en avant uniquement (read-only, forward-only,).
Les résultats sont retournés pendant que la requête s'exécute et stockés dans la mémoire
tampon de réseau sur le client jusqu'à ce que vous les demandiez au moyen de la méthode Read de
DataReader.

L’objet DataReader se crée par la méthode ExecuteReader de l'objet Command

Propriétés
Nom Description
FieldCount Obtient le nombre de colonnes figurant dans la ligne en cours.
HasRows Obtient une valeur indiquant si DataReader contient une ou plusieurs lignes.
IsClosed Indique si DataReader est fermé
RecordsAffected Indique le nombre de lignes modifiés, ajoutées ou supprimées par l’éxecution d’une
instruction SQL
Item Récupere la valeur de la colonne de données spécifique comm objet .NET. il existe 2
implementations surchargées de cette propriété : une pour le nom de la colonne et l’autre
pour la position ordinale de la colonne.

SAIDI AHMED 6
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)
Méthodes
Nom Description
Colse Ferme l’objet OracleDataReader
Dispose Libère toutes les ressources occupée par l’objet OracleDataReader
Read Permet d’avancer l’objet DataReader jusqu’à l’enregistrement suivant.
GetDateTime Obtient la valeur de la colonne spécifiée sous la forme d'un objet DateTime.
GetDecimal Obtient la valeur de la colonne spécifiée sous la forme d'un objet Decimal.
GetDouble Obtient la valeur de la colonne spécifiée sous la forme d'un nombre de type Double.
GetFloat Obtient la valeur de la colonne spécifiée sous la forme d'un nombre de type Float.
GetInt16 Obtient la valeur de la colonne spécifiée sous la forme d'un entier signé 16 bits.
GetInt32 Obtient la valeur de la colonne spécifiée sous la forme d'un entier signé 32 bits.
GetInt64 Obtient la valeur de la colonne spécifiée sous la forme d'un entier signé 64 bits.
GetName Obtient le nom de la colonne spécifiée.
GetString Obtient la valeur de la colonne spécifiée sous la forme d'une chaîne.
Par défaut, un DataReader charge une ligne entière en mémoire à chaque appel de la méthode
Read. Il est possible d'accéder aux valeurs de colonnes soit par leurs noms soit par leurs références
ordinales. Une solution plus performante est proposée permettant d'accéder aux valeurs dans leurs
types de données natifs (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
de l'objet DataReader

 L’objet Parameter
La classe SqlCommand permet de construire des requêtes paramétrées.
Dans le texte de la commande (CommandText), les paramètres sont désignés par un nom quelconque
précédé du caractère @ (@num dans l’exemple suivant)

SqlCommand cmd;
cmd = new SqlCommand("Update Compte Set solde=0 WHERE numCompte=@num");
Les objets de la classe SqlCommand possèdent une propriété Parameters qui permet de déclarer les
paramètres utilisés dans le texte de la commande.
Chaque paramètre est lui-même un objet de la classe SqlParameter qui doit être créé, initialisé et
ajouté à la collection Parameters de la commande.

cmd.Parameters.Add ( new SqlParameter("@num", SqlDbType.Int, 4) )

Dans cet exemple, on crée un seul paramètre de nom @num, de type SQL SqlDbType.Int, de taille 4.
Avant de lancer la commande, il faut renseigner tous les paramètres en entrée. On accède aux
paramètres, dans la collection Parameters, soit par leur nom ( @num), soit par leur indice ( 0 )

cmd.Parameters ["@num"].value = Int.Parse(txtNum.Text);

cmd.ExecuteNonQuery() ;

Quelques Constructeurs
SqlParameter ()
SqlParameter (string, SqlDbType)
SqlParameter (string, SqlDbType, int)
SqlParameter (stringSqlDbType, int, string)
SqlParameter (string, SqlDbType,
ParameterDirection)
Instancie un SqlParameter
String désigne le nom du paramètre,
le SqlDbtype désigne le type de données du Pramètre public
SqlParameter(string parameterName, SqlDbType Type)
Même que le précédent, sauf qu’on indique la taille du paramètre
Même que le précédent, sauf qu’on indique la taille du paramètre
et le nom de la colonne source
Le ParameterDirection indique si le paramètre est en IN ou Out.
Utilisé lorsque nous avons une procédure stockée

SAIDI AHMED 7
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)

Propriétés importantes SqlParameter

Obtient ou définit une valeur qui indique si le paramètre est un paramètre d'entrée
uniquement, de sortie uniquement, bidirectionnel ou de valeur de retour d'une procédure
stockée.
Prend l’une des valeurs suivantes :
Direction
Input : paramètre d’entrée
InputOutput : paramètre d’entrée sortie
Output : paramètre de sortie
ReturnValue : représente un code retour
ParameterName Obtient ou définit le nom de SqlParameter
SqlDbType Spécifie le type de données Oracle
Size Obtient ou définit la taille maximale, en octets, des données figurant dans la colonne.
Value Obtient ou définit la valeur du paramètre

Méthodes importantes de l’objet SqlParameter

Clone Crée une copie de l’objet SqlParameter
Dispose Libère les ressources occupées par OracleParameter
GetType Obtient le Type de l'instance actuelle
ToString Obtient une chaîne qui contient ParameterName

Définissons ensuite chacun des paramètres en utilisant la méthode Add de la collection

Parameters (dont l'un des prototypes est décrit ci-dessous).
Description Type Exemple
Nom du paramètre string @nom
Type de données SqlDbType SqlDbType.Char
Taille de la colonne int 25
nom de la colonne source string nom

 Création d'un paramètre en entrée

SqlParameter Param = Cmd.Parameters.Add("@nom", SqlDbType.Char, 25, Nom)

Param.Value = "Ahmed"

 Création d'un paramètre retour

SqlParameter Param = Cmd.Parameters.Add("ReturnValue", SqlDbType.Int)

Param.ParameterDirection = ParameterDirection.ReturnValue

Précisons :
 qu'il est nécessaire d'affecter à la propriété Value de l'objet Parameter une valeur pour les
paramètres qui le nécessitent.
 qu'il faut décrire explicitement le type de paramètres via la propriété ParameterDirection de
l'objet Parameter (sauf pour les paramètres en entrée). Celle-ci peut prendre l'une des valeurs
suivantes :
o Input,
o InputOutput,
o Output
o ReturnValue.

SAIDI AHMED 8
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)
 L’utilisation des procédures stockées
Une procédure stockée est un groupe d'instructions SQL qui est compilé une fois pour toutes et peut
être exécuté plusieurs fois. Grâce aux procédures stockées, il est possible de centraliser l'ensemble
du code SQL de votre application à un seul endroit.
La procédure accepte des paramètres d'entrée et renvoie plusieurs valeurs sous forme de paramètres
de sortie et/ou de code retour.

ADO.NET permet d'appeler ces procédures au moyen de l'objet Command, dont la propriété
.CommandType sera alors mise à la valeur "StoredProcedure " et dont la propriété .CommandText
contiendra le nom de la procédure à invoquer.
Cmd.CommandType = CommandType.StoredProcedure

 Utilisation d’une procedure stocké sans parametre

À l'aide de SQL ServerManagement Studio Express, vous allez créer une procédure stockée qui
produit. Une liste des noms des employés dans la base de données Northwind. Il ne nécessite aucune
entrée et n'a pas besoin de définir une valeur de retour.

Procdeure stockée: sp_Select_All_Employees

create procedure sp_Select_All_Employees
as
select employeeid,firstname,lastname from employees

Source c#
SqlConnection conn = new SqlConnection(@"server = .\sqlexpress;integrated security = true;database =
northwind");
try
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "sp_Select_All_Employees";
SqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
Console.WriteLine("{0} {1} {2}", rdr[0].ToString().PadRight(5), rdr[1].ToString(), rdr[2].ToString());
}
rdr.Close();
Console.ReadKey();
}
catch (SqlException ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
conn.Close();
}

 Utilisation d’une procedure stocké avec parametre input

Créer une procédure stockée qui produit une liste de commandes pour un employé donné.Vous passerez
l'ID d'employé à la procédure stockée pour l'utilisation dans une requête.

Procdeure stockée : sp_Orders_By_EmployeeId

SAIDI AHMED 9
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)
create procedure sp_Orders_By_EmployeeId
@employeeid int
as
select orderid, customerid from orders where employeeid = @employeeid;

Source c#
SqlConnection conn = new SqlConnection(@"server = .\sqlexpress;integrated security = true;database =
northwind");
try
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "sp_Select_All_Employees";
SqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
Console.WriteLine("{0} {1} {2}", rdr[0].ToString().PadRight(5), rdr[1].ToString(), rdr[2].ToString());
}
rdr.Close();
Console.ReadKey();
}
catch (SqlException ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
conn.Close();
}

 Utilisation d’une procedure stocké avec parametre output

Les paramètres de sortie sont habituellement utilisés pour passer des valeurs entre les procédures
stockées, mais Parfois ils doivent être accessibles à partir de C #.

Procdeure stockée: sp_Orders_By_EmployeeId2

create procedure sp_Orders_By_EmployeeId2
@employeeid int,
@ordercount int = 0 output
as
select orderid,customerid from orders where employeeid = @employeeid;
select @ordercount = count(*) from orders where employeeid = @employeeid
return @ordercount

Source c#
SqlConnection conn = new SqlConnection(@"server = .\sqlexpress;integrated security = true;database =
northwind");
try
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "sp_Orders_By_EmployeeId2";
SqlParameter inparm = cmd.Parameters.Add("@employeeid", SqlDbType.Int);
inparm.Direction = ParameterDirection.Input;
inparm.Value = 2;

SAIDI AHMED 10
Module : Développement d’une application Client/serveur
ADO.NET (VERSION C#)
SqlParameter ouparm = cmd.Parameters.Add("@ordercount", SqlDbType.Int);
ouparm.Direction = ParameterDirection.Output;
SqlParameter retval = cmd.Parameters.Add("return_value", SqlDbType.Int);
retval.Direction = ParameterDirection.ReturnValue;

SqlDataReader rdr = cmd.ExecuteReader();

while (rdr.Read())
{
Console.WriteLine("{0} {1}", rdr[0].ToString().PadRight(5), rdr[1].ToString());
}
rdr.Close();
Console.WriteLine("la valeur du parametre output est {0}", cmd.Parameters["@ordercount"].Value);
Console.WriteLine("valeur de retour est {0}", cmd.Parameters["return_value"].Value);
Console.ReadKey();
}
catch (SqlException ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
conn.Close();
}

Pour les paramètres autres que Input, vous devez définir la propriété ParameterDirection pour
spécifier si le type de paramètre est InputOutput, Output ou ReturnValue.
Après exécution, on récupère la valeur de retour et les paramètres en sortie de la procédure dans la
collection Parameters

SAIDI AHMED 11