Microsoft .

NET Framework

Web Services User Interface

Data and XML

ADO.NET XML ... ...

Base Classes

Common Language Runtime

ADO
Microsoft ActiveX Data Objects
Conçu pour un accès connecté
Lié au modèle de données physique
Le RecordSet est un conteneur de données.
Le RecordSet est une (1) table qui contient toutes les
données
Récupérer les données de plusieurs tables exige une jointure
SQL ( JOIN )
Les données sont «aplaties»: perte des relations, la navigation
est séquentielle
ADO.NET
Conçu pour un accès déconnecté
Avoir une modélisation logique des données
Le DataSet remplace le RecordSet
DataSet peut contenir plusieurs tables
Récupérer les données de plusieurs tables ou de source ne
nécessite pas un JOIN SQL.
Les relations sont conservées: la navigation est relationnelle
Les données sont liées à un schéma XML
Pas de conversions de type de données requises
Avantages
Avec un mode connecté, la connexion est permanente,
par conséquence les données sont toujours à jour. De
plus il est facile de voir quels sont les utilisateurs
connectés et sur quoi ils travaillent. Enfin, la gestion
est simple, il y a connexion au début de l’application
puis déconnexion à la fin.
Inconvénients
L’inconvénient se trouve surtout au niveau des
ressources. En effet, tous les utilisateurs ont une
connexion permanente avec le serveur. Même si
l’utilisateur n’y fait rien la connexion gaspille beaucoup
de ressource entrainant aussi des problèmes d’accès
au réseau.
Avantage
Il est possible de brancher un nombre important
d’utilisateurs sur le même serveur. En effet, ils se
connectent le moins souvent et durant la plus courte
durée possible. De plus, avec cet environnement
déconnecté, l’application gagne en performance par la
disponibilité des ressources pour les connexions.
Inconvénients
Les données ne sont pas toujours à jour, ce qui peut
aussi entrainer des conflits lors des mises à jour. Il faut
aussi penser à prévoir du code pour savoir ce que va
faire l’utilisateur.
L'interopérabilité par l'utilisation du langage XML
(plus tard!)
Standard ouvert : Open Standard.
Utilisé en interne mais accessible de l'extérieur
Utilisation de l’XML pour lire, écrire et transférer des données
Évolution grâce à la déconnexion DataSet
Les Connexions ne sont pas maintenues pendant de
longues périodes
Fonctionne de la façon dont fonctionne le Web: "Hit and
Run!"
Maintenance
Séparation de Data-Logic et User Interface
ADO.NET Founisseur DataSet
Connection DataAdapter DataTableCollection
Transaction SelectCommand
DataTable
DataRowCollection
Command InsertCommand
DataColumnCollection
Parameters UpDateCommand
ConstraintCollection

DataReader DeleteCommand
DataRelationCollection

Base de
données XML
il existe quatre types de fournisseurs :
SQL Server
Oracle
OLE DB
ODBC
Une collection de classes pour accéder aux data
sources:
Microsoft SQL Server 2000/2005/2008, SQL Server 7,
and MSDE, SQL Express…
OLE Database (OLE DB) providers
Ex: Oracle, JET, SQL OLE DB Providers
Etablie la connexion entre un DataSets et une data
stores
Deux .NET data providers:
ADO: via le namespace System.Data.OleDb
SQL Server: via le namespace System.Data.SqlClient
System.Data.OleDb est le .NET data provider
 UI Applications

SQL Server OLE DB ODBC ORACLE

API API API

API SQL OLE DB ODBC ORACLE

SQL Server Ole DB ODBC ORACLE

 ADO.NET

System.Data

.SqlTypes .SqlClient .Common .OleDb

.Common
Regroupe les classes
partagées
System.Data
.SqlClient .OleDb
SqlCommand OleDbCommand
SqlConnection OleDbConnection
SqlDataReader OleDbDataReader
SqlDataAdapter OleDbDataAdapter
Représente une session unique avec une data
source
Create, open, close, connection a la data source
Fonctionnalités & méthodes pour les transactions
OleDbConnection example:
String conStr="Provider=Microsoft.Jet.OLEDB.4.0;" +
"Data Source=NWIND_RW.MDB";
OleDbConnection aConn = new OleDbConnection(conStr);
aConn.Open();
// Execute Queries using OleDbDataAdapter Class
aConn.Close();
Bridge entre le DataSet et la data store
Hérite de la classe DataAdapter
Moyen pour modifier le DataSet et la data
source

data store DataAdapter DataSet

Bridge entre le DataTable et la data store
Moyen pour modifier le DataTable et la data
source

Table store TableAdapter DataTable

Propriétés:
DeleteCommand: représenta la commande “delete“
SQL
InsertCommand: Gets & sets insert command
SelectCommand: Gets or sets select command
UpdateCommand: Gets or sets update command
TableMappings: Mapper table SQL <=> DataTable
OleDbCommands récupère ou affecte la propriété
command
Implémente les méthodes de la class DataAdapter:
public abstract int Fill( DataSet dataSet );
public abstract int Update( DataSet dataSet );
Représente la requête a exécuté dans la data
source
Requête SQL ou stored procedure.

Propriétés:
Connection: Get & Set the data source connection
CommandText: Get & Set the query (text) command
Texte SQL ou le nom d’une stored procedure.
CommandType: Get & Set l’interprétation de la
command.
Text, StoredProcedure, TableDirect
CommandTimeout: connection timeout
Parameters
Modèle de programmation “Lightweight”
Plus simple a l’utilisation que l’objet
OleDbDataAdapter
Instanciation avec la méthode :
OleDbCommand.ExecuteReader()
Fixe la OleDbCommand jusqu’à la fin de la
lecture des données.
Properietés:
FieldCount: Retourne le nombre de line dans le
« result set ».
RecordsAffected: Nombre de line affectées par
la commande.
Methodes pour récupérer les données:
Suivant la column type and/or index: GetValue;
GetString; etc.
Read(): Avancer au record suivant.
GetValues(): Gets la line courante.
 // Code for creating the OleDbConnection “adoConn” not shown
String conStr="Provider=Microsoft.Jet.OLEDB.4.0;" +
"Data Source=NWIND_RW.MDB";
OleDbConnection adoConn = new OleDbConnection(conStr);
String myQuery = “SELECT * FROM Customers”;
OleDbCommand myCmd = new OleDbCommand( myQuery,adoConn );
adoConn.Open();
// Declare the OleDbDataReader &
// then instantiate it with ExecuteReader(...) ...
OleDbDataReader reader = myCmd.ExecuteReader();

// Always call Read before accessing data.

while( reader.Read() )
{
Object [] cols = new Object[10] ;
reader.GetValues( cols );
Console.WriteLine( cols[0].ToString() + " | " + cols[1] );
}
// Always Close the reader and the connection when done
reader.Close();
adoConn.Close();
Contient la base de l’ADO.NET
Fournit les moyens pour travailler sur et
avec vos données!
Les classes et les méthodes pour manipuler
vos données
Capacité à créer des vues sur vos données
Des moyens pour représenter logiquement vos
données
Permet l'utilisation de XML pour visualiser,
partager et stocker des données
System.Data Contient les classes «principales» de
L’ADO.NET
DataSet Cache en mémoire des données
DataTable Cache en mémoire d'une table
DataRow
Utilisé pour manipuler une ligne dans
un DataTable
DataColumn Utilisé pour définir les colonnes dans
un DataTable
DataRelation
Utilisé pour relier 2 DataTable
DataViewManager Utilisé pour créer des vues sur DataSets
DataSet Tables
DataTable DataView

Row(s) DataViewManager

Relations Column(s) DataViewSettings

DataRelation Constraint(s)
DataViewSetting
DataRelation DataViewSetting
DataTable

DataTable
Un cache mémoire des données provenant d'une source
de : (Base de données relationnelle, fichiers, …)
Façon commune de représenter et manipuler des
données
Conteneur de données universel
Pas seulement pour une utilisation avec les bases de données
Une représentation des données physique - logique
Conçu pour être déconnecté de la source de données
Connecter, exécuter une requête, déconnecter
Peut utiliser XML
Pour lire et écrire des données XML
Pour lire et écrire un XML Schema
Les collections sont utilisées pour ajouter et supprimer des
tables et relations
Propriétés d'intérêt :
Tables: Renvoie une collection de DataTable
Relations: Renvoie une collection de DataRelation
Namespace: Obtient ou définit l'espace de noms du
DataSet
À partir des simples Propriétés :
myDataSet.Tables.Add( myTable );
myDataTableCollection = myDataSet.Tables
Peut être mappées sur une table physique d’une source
de données
Peuvent être reliés les uns aux autres par le biais de
DataRelations
Propriétés d'intérêt t:
Columns: Renvoie ColumnsCollection de DataColumn
Rows: Renvoie une collection de DataRow de type
RowsCollection
ParentRelations: Renvoie une RelationsCollection
Constraints: Renvoie la table de ConstraintsCollection
DataSet: Renvoie le DataSet de DataTable en question
PrimaryKey: Renvoie DataColumns qui composent la clé
primaire de la table
Conteneur Universel de données
DataSet: non seulement pour
une base de données
Créer un DataTable et ajoutez-le à un DataSet
DataSet ds = new DataSet();

// Create DataTable object: “Customers”.

DataTable dt = new DataTable("Customers");

// Create and add columns to the table

// 1. Explicitly create and Add a DataColumn
DataColumn dc;
dc = new DataColumn("CustID", Type.GetType("System.Int16"));
dt.Columns.Add(dc);

// 2. Implicitly Create and Add columns (DataColumn).

dt.Columns.Add("First_Name", Type.GetType("System.String"));
dt.Columns.Add("Last_Name");

// Add the DataTable object to the DataSet

ds.Tables.Add(dt);
Utilisé pour créer des relations logiques entre les
données.
Créer des relations entre deux (2) objets DataTable.
Nécessite l’objet DataColumn pour chaque DataTable
Le DataType des DataColumns doit être le même.
Impossible de relier un objet Int32 DataColumn avec String
DataColumn
La relation est nommée (par vous!)
DataRelation dr = new DataRelation(
“myRelation”,...)
Permet la navigation relationnelle
RelationsCollection collection de DataRelation
Accessible via la propriété Relations du DataSet’s
// Building on the DataTable example earlier...
// Get the DataTable DataColumns we want to relate...

DataColumn parentCol, childCol;

parentCol= ds.Tables["Customers"].Columns["CustID"];

childCol = ds.Tables["Orders“].Columns["CustID"];

// Create DataRelation with the name “CustomerOrders”...

DataRelation dr = new DataRelation("CustomersOrders",
parentCol,
childCol);

// Add the relation to the DataSet...

ds.Relations.Add( dr );
Représente une vue personnalisée du DataTable
Créer des vues multiples sur l’objet DataTable
Bindable avec les contrôles d’interface
Propriétés:
Table: Référence sur l’objet DataTable associé.
Sort: Get & Set les colonnes de trie.
RowFilter: Obtient ou définit l'expression utilisée pour
filtrer les lignes qui s'affichent dans le DataView.
 // Code for myTable “Customers” with “Name” column not
shown
DataView view1 = new DataView( myTable );
DataView view2 = new DataView( myTable );

// Creates Ascending view of Customers by “Name”

view1.Sort = “Name ASC”;

// Set the view to show only modified (original) rows

view2.RowFilter = "City = ‘Casablanca‘";

// Bind to UI element(s)...
DataGridView myGrid = new DataGridView();
myGrid.DataSource = view1;
myGrid.DataSource = view2;
Similaire a DataView mais orienté DataSet
Utiliser pour créer des vues multiples dans un
DataSet
Possibilité de régler automatiquement les filtres sur les tables
Propriétés :
DataViewSettings: collection de DataView pour
chaque DataTable
DataSet: Gets or Sets le DataSet visualisé
CreateDataView méthode
Crée le DataView sur un DataTable.
 // Create the DataViewManager & views...
DataViewManager dvMgr = new DataViewManager( ds);

dvMgr.CreateDataView( ds.Tables["Orders"] );
dvMgr.DataViewSettings["Orders"].Sort = "CustID ASC";

dvMgr.CreateDataView( ds.Tables["Customers"] );
dvMgr.DataViewSettings["Customers"].Sort = "Name DESC";

// Bind to a UI elements/controls...
dataGrid1.DataSource = dvMgr;
dataGrid1.DataMember = "Table1";

dataGrid2.DataSource = dvMgr;
dataGrid2.DataMember = "Table2";

// Update the control with the data...

dataGrid1.Update();
dataGrid2.Update();
DataSet peut Lire/Ecrire du XML et/ou des schémas
Création & modification des données dans un DataSet avec XML
Création & modification du DataSets Schéma avec XML
XML-related DataSet : méthodes de lecture:
ReadXml: lecture du XML Data & Schéma dans un DataSet
ReadXmlSchema: lecture d’un XML schéma dans DataSet
Méthode d’écriture:
WriteXml, WriteXmlSchema
GetXml, GetXmlSchema
 // Code for creating the DataSet mds and loading the
// DataSet from a data source not shown.

String oFile = "C:\\ADO.NET\\myXmlOutput.xsd";

String iFile = "C:\\ADO.NET\\myXmlInput.xsd";

// Write the DataSet’s XMLSchema to an XML Document

mds.WriteXmlSchema( oFile );

// Read/Upload XML Data into the DataSet

mds.ReadXml( iFile);

// modify the data

// ...

// Write the existing Data to an XML Document

mds.WriteXml("C:\\ADO.NET\\myXmlData.txt",
XmlWriteMode.DiffGram);
ADO.NET est l’évolution de l’ADO
Mode déconnecté, Web-centric model
Flexibilité de manipulation des données
Incrémente l’agilité d’organisation des
données
Support de l’XML
Facilité de travailler et partager des données
Interagit avec une large variétés de data
sources.