-
http://www.labo-dotnet.com
Auteur : François Michael Dain et Patrice Lamarche Version 1.1 –
2 novembre 2004
Nombre de pages : 55
Ecole Supérieure d’Informatique de Paris 23. rue Château Landon
75010 – PARIS www.supinfo.com
.NET Compact Framework SUPINFO DOTNET TRAINING COURSE
http://www.supinfo.com/
-
.NET Compact Framework 2 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Table des matières 1. INTRODUCTION AU DEVELOPPEMENT
D’APPLICATION MOBILE...............................................
3 1.1. PRESENTATION DU COMPACT
FRAMEWORK..................................................................................................
3 1.2. LES EMULATEURS
.........................................................................................................................................
4
1.2.1. Pocket
PC..............................................................................................................................................
4 1.2.2. Smartphone
...........................................................................................................................................
5 1.2.3. Windows CE.Net
...................................................................................................................................
6
1.3. DEVELOPPEMENT D’UNE PREMIERE APPLICATION POUR WINDOWS
CE......................................................... 6 2.
CREATION
D’INTERFACE...........................................................................................................................
9 2.1. GUIDE DE DEVELOPPEMENT D’APPLICATIONS
MOBILES.................................................................................
9 2.2. LES CONTROLES PRINCIPAUX
......................................................................................................................
10
2.2.1. ContextMenu
.......................................................................................................................................
10 2.2.2. DataGrid
.............................................................................................................................................
11 2.2.3. Remplissage du DataGrid
...................................................................................................................
11 2.2.3.1. Personnalisation du DataGrid
............................................................................................................
12 2.2.3.2. Sélection d’un élément du DataGrid
...................................................................................................
15 2.2.4. ListBox
................................................................................................................................................
17 2.2.5. DomainUpDown
.................................................................................................................................
18 2.2.6.
ImageList.............................................................................................................................................
19 2.2.7.
ListView...............................................................................................................................................
20 2.2.8. TabControl
..........................................................................................................................................
22
3. ACCES A DES BASES DE DONNEES
LOCALES.....................................................................................
23 3.1. LES DATASET
.............................................................................................................................................
23
3.1.1. Création du
DataSet............................................................................................................................
23 3.1.2. Les contraintes
....................................................................................................................................
24 3.1.3. Remplissage
........................................................................................................................................
24 3.1.4. Consultation
........................................................................................................................................
25 3.1.5.
Sauvegarde..........................................................................................................................................
26
3.2.
XML...........................................................................................................................................................
26 3.3. SQL SERVER
CE.........................................................................................................................................
28
3.3.1. Présentation
........................................................................................................................................
28 3.3.2. Installation
..........................................................................................................................................
29 3.3.3. Création d’une base de données SQL Server
CE................................................................................
30 3.3.4. Insérer des
données.............................................................................................................................
33 3.3.5. Modifier des données
..........................................................................................................................
34 3.3.6. Lire des
données..................................................................................................................................
35
4. ACCEDER A DES DONNEES
DISTANTES...............................................................................................
36 4.1. INTERROGATION D’UN WEB SERVICE
.........................................................................................................
36
4.1.1. Création d’un Web Service
.................................................................................................................
36 4.1.2. Interrogation du Web Service à partir d’une application
mobile .......................................................
40
4.2. ACCES DIRECTE A UNE BASE DE DONNEES SQL SERVER
.............................................................................
42 5. SYNCHRONISATION DE SQL SERVER CE
............................................................................................
45 5.1. INTRODUCTION
...........................................................................................................................................
45 5.2. REMOTE DATA
ACCESS...............................................................................................................................
45
5.2.1. Installation
..........................................................................................................................................
45 5.2.2. Récupération de données grâce à la méthode PULL
..........................................................................
49 5.2.3. Envoi de données grâce à la méthode
PUSH......................................................................................
50 5.2.4. Exécution de requêtes SQL sur un poste distant grâce à la
méthode SubmitSQL............................... 51
5.3. MERGE
REPLICATION..................................................................................................................................
51
DOCUMENTATION..........................................................................................................................................
55
-
.NET Compact Framework 3 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
1. Introduction au développement d’application mobile
Les périphériques mobiles sont de plus en plus présent en
entreprise et doivent remplir des rôles de plus en plus complexes.
Simples agenda électroniques au départ, ceux-ci ont évolués tant en
terme de systèmes d’exploitation qu’au niveau des capacités du
matériel. Les machines d’aujourd’hui ont la capacité d’avoir des
fonctionnalités puissantes et intéressantes et doivent s’intégrer
au système d’information de l’entreprise. Cela laisse place à
différents scénarios d’utilisation où les applications doivent être
fonctionnelles en mode Online ou Offline, en mettant en place des
fonctionnalités de synchronisation avec les différents systèmes de
l’entreprise. Les périphériques mobiles s’intègrent ainsi dans le
réseau de l’entreprise selon le schéma ci-dessous :
Figure 1 - Intégration des périphériques mobiles dans le réseau
de l'entreprise
1.1. Présentation du Compact Framework Le Compact Framework est
donc proposé par Microsoft pour répondre à toutes ces
problématiques et faire fonctionner des clients riches répondant
aux besoins des entreprises. Le Compact Framework .Net est un
Framework .Net allégé qui pèse moins de 2Mo afin d’être adapté aux
périphériques mobiles. Ainsi certaines fonctions et certaines
briques logicielles du Framework .Net ne sont pas incluses comme
par exemple ASP.Net qui est totalement inutile pour un Pocket PC ou
un Smartphone (On ne sert pas de ces appareils comme serveur web…)
On considère ainsi par souci de simplicité que le Compact Framework
.Net est un sous-ensemble du Framework.Net qui reprend les
fonctionnalités les plus utilisées de son grand frère. L’avantage
de ce type de conception est évident : il n’est pas nécessaire
d’avoir des compétences particulières pour développer des
applications mobiles pour Pocket PC, Smartphone ou machines
fonctionnant sous Windows CE. Si vous savez développer des
applications Windows pour Win 9X, Windows XP ou Windows 2003, vous
savez développer des applications pour Windows CE. Votre code sera
le plus souvent compatible avec le Compact Framework à condition
d’utiliser que des namespaces et classes implémentées dans le
Framework .NET et dans le Compact Framework. Cependant, penser que
le Compact Framework est un sous-ensemble du Framework.net n’est
pas entièrement vrai puisqu’il existe quelques ajouts de namespaces
et donc de fonctionnalités. Ainsi, le Compact Framework propose des
objets permettant d’interagir avec les capacités IRDA (Infrarouge)
des périphériques mobiles et propose également un namespace
System.Data.SqlserverCE permettant d’accéder et de manipuler des
bases de données SQL Server CE (la version allégée de SQL Server
fonctionnant sur Pocket PC).
-
.NET Compact Framework 4 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 2 - Namespaces du Compact Framework
1.2. Les émulateurs 1.2.1. Pocket PC
Des émulateurs Pocket PC 2002 sont livrés par défaut avec Visual
Studio.Net 2003. Cependant ceux-ci émulent une version précédente
des Pocket PC et peuvent dans quelques cas poser certains
problèmes. Il est donc préférable de télécharger le SDK Pocket PC
2003 afin de disposer des derniers émulateurs disponibles. Le SDK
Pocket PC 2003 est proposé gratuitement par Microsoft à l’adresse
suivante :
http://www.microsoft.com/downloads/details.aspx?familyid=9996b314-0364-4623-9ede-0b5fbb133652&displaylang=enIl
fournit une aide détaillée à propos du développement d’applications
pour Pocket PC 2003 ainsi qu’un émulateur amélioré par rapport à la
version fournie avec Visual Studio .Net 2003. Une fois le SDK
installé vous pouvez lancer l’émulateur via Visual Studio .Net.
Pour cela, cliquer sur « Outils \ Connecter au périphérique » et
sélectionner l’émulateur « Pocket PC 2003 Emulator »
Figure 3 - Menu de lancement de l'émulateur
Une fois lancé, vous arrivez sur l’émulateur suivant. Vous êtes
alors en face d’un véritable Pocket PC avec un Windows CE installé.
Vous pouvez ainsi découvrir ce périphérique ainsi que le système
d’exploitation. N’hésitez pas à lancer des applications et à
naviguer sur le web via Pocket Internet Explorer afin d’étudier
l’ergonomie des sites web dédiés au PDA. Vous pouvez vous rendre
sur www.msn.com, www.hotmail.com pour découvrir les versions
allégées des sites web que vous connaissez déjà.
http://www.microsoft.com/downloads/details.aspx?familyid=9996b314-0364-4623-9ede-0b5fbb133652&displaylang=enhttp://www.microsoft.com/downloads/details.aspx?familyid=9996b314-0364-4623-9ede-0b5fbb133652&displaylang=enhttp://www.msn.com/http://www.hotmail.com/
-
.NET Compact Framework 5 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 4 - Emulateur Pocket PC 2003
Du point de vue utilisation, l’émulateur Pocket PC 2003 se
manipule très simplement à l’aide de votre souris (la souris fait
office de stylet). Pour effectuer des clic droits, faite un clic
gauche prolongé. Les autres actions ne demandent pas de
manipulations particulières.
1.2.2. Smartphone Comme pour les émulateurs Pocket PC, il est
nécessaire d’installer le SDK Smartphone 2003 afin de disposer des
derniers émulateurs Smartphone disponible. Pour le télécharger et
ensuite l’installer rendez-vous sur : http
://www.microsoft.com/downloads/details.aspx
?familyid=a6c4f799-ec5c-427c-807c-4c0f96765a81&displaylang=en
Figure 5 - Emulateur Smartphone 2003
http://www.microsoft.com/downloads/details.aspx?familyid=a6c4f799-ec5c-427c-807c-4c0f96765a81&displaylang=enhttp://www.microsoft.com/downloads/details.aspx?familyid=a6c4f799-ec5c-427c-807c-4c0f96765a81&displaylang=en
-
.NET Compact Framework 6 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
1.2.3. Windows CE.Net Qaunt à l’émulateur de Windows CE, la
seule disponible est celle de la version 4.2. Actuellement il
existe des émulateurs Windows CE 5, mais ils ne sont pas
intégrables dans Visual Studio .Net.
Figure 6 - Emulateur de Windows .NET
1.3. Développement d’une première application pour Windows
CE
La création d’une application Windows pour périphériques mobiles
se fait de manière classique. Dans la boite de dialogue Nouveau
Projet, sélectionnez un projet « Smart Device » dans le langage de
votre choix (VB.Net ou C#)
Figure 7 - Création d'un projet Smart Device
Une fois la création de projet validée, un assistant apparaît
permettant de définir le type d’application que vous souhaitez
développer ainsi que la plateforme désirée (Pocket PC, Smartphone,
ou périphérique Windows CE).
-
.NET Compact Framework 7 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 8 – Définition du type de l’application et de la
plateforme ciblée
Pour notre première application, nous allons créer une
application Windows pour Pocket PC. Une fois l’assistant terminé,
vous arrivez sur un espace de travail légèrement modifié. Vous
pouvez constater que la taille par défaut des formulaires Windows
est plus petite et correspond à la taille d’un écran de Pocket PC
Standard. Autre modification, la boite à outils contenant les
contrôles à disposer sur les formulaires, contient un onglet «
Contrôles du périphériques » qui contient tous les contrôles que
vous pourrez utiliser dans vos applications Pocket PC.
Figure 9 - Environnement de développement d'application
mobile
Placez un bouton sur votre formulaire. Nous allons faire un
simple Hello World : Exemple en C# : MessageBox.Show("Hello Pocket
PC"); Exemple en VB.Net : Msgbox(" Hello Pocket PC ") Lancez
l’application pour voir le résultat dans l’émulateur. Autre
exemple, créez une application Windows fonctionnant sous Windows CE
en suivant la procédure indiquée ci-dessus. Placer un label ayant
comme texte : « Hello Compact Framework ».
-
.NET Compact Framework 8 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Utilisez un Timer et saisissez le code suivant dans l’évènement
Tick de votre Timer : If lblHello.Left < (Me.Width) Then
lblHello.Left += 20 Else lblHello.Left = -(lblHello.Width) End If
Exécutez votre application. L’émulateur se lance automatiquement et
le déploiement de l’application sur l’émulateur s’effectue.
Remarque : Si vous déployez une application .Net sur un système
vierge, Visual Studio le détectera et installera le Compact
Framework nécessaire à l’exécution de l’application sur votre
système cible.
Figure 10 - Déploiement du Compact Framework
-
.NET Compact Framework 9 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
2. Création d’interface Dans ce chapitre, nous allons développer
la création d’interface pour Pocket PC. En effet, les contraintes
de développement d’interface sous un Pocket PC sont beaucoup plus
importantes (taille de l’écran, système de saisie de
l’information…), alors qu’un périphérique sous Windows CE «
ressemble » plus à un PC ordinaire.
2.1. Guide de développement d’applications mobiles Afin de
développer des applications Mobiles ergonomique, voici une liste de
règles à respecter :
• L’interface doit être la plus simple possible pour
l’utilisateur. C'est-à-dire qu’elle ne doit pas exposer trop de
fonctionnalités, cela peut rendre l’utilisation de l’application
trop complexe. Il faut donc limiter les contrôles, et mettre en
avant les contrôles qui exécutent les fonctionnalités les plus
courantes. La « navigation » dans votre application doit être la
plus simple possible pour l’utilisateur mobile.
• L’application doit être « utilisable » : l’utilisateur doit
pouvoir accomplir rapidement et facilement les tâches qu’il doit
exécuter. Par exemple, imaginez un responsable d’achat qui fait
l’inventaire des stocks. Il doit vérifier pour chaque produit la
quantité qu’il a réellement et la quantité théorique. Cette
vérification doit la plus simple possible. Il sélectionne
l’article, l’application mobile revoit la quantité théorique…. Dans
ce cas la, il faut que l’interaction entre l’utilisateur soit la
plus simple possible. Il n’y a pas besoin de Wizard qui le guide à
travers les étapes de saisie. Les boites de dialogue superflus
doivent êtres simplifiés au maximum.
• L’application mobile doit être compréhensible et adaptée à
l’utilisateur final. Par exemple, dans le cas d’une erreur, il n’a
pas besoin de savoir le détail technique de l’erreur.
• L’application ne doit pas contraindre l’utilisateur à se
souvenir d’information, dont elle aurait besoin plus tard. Ce n’est
pas une application Windows classique, il n’est pas possible
d’ouvrir 20 fenêtres simultanément, et de faire du copier coller
!
• L’utilisation des icônes dans les applications est soumise à
quelques règles. En général, les icônes de taille 32x32px sont
dessinés en perspective, ce qui donne un aspect 3D, contrairement
aux icônes de taille 16x16px. Il existe quelques exceptions à cette
règle. Par exemple les icônes de taille 32x32 qui ont une forme
circulaire ou alors qui sont un logo, ont un rendu plat. De même,
les icônes qui ont plusieurs objets, peuvent avoir un rendu
plat.
• Comme nous avons pu le voir avant l’interaction avec
l’utilisateur est importante, c’est pourquoi il est nécessaire de
respecter le modèle d’interaction de la plateforme sur laquelle
votre application est destinée. Par exemple, l’équivalent du clic
droit d’une application Windows classique est de maintenir le
stylet 2 secondes sur l’écran du Pocket PC.
• La façon d’entrer du texte est importante. Il faut que la
quantité d’information saisie par l’utilisateur être adaptée au
système d’entrer du périphérique. Par exemple la saisie de texte
sous PPC est beaucoup plus simple que la saisie sous
SmartPhone.
Figure 11 - Système de saisie du Pocket PC
-
.NET Compact Framework 10 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
2.2. Les contrôles principaux 2.2.1. ContextMenu
Le contrôle ContextMenu permet de créer un menu associé à un
autre control (par exemple un Label) par une longue pression sur
l’écran tactile. Cette longue pression est l’équivalent du clic
droit sur une application Windows traditionnelle.
Figure 12 - Exemple de ContextMenu
Pour associer à un contrôle quelconque (Button, DataGrid,…), il
faut associer le contrôle en question avec un objet ContextMenu en
utilisant la propriété ContextMenu.
Figure 13 - Définition du ContextMenu du button5
Pour ajouter des éléments dans le menu, soit vous utilisez le
desginer de Visual Studio, soit vous le faites par le code à l’aide
la méthode Add de la propriété MenuItems.
-
.NET Compact Framework 11 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 14 - Ajout d'élément dans le ContextMenu à l'aide de
Visual Studio
2.2.2. DataGrid Le contrôle DataGrid est un contrôle qui ne sert
à afficher que des données provenant d’une source de données. Cette
source de données est spécifiée par la propriété DataSource. Cette
propriété accepte les objets DataTable, DataView, ArrayList, et les
objets implémentant les interfaces IListSource et IList. Si vous
avez déjà utilisé les DataGrid avec le .NET Framework, il existe
quelques différences :
• Le DataGrid du Compact Framework ne peut pas accepter les
DataSet comme DataSource. Le DataGrid du Framework offre la
fonctionnalité d’afficher les DataTable du DataSet, or cette
fonctionnalité n’est pas implémentée dans le DataGrid du CF.
• Le mode édition du contrôle du DataGrid n’est pas implémenté
nativement. Il faut que l’implémentiez vous-même.
Afin d’illustrer l’utilisation du DataGrid, nous allons réaliser
les cas d’utilisation suivant :
• Remplissage du DataGrid • Personnalisation du DataGrid •
Sélection d’un élément du DataGrid
2.2.3. Remplissage du DataGrid Dans cet exemple, nous allons
concevoir une application Pocket PC qui créé un DataSet et qui le
lie au DataGrid. La création du DataSet est abordé en détail dans
le paragraphe 3.1.1 Création du DataSet. Remarque : le fait de lier
un contrôle d’affichage à une source de données s’appelle le
DataBind Cette application Pocket PC possède trois contrôles :
• Un DataGrid qui permet d’afficher les données • Un Button
button1 qui permet de créer le DataSet • Un Button button2 qui
permet d’afficher les données du DataSet dans le DataGrid
/// /// Méthode permettant la création du DataSet /// /// ///
private void button1_Click(object sender, System.EventArgs e) { //
Création des différentes colonnes DataColumn id = new
DataColumn("ID",System.Type.GetType("System.Int32")); DataColumn
lastName = new
DataColumn("LastName",System.Type.GetType("System.String"));
DataColumn firstName = new DataColumn("FirstName",
System.Type.GetType("System.String"));
-
.NET Compact Framework 12 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
// Création de la tabe Users DataTable user = new
DataTable("Users"); user.Columns.Add(id);
user.Columns.Add(lastName); user.Columns.Add(firstName); //
Instanciation du DataSet et ajout de la table Users dans le DataSet
_dataToDisplay = new DataSet("User");
_dataToDisplay.Tables.Add(user); // Création d'un utilisateur
DataRow newRow1 = user.NewRow(); newRow1["ID"] = 1;
newRow1["LastName"] = "DAIN"; newRow1["FirstName"] = "François
Michael"; user.Rows.Add(newRow1); // Création d'un utilisateur
DataRow newRow2 = user.NewRow(); newRow2["ID"] = 2;
newRow2["LastName"] = "LAMARCHE"; newRow2["FirstName"] = "Patrice";
user.Rows.Add(newRow2); } /// /// Cette méthode lie le DataGrid au
DataSet /// /// /// private void button2_Click(object sender,
System.EventArgs e) { if (_dataToDisplay != null) { da
id1.DataSource = _dataToDispltaGr ay.Tables[0]; } }
2.2.3.1. Personnalisation du DataGrid Pour perso ge des données,
il faut utiliser la propriété St ataGridTableStyle, il faut
instancier
ancier une classe
nnaliser le DataGrid, c'est-à-dire modifier l’affichayle du
DataGrid. Comme cette propriété est de type D
un objet DataGridTableStyle, auquel on ajoute des objets
DataGridColumnStyle. Chaque objet DataGridColumnStyle représente la
colonne personnalisée que vous voulez afficher. Remarque : La
classe DataGridColumnStyle est une classe abstraire, il faut donc
instfille. Contrairement au .NET Framework, le Compact Framework ne
propose pas la classe DataGridBoolColumn. Seule la classe
DataGridTextBoxColumn est disponible. Nous avons donc modifié notre
méthode button2_Click, pour personnaliser l’affichage du DataGrid :
/// /// Cette méthode lie le DataGrid au DataSet /// /// ///
-
.NET Compact Framework 13 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
private void button2_Click(object sender, System.EventArgs e) {
if (_dataToDisplay != null) { dataGrid1.DataSource =
_dataToDisplay.Tables[0]; // Création de l'instance
DataGridTableStyle qui vas nous permettre // de personaliser
l'affichage. DataGridTableStyle customDisplayUser = new
DataGridTableStyle(); // On sécifie que la personalistion de
l'affichage est lié à la // DataTable Users
customDisplayUser.MappingName = "Users"; // Personalisation de la
colonne ID // Comme DataGridColumnStyle est une classe abstraite,
// il faut spécifier le style de colonne que l'on souhaite
DataGridColumnStyle lastnameColumn = new DataGridTextBoxColumn();
// On sécifie que la personalistion de la colone est lié au //
champ ID de la DataTable Users lastnameColumn.MappingName =
"LastName"; lastnameColumn.HeaderText = "Nom"; lastnameColumn.Width
= 100; // Ajout de IDColumn de la DataGridTableStyle
customDisplayUser.GridColumnStyles.Add(lastnameColumn); // Ajout de
DataTableStyle au DataGrid
dataGrid1.TableStyles.Add(customDisplayUser); } }
s cet exemple, on affiche que le nomDan de l’utilisateur.
Figure 15 - Affichage de l'exemple
nous venons de mod code. Il est aussi possible de le Remarque :
ifier le style du DataGrid par le
modifier en utilisant le designer de Visual Studio. Dans la
fenêtre des propriétés (Figure 16), il existe une propriété
TableStyles.
-
.NET Compact Framework 14 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 16 - Propriété TableStyles
Figure 17 - Création d'une collection de DataGridStyle
En cliquant sur cette propriété, le d DataGridStyle esigner vous
propose de créer une collection de (Figure 17).
-
.NET Compact Framework 15 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 18 - Création d'une collection de
DataGridTextBoxColumn
Pour chaque objet DataGridStyle ajouté dans la collection, il
existe une autre propriété GridComumnStyle qui permet de créer les
colonnes personnalisées (Figure 18).
2.2.3.2. Sélection d’un élément du DataGrid Les utilisateurs
peuvent sélectionner n’importe quels éléments du DataGrid (cellule,
ligne, colonne). Pour cela, il est nécessaire de gérer l’évènement
MouseUp du DataGrid (Figure 19). La méthode dataGrid_MouseUp est
appelée automatiquement lors de l’évènement MouseUp. Elle possède
comme paramètre un objet object sender, et un
System.Windows.Forms.MouseEventArgs e. L’objet sender est le
DataGrid qui émet l’évènement, et l’objet e nous permet de
récupérer les coordonnées du pointeur à travers les propriétés X et
Y.
Figure 19 - Gestion de l'évènement de MouseUp
Ensuite, il nous suffit de caster l’objet sender en DataGrid ;
DataGrid myDataGid = (DataGrid)sender;
-
.NET Compact Framework 16 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Puis d’appeler la méthode HitTest du DataGrid, qui nous renvoie
un objet HitTestInfo. Cet objet nous permet de déterminer la partie
d'un contrôle DataGrid sur laquelle l'utilisateur a cliqué (cette
partie est représentée par les coordonnées spécifiées dans le
méthode HitTest). DataGrid.HitTestInfo hit =
myDataGid.HitTest(e.X,e.Y); La propriété Type de l’objet hit (qui
est une énumération DataGrid.HitTestInfo) permet de déterminer le
type de sélection de l’utilisateur, c'est-à-dire une cellule, une
ligne, une colonne… Le tableau ci-dessous énumère les membres de
DataGrid.HitTestType.
Nom de membre Description Cell Légende du contrôle
System.Windows.Forms.DataGrid. ColumnHeader En-tête de colonne du
contrôle System.Windows.Forms.DataGrid. ColumnResize Bordure de la
colonne, représentée par la ligne située entre les en-têtes de
colonne. Elle peut être déplacée pour redimensionner la largeur
d'une colonne.
None Zone d'arrière-plan, visible lorsque le contrôle ne
contient aucune table ou contient peu de lignes, ou encore
lorsqu'une table est parcourue jusqu'à la fin.
RowHeader En-tête de ligne dans le contrôle
System.Windows.Forms.DataGrid RowResize Bordure de la ligne,
représentée par la ligne située entre les en-têtes de ligne.
Elle peut être déplacée pour redimensionner la hauteur d'une
ligne. Tableau 1 - Liste des membres de l'énumération
DataGrid.HitTestType
Voici un exemple complet de gestion de l’évènement MouseUp du
DataGrid : private void dataGrid1_MouseUp(object sender,
System.Windows.Forms.MouseEventArgs e) {
DataGrid myDataGid = (DataGrid)sender; DataGrid.HitTestInfo hit
= myDataGid.HitTest(e.X,e.Y); switch(hit.Type) { case
(DataGrid.HitTestType.Cell): { object selectionedCell =
myDataGid[hit.Row,hit.Column];
MessageBox.Show(selectionedCell.ToString()); break; }
case(DataGrid.HitTestType.ColumnHeader): { DataTable datasource =
(DataTable)myDataGid.DataSource; DataColumn selectionnedColumn =
datasource.Columns[hit.Column];
MessageBox.Show(selectionnedColumn.Caption); break; }
case(DataGrid.HitTestType.RowHeader): { DataTable datasource =
(DataTable)myDataGid.DataSource; DataRow selectionRowHeader =
datasource.Rows[hit.Row]; MessageBox.Show("Ligne de " +
selectionRowHeader["LastName"].ToString() +" selectionée"); break;
} case(DataGrid.HitTestType.None): {
-
.NET Compact Framework 17 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
MessageBox.Show("Aucune donnée est selectionnée"); break; }
default: { MessageBox.Show("Selection non prise en compte"); break;
} } }
2.2.4. ListBox Le contrôle ListBox permet d’afficher une liste
d’éléments, parmi laquel l’utilisateur peut faire un choix.
Remarque : contrairement au contrôle ListBox du .NET Framework, il
n’est pas possible de faire de sélectionner plusieurs éléments avec
un contrôle ListBox du Compact Framework. Le contrôle ListBox
possède trois propriétés importantes (ces trois propriétés héritent
de ListControl) :
• DataSource, cette propriété permet de spécifier la source de
donnée • DisplayMember, cette propriété permet de définir la
colonne de la source de donnée à afficher • ValueMember, cette
propriété permet de définir la colonne de la source de donnée.
Généralement c’est l’identifiant unique d’un élément
Nom de membre Description DisplayMember Obtient ou définit une
chaîne qui spécifie la propriété de la source de
données dont vous voulez afficher le contenu. DataSource Obtient
ou définit la source de données ValueMember Obtient ou définit une
chaîne qui spécifie la propriété de la source de
données dont vous souhaitez dessiner la valeur Tableau 2 -
Description de DataSource, DisplayMember, ValueMember
Pour récupérer l’élément sélectionné par l’utilisateur, il
existe trois propriétés :
• SelectedIndex • SelectedItem • SelectedValue
Nom de membre Description
SelectedItem Obtient ou définit l'index de base zéro de
l'élément actuellement sélectionné SelectedIndex Obtient ou définit
l'index de base zéro de l'élément actuellement sélectionné
SelectedValue Obtient ou définit la valeur de la propriété de
membre spécifiée par la
propriété ValueMember Tableau 3 - Description de SelectedItem,
SelectedIndex, SelectedValue
Voici un exemple, lorsqu’on clique sur le bouton button3,
affiche les données de la DataTable, et lorsqu’on clique sur le
bouton button4, on affiche la sélection de l’utilisateur. private
void button3_Click(object sender, System.EventArgs e) {
listBox1.DataSource = Data.Data.GetUsers().Tables[0];
listBox1.DisplayMember = "LastName"; listBox1.ValueMember = "ID";
}
-
.NET Compact Framework 18 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
private void button4_Click(object sender, System.EventArgs e) {
MessageBox.Show("ID de l'élément à supprimer " +
listBox1.SelectedValue + "\n Personne à supprimer " +
((DataRowView)listBox1.SelectedItem)["FirstName"].ToString() + " \n
Index de l'élément selectioné " + listBox1.SelectedIndex); }
Figure 20 - Résultat d'affichage d'une sélection
2.2.5. DomainUpDown Le contrôle DomainUpDown a les mêmes
fonctionnalités que le contrôle ListBox, excepté que le rendu
visuel est très différent. En effet, le contrôle DomainUpDown ne
possède qu’un seul élément à la fois.
-
.NET Compact Framework 19 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 21 - Exemple DomainUpDown
De même, il n’est pas possible de lier le contrôle DomainUpDown
directement à une source de donnée : la propriété DataSource
n’existe pas disponible. Il faut donc utiliser la méthode Add de la
propriété Items foreach (DataRow myRow in
Data.Data.GetUsers().Tables[0].Rows) {
domainUpDown1.Items.Add(myRow["FirstName"].ToString());
}
2.2.6. ImageList Le contrôle ImageList est un contrôle qui agit
comme un containeur d’image. Il permet de stocker des images qui
seront utilisées par d’autres contrôles comme le contrôle ListView
ou TreeView. Pour ajouter une image dans ImageList, le plus simple
est d’utiliser le designer de Visual Studio. En affichant les
propriétés du contrôle ImageList, il existe une collection Images
(voir ci-dessous).
Figure 22 - Propriétés du contrôle ImageList
Si vous cliquez sur la collection Images, une fenêtre s’ouvre et
vous propose d’insérer des images dans la collection (voir
ci-dessous).
-
.NET Compact Framework 20 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 23 - Ajout d'image dans le contrôle ImageList
Il est possible d’ajouter dynamiquement des images dans le
contrôle ImageList grâce à la méthode Add de la collection
Images.
2.2.7. ListView Pour créer des éléments dans un ListView, il
faut d’abord créer une ListViewItem, qui vas correspondre à un
élément du ListView, et que l’on ajoutera dans la propriété Items.
foreach (DataRow myRow in Data.Data.GetUsers().Tables[0].Rows) {
ListViewItem user = new ListViewItem(myRow["LastName"].ToString());
user.SubItems.Add(myRow["FirstName"].ToString());
listView1.Items.Add(user); } Après avoir ajouter les éléments à
afficher dans le ListView, nous allons paramétrer l’affichage. Nous
allons d’abord définir le type d’affichage souhaité, grâce à la
propriété View. La propriété View est une énumération, dont le
détail est affiché dans le tableau ci-dessous :
Nom de membre Description Details Chaque élément s'affiche sur
une ligne séparée et des informations
complémentaires sur chacun des éléments sont disposées en
colonnes. La colonne la plus à gauche contient une petite icône et
une étiquette et les colonnes suivantes contiennent des
sous-éléments, tel que cela a été spécifié par l'application. Une
colonne affiche un en-tête qui peut contenir un titre pour la
colonne. L'utilisateur peut redimensionner chaque colonne au moment
de l'exécution.
LargeIcon Chaque élément s'affiche sous forme d'une icône de
taille normale, avec une étiquette placée au-dessous.
List Chaque élément s'affiche sous forme d'une petite icône,
avec une étiquette placée à droite. Les éléments sont répartis dans
des colonnes sans en-têtes.
SmallIcon Chaque élément s'affiche sous forme d'une petite
icône, avec une étiquette placée à droite. Tableau 4 - Détails de
l'énumération de View (MSDN)
Ensuite, il suffit d’ajouter les colonnes :
-
.NET Compact Framework 21 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
listView1.Columns.Add("Nom",-1,HorizontalAlignment.Center);
listView1.Columns.Add("Prénom",-1,HorizontalAlignment.Center);
Voici, le code qui gère l’évènement Click du button5 et qui permet
d’avoir l’affichage de la Figure 24 : private void
button5_Click_1(object sender, System.EventArgs e) { listView1.View
= View.Details; foreach (DataRow myRow in
Data.Data.GetUsers().Tables[0].Rows) { ListViewItem user = new
ListViewItem(myRow["LastName"].ToString());
user.SubItems.Add(myRow["FirstName"].ToString());
listView1.Items.Add(user); }
listView1.Columns.Add("Nom",-1,HorizontalAlignment.Center);
listView1.Columns.Add("Prénom",-1,HorizontalAlignment.Center);
}
Figure 24 - Exemple d'utilisation du ListView
Il est possible d’associer des images à chaque élément du
ListView (voir Figure 25).
Figure 25 - Exemple d'utilisation du ListView avec des
images
-
.NET Compact Framework 22 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Il faut donc préciser à la propriété SmallImageList l’ImageList,
qui contient les images, et à la propriété ImageIndex du
ListViewItem, l’index de l’image : private void
button5_Click_1(object sender, System.EventArgs e) { listView1.View
= View.Details; int i =0; foreach (DataRow myRow in
Data.Data.GetUsers().Tables[0].Rows) { ListViewItem user = new
ListViewItem(myRow["LastName"].ToString());
user.SubItems.Add(myRow["FirstName"].ToString()); user.ImageIndex =
i; i++; listView1.Items.Add(user); }
listView1.Columns.Add("Nom",-1,HorizontalAlignment.Center);
listView1.Columns.Add("Prénom",-1,HorizontalAlignment.Center);
}
2.2.8. TabControl Le contrôle TabControl est très utile pour des
applications qui manipulent beaucoup de données qui peuvent classer
dans des catégories. Chaque catégorie peut être représenté par un
onglet dans le TabControl. Cet onglet est un objet de type TabPage
et est ajouté à travers la méthode Add de l’objet TabControl :
this.tabControl1.Controls.Add(this.tabPage2);
Figure 26 - Exemple de TabControl
Ensuite, il est possible de personnaliser chaque objet TabPage
en ajoutant d’autres contrôles comme le contrôle Label,
CheckBox...
-
.NET Compact Framework 23 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
3. Accès à des bases de données locales
Bien que les périphériques mobiles soient intégrées au système
d’information de l’entreprise et connectées physiquement à son
réseau, il est nécessaire de stocker des informations en local. En
effet, il est rare de disposer de périphériques mobiles connectés
en permanence. Il faut donc pouvoir gérer les scénarii « Online /
Offline » et les opérations de synchronisation des données. Pour
cela, il est donc nécessaire de stocker des données en local. Le
Compact Framework .Net permet de stocker et/ou de manipuler des
données de trois manières différentes : en utilisant des DataSet,
en créant des fichiers XML, ou en utilisant un SGBD léger développé
par Microsoft - SQL Server CE.
3.1. Les DataSet Le support du mode déconnecté est une des
nouveautés majeures d’ADO.Net par rapport au modèle ADO. En effet,
alors qu’autrefois, il fallait être tout le temps connecté à une
base de données pour effectuer des manipulations, il est désormais
possible d’avoir « une base de données en mémoire » et d’y
effectuer tout type d’opérations et ensuite de valider les
opérations effectuées vers une base de données. Cela est possible
grâce à l’objet DataSet qui permet de manipuler des tables
constituées de DataRows, auxquels on peut attribuer différentes
contraintes. Nous allons donc voir comment utiliser ces DataSet
dans le cadre du Compact Framework .NET afin de consulter et de
manipuler des données en mode déconnecté. Note : le Compact
Framework supporte uniquement les DataSet NON typés.
3.1.1. Création du DataSet La création de DataSet se fait très
simplement, il suffit de lui attribuer un ensemble de DataTable et
d’ajouter les colonnes à ces DataTable pour construire la structure
de la base que l’on souhaite manipuler. Dans notre cas, nous allons
créer une base contenant une table produits puis lui ajouter
quelques champs classiques :
Produits (id_produit, nom_produit, desc_produit,
qte_stock_produit) Exemple en VB.Net : Dim myDs As New
DataSet("Produits") Dim mydt As DataTable =
myDs.Tables.Add("Produit") mydt.Columns.Add("id_produit",
System.Type.GetType("System.Int32"))
mydt.Columns.Add("nom_produit",
System.Type.GetType("System.String"))
mydt.Columns.Add("desc_produit",
System.Type.GetType("System.String"))
mydt.Columns.Add("qte_stock_produit",
System.Type.GetType("System.Int32")) Exemple en C# : DataSet myds =
new DataSet("Produits"); DataTable mydt =
myds.Tables.Add("Produits"); DataTable =
myds.Tables.Add("Produit"); DataColumn col_IdProd = new
DataColumn("id_produit",System.Type.GetType("System.Int32"));
mydt.Columns.Add(col_IdProd); mydt.Columns.Add("id_produit",
System.Type.GetType("System.Int32"));
mydt.Columns.Add("nom_produit",
System.Type.GetType("System.String"));
mydt.Columns.Add("desc_produit",
System.Type.GetType("System.String"));
mydt.Columns.Add("qte_stock_produit",
System.Type.GetType("System.Int32"));
-
.NET Compact Framework 24 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
3.1.2. Les contraintes Il est également possible de définir des
contraintes afin de garantir l’intégrité de la base réalisée. Il
est possible de définir deux types de contraintes différentes :
• PrimaryKey : Cette contrainte permet de définir la clé
primaire d’une DataTable. Contrairement aux deux autres types de
contraintes que nous allons voir ci-dessous, cette contrainte se
définit via une propriété de la DataTable et non en instanciant un
objet de type Contrainte. Cette clé primaire peut être composée
d’une ou de plusieurs DataColumn, il est donc nécessaire
d’attribuer un tableau de DataColumn à la propriété PrimaryKeys
d’une DataTable, même si cette PrimaryKey n’est composée que d’une
DataColumn.
Exemple en C# :
DataColumn[] Pks = new DataColumn[1]; Pks[0] = col_IdProd;
mydt.PrimaryKey=Pks;
Exemple en VB.Net :
Dim Pks(0) As DataColumn Pks(0) = col_IdProd mydt.PrimaryKey =
Pks
• Clé étrangère : Cette contrainte vous permet de définir une
contrainte d’intégrité référentielle, une clé étrangère. Pour faire
cela, il est nécessaire d’utiliser l’objet DataRelation et
d’affecter cette DataRelation à la collection des DataRelations du
DataSet :
Exemple en C# : DataColumn columnParent; DataColumn columnChild;
columnParent = mydataset.Tables["Table1"].Columns["cléprimaire"];
columnChild= mydataset.Tables["Tables2"].Columns["cléétrangère"];
DataRelation myrelation = new
DataRelation("NomRelation",columnParent, columnChild,true);
mydataset.Relations.Add(myrelation);
3.1.3. Remplissage Il est à présent temps de remplir ce DataSet
de données. Nous souhaitons donc ajouter des enregistrements dans
les tables. Pour faire cela, il faut ajouter des objets de type
DataRow aux DataTables qui composent votre DataSet. Exemple en
VB.Net : Dim mydr As DataRow = mydt.NewRow mydr("id_produit") = 1
mydr("nom_produit") = "Chaises" mydr("desc_produit") = "Chaises à 4
pieds et avec un dossier" mydr("qte_stock_produit") = 83
mydt.Rows.Add(mydr)
-
.NET Compact Framework 25 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Exemple en C# : DataRow mydr= mydt.NewRow; mydr("id_produit") =
1; mydr("nom_produit") = "Chaise"; mydr("desc_produit") = "Chaise à
4 pieds et avec un dossier"; mydr("qte_stock_produit") = 83;
mydt.Rows.Add(mydr); mydr = mydt.NewRow; mydr("id_produit") = 2;
mydr("nom_produit") = "Tabouret"; mydr("desc_produit") = "Tabouret
à 3 pieds"; mydr("qte_stock_produit") = 83; mydt.Rows.Add(mydr);
Exemple en VB.Net : Dim mydr As DataRow = mydt.NewRow
mydr("id_produit") = 1 mydr("nom_produit") = "Chaise"
mydr("desc_produit") = "Chaise à 4 pieds et avec un dossier"
mydr("qte_stock_produit") = 83 mydt.Rows.Add(mydr) mydr =
mydt.NewRow mydr("id_produit") = 2 mydr("nom_produit") = "Tabouret"
mydr("desc_produit") = "Tabouret à 3 pieds"
mydr("qte_stock_produit") = 83 mydt.Rows.Add(mydr)
3.1.4. Consultation La consultation du DataSet ainsi construit
est très simple. Il suffit d’énumérer toutes les lignes d’une table
et de récupérer les valeurs correspondantes. Pour énumérer les
DataRows de la collection Rows d’une DataTable et récupérer les
valeurs des champs comme le montre le code suivant : Exemple en C#
: foreach (DataRow myrow in mydt.Rows) {
lstProduits.Items.Add(myrow("id_produit").ToString()); //faire
traitement afficher dans des contrôles (textbox, listbox, etc...) }
Exemple en VB.net : For Each myrow As DataRow In mydt.Rows
lstProduits.Items.Add(myrow("nom_produit").ToString) 'faire
traitement (afficher dans des textbox, listbox, etc...) Next Il est
également possible de binder des contrôles avec notre DataSet. Nous
pouvons par exemple remplir un contrôle DataGrid pour une
consultation des données agréables en lui attribuant en source
-
.NET Compact Framework 26 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
de données, le DataSet, que nous avons créé et rempli grâce à
notre code (voir paragraphe 2.2.3 Remplissage du DataGrid). Pour
cela placez un DataGrid sur un formulaire, et spécifiez sa
propriété DataSource en lui attribuant une DataTable. Exemple en C#
: dtgProduits.DataSource = mydt;
3.1.5. Sauvegarde Nous avons jusqu’à présent créé et manipulé
notre DataSet en mémoire. Il est pourtant souvent nécessaire de
pouvoir sauvegarder ce DataSet sur l’espace de stockage du
périphérique mobile afin de conserver les données. Pour faire cela,
le Compact Framework propose la méthode WriteXML de l’objet DataSet
qui permet de sauver le DataSet sous la forme d’un fichier XML très
simplement : Exemple en C# : myDs.WriteXml("Produits.xml") ; Le
fichier XML généré à partir du DataSet créé dans ce cours donne
:
Figure 27 – Fichier XML généré par le DataSet
Pour ensuite charger un DataSet à partir d’un fichier XML,
utilisez la méthode ReadXML qui charge automatiquement un fichier
et remplit le DataSet en conséquence à partir d’un flux ou d’un nom
de fichier. myDs.ReadXml("Produits.xml") ;
3.2. XML Il est également possible d’enregistrer des données
directement dans des fichiers XML sans passer par des DataSet. Cela
est possible grâce à l’objet XmlDocument largement décrit dans le
cours « XML et
-
.NET Compact Framework 27 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
.Net. » Nous allons voir à l’aide d’un exemple, comment créer un
fichier XML à l’aide de XMLDocument. Nous allons donc recréer à
l’aide d’un XMLDocument le fichier XML que nous avons précédemment
généré avec un DataSet. Exemple en C# : XmlDocument myxmldoc=new
XmlDocument(); XmlNode mynewnode = new XmlNode(); XmlNode
mymainnode = new XmlNode(); XmlNode myprodnode = new XmlNode();
//Ajout de l'élément racine "Produits" mymainnode =
myxmldoc.CreateElement("Produits"); myprodnode =
myxmldoc.CreateElement("Produit"); mynewnode =
myxmldoc.CreateElement("id_produit"); mynewnode.InnerText = "1";
myprodnode.AppendChild(mynewnode); mynewnode =
myxmldoc.CreateElement("nom_produit"); mynewnode.InnerText =
"Chaise"; myprodnode.AppendChild(mynewnode); mynewnode =
myxmldoc.CreateElement("desc_produit"); mynewnode.InnerText =
"Chaise à 4 pieds et avec un dossier";
myprodnode.AppendChild(mynewnode); mynewnode =
myxmldoc.CreateElement("qte_stock_produit"); mynewnode.InnerText =
"83"; myprodnode.AppendChild(mynewnode); //ajout de l'élément
"Produit" à "Produits" mymainnode.AppendChild(myprodnode);
//Création du deuxième élément "Produit" myprodnode =
myxmldoc.CreateElement("Produit"); mynewnode =
myxmldoc.CreateElement("id_produit"); mynewnode.InnerText = "2";
myprodnode.AppendChild(mynewnode); mynewnode =
myxmldoc.CreateElement("nom_produit"); mynewnode.InnerText =
"Tabouret"; myprodnode.AppendChild(mynewnode); mynewnode =
myxmldoc.CreateElement("desc_produit"); mynewnode.InnerText =
"Tabouret à 3 pieds"; myprodnode.AppendChild(mynewnode); mynewnode
= myxmldoc.CreateElement("qte_stock_produit"); mynewnode.InnerText
= "83"; myprodnode.AppendChild(mynewnode); //ajout de l'élément
"Produit" à "Produits" mymainnode.AppendChild(myprodnode); //ajout
de l'élement "Produits" au XMLDocument
myxmldoc.AppendChild(mymainnode); myxmldoc.Save("xmldoc.xml");
Exemple en VB.Net : Dim myxmldoc As New XmlDocument Dim mynewnode
As XmlNode Dim mymainnode As XmlNode Dim myprodnode As XmlNode
-
.NET Compact Framework 28 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
'Ajout de l'élément racine "Produits" mymainnode =
myxmldoc.CreateElement("Produits") myprodnode =
myxmldoc.CreateElement("Produit") mynewnode =
myxmldoc.CreateElement("id_produit") mynewnode.InnerText = "1"
myprodnode.AppendChild(mynewnode) mynewnode =
myxmldoc.CreateElement("nom_produit") mynewnode.InnerText =
"Chaise" myprodnode.AppendChild(mynewnode) mynewnode =
myxmldoc.CreateElement("desc_produit") mynewnode.InnerText =
"Chaise à 4 pieds et avec un dossier"
myprodnode.AppendChild(mynewnode) mynewnode =
myxmldoc.CreateElement("qte_stock_produit") mynewnode.InnerText =
"83" myprodnode.AppendChild(mynewnode) 'ajout de l'élément
"Produit" à "Produits" mymainnode.AppendChild(myprodnode) 'Création
du deuxième élément "Produit" myprodnode =
myxmldoc.CreateElement("Produit") mynewnode =
myxmldoc.CreateElement("id_produit") mynewnode.InnerText = "2"
myprodnode.AppendChild(mynewnode) mynewnode =
myxmldoc.CreateElement("nom_produit") mynewnode.InnerText =
"Tabouret" myprodnode.AppendChild(mynewnode) mynewnode =
myxmldoc.CreateElement("desc_produit") mynewnode.InnerText =
"Tabouret à 3 pieds" myprodnode.AppendChild(mynewnode) mynewnode =
myxmldoc.CreateElement("qte_stock_produit") mynewnode.InnerText =
"83" myprodnode.AppendChild(mynewnode) 'ajout de l'élément
"Produit" à "Produits" mymainnode.AppendChild(myprodnode) 'ajout de
l'élement "Produits" au XMLDocument
myxmldoc.AppendChild(mymainnode) myxmldoc.Save("xmldoc.xml")
3.3. SQL Server CE 3.3.1. Présentation
SQL Se ée de SQL Server destinée aux périphériques mobiles.
Cette version
oche de Microsoft Access que de
• as les procédures stockées
ependant ce logiciel est très intéressant car il permet de :
elles très léger et relativement puissant
érable de faire cela
rver CE est la version allégqui pèse près d’1 Mo, possède
beaucoup moins de fonctionnalités que son grand frère. Elle est
adaptée aux configurations matérielles des Pocket PC, et des
machines tournant sous Windows CE. Par conséquent il faut bien
comprendre et retenir que SQL Server CE :
• N’est pas un SGBD client / serveur (ce SGBD est plus prSQL
Server) Ne supporte p
• Ne supporte pas les triggers
C• Disposer d’un moteur de bases de données relationn•
Synchroniser les données simplement vers un SQL Server 6.5 ou
ultérieur • Construire une base de donnée via le Query Analyser
(même s’il est préf
via du code)
-
.NET Compact Framework 29 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
3.3.2. Installation SQL Server CE est installé par défaut avec
Visual Studio.Net 2003 sur votre poste développement. Vous pouvez
cependant le télécharger gratuitement (à des fins de tests et de
développement uniquement) à l’adresse suivante :
http://www.microsoft.com/sql/ce/downloads/default.asp Installation
sur un Pocket PC L’installation sur votre Pocket PC de
développement (ou l’émulateur) se fait très simplement. Il vous
suffit de rajouter une référence vers System.Data.SqlServerCe à
votre projet et déployer votre application sur votre périphérique
de test.
Figure 28 - Référence au namespace System.Data.SqlServerCe
Lors du déploiement, Visual Studio .Net 2003 installera
automatiquement SQL Server CE sur votre émulateur ou Pocket PC de
test comme vous pouvez le voir sur la figure suivante.
Figure 29 - Installation de SQL Server CE
http://www.microsoft.com/sql/ce/downloads/default.asp
-
.NET Compact Framework 30 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Une fois votre application déployée, vous pouvez constater qu’en
plus du moteur du SGBD une nouvelle application a été installée :
le Query Analyzer
Figure 30 - Query Analyser
Cet outil vous permet de créer et de manipuler les bases de
données présentes sur votre Pocket PC. Dans la pratique, il vous
permet d’effectuer des contrôles et de gérer vos bases de données,
la création des bases de données étant de préférence effectuée par
votre application grâce à du code que vous devez écrire dans la DAL
(couche d’accès aux données). Vous pouvez ainsi ponctuellement
insérer, modifier, supprimer des données ainsi que réparer ou
compacter vos bases de données via le Query Analyzer et effectuer
toutes vos opérations courantes via votre application.
3.3.3. Création d’une base de données SQL Server CE Comme dit
précédemment, il est possible de créer une base de données SQL
Server CE via du code .Net. Afin de faire cela, il est nécessaire
d’ajouter une référence au namespace System.Data.SqlServerCE à
votre projet. Une base de données SQL Server CE est un fichier
.sdf. Pour pouvoir vous connecter à votre base de données, il vous
suffira de fournir le chemin de ce fichier ainsi que les différents
preuves d’identité (login/password) nécessaires. Note : sur les
périphériques mobiles il n’existe pas de lettres de lecteur comme
sur les PC. Pour accéder à un fichier il est donc nécessaire
d’indiquer le chemin sans lettre C : ou D : comme ceci : "\Program
Files\Frais\Frais.sdf" Dans notre exemple, nous testerons la
présence de la base de données, puis si elle est absente nous la
créerons via du code. Pour cela, il est nécessaire d’utiliser
l’objet SQLCeEngine. Cet objet vous permet d’accéder directement au
moteur de base de données de SQL Server CE et ainsi d’effectuer
différentes opérations, telles que le compactage d’une base ou sa
création. Dans notre cas, nous utiliserons donc la méthode
CreateDatabase de l’objet SQLCeEngine pour créer notre base de
données. Une fois ceci fait, il suffit de se connecter à la base
ainsi créée et d’exécuter des requêtes de création de tables pour
définir le contenu de notre base.
-
.NET Compact Framework 31 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Astuce : Pour avoir des requêtes SQL de création de tables «
propres » sans se fatiguer, créez toutes vos tables graphiquement
ainsi que les contraintes sous SQL Server 2000 sur votre poste de
développement et générez le SQL correspondant aux tables ainsi
créés. Cela vous permettra d’avoir du code SQL bien fait en
quelques secondes. La connexion et l’exécution de requêtes SQL se
font analogiquement de la même manière qu’en ADO.net grâce à des
objets Connexions et Command. Dans notre cas, ce sont les objet de
type SQLCeConnection et SQLCeCommand. Exemple en C# : using
System.Data.SqlServerCe; using System.IO; public class clsdata {
private void CeDBFileName = "\\Program Files\\Frais\\Frais.sdf";
public void CreateCeDB() { if (!(File.Exists(CeDBFileName))) {
string cu_sql; string MyConnectionStr = "Data Source=" +
CeDBFileName; SqlCeEngine MySqlCeEngine = new
SqlCeEngine(MyConnectionStr); //créé la base de données
MySqlCeEngine.CreateDatabase(); SqlCeConnection myconnection = new
SqlCeConnection(MyConnectionStr); try { myconnection.Open();
SqlCeCommand mycmd; mycmd = myconnection.CreateCommand;
mycmd.CommandType = CommandType.Text; //remplir cu_sql avec
l'instruction pour créer les tables cu_sql = "CREATE TABLE
[dbo].[Types] ("; cu_sql += "[idtype] [int] NOT NULL ,"; cu_sql +=
"[nom] [varchar] (50) COLLATE French_CI_AS NOT NULL "; cu_sql += ")
ON [PRIMARY]"; mycmd.CommandText = cu_sql; mycmd.ExecuteNonQuery();
cu_sql = "CREATE TABLE [dbo].[Frais] ("; cu_sql += "[id] [char]
(10) COLLATE French_CI_AS NULL ,"; cu_sql += "[id_frais]
uniqueidentifier ROWGUIDCOL NOT NULL ,"; cu_sql += " [idtype] [int]
NULL ,"; cu_sql += " [nomtype] [varchar] (50) COLLATE French_CI_AS
NULL ,"; cu_sql += " [montant] [money] NOT NULL ,"; cu_sql += "
[id_perso] [int] NOT NULL ,"; cu_sql += " [datefrais] [datetime]
NOT NULL "; cu_sql += ") ON [PRIMARY]"; mycmd.CommandText = cu_sql;
mycmd.ExecuteNonQuery(); cu_sql = "CREATE TABLE [dbo].[Commerciaux]
("; cu_sql += "[idperso] [int] NOT NULL ,";
-
.NET Compact Framework 32 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
cu_sql += "[nom] [varchar] (50) COLLATE French_CI_AS NOT NULL
,"; cu_sql += "[prenom] [varchar] (50) COLLATE French_CI_AS NOT
NULL ,"; cu_sql += "[login] [varchar] (50) COLLATE French_CI_AS NOT
NULL ,"; cu_sql += "[password] [varchar] (50) COLLATE French_CI_AS
NOT NULL "; cu_sql += ") ON [PRIMARY]"; mycmd. u_sql; CommandText =
c mycmd.ExecuteNonQuery(); } catch (Exception ex) {
MsgBox(ex.Message, MsgBoxStyle.Exclamation); } } } } Exemple en
VB.Net : Imports System.Data.SqlServerCe Imports System.IO Public
Class clsdata Private CeDBFileName = "\Program
Files\Frais\Frais.sdf" Public Sub CreateCeDB() If Not
File.Exists(CeDBFileName) Then Dim cu_sql As String Dim
MyConnectionStr As String = "Data Source=" & CeDBFileName Dim
MySqlCeEngine As New SqlCeEngine(MyConnectionStr)
MySqlCeEngine.CreateDatabase() 'créé la base de données Dim
myconnection As New SqlCeConnection(MyConnectionStr) Try
myconnection.Open() Dim mycmd As SqlCeCommand mycmd =
myconnection.CreateCommand mycmd.CommandType = CommandType.Text
'remplir cu_sql avec l'instruction pour créer les tables cu_sql =
"CREATE TABLE [dbo].[Types] (" cu_sql += "[idtype] [int] NOT NULL
," cu_sql += "[nom] [varchar] (50) COLLATE French_CI_AS NOT NULL "
cu_sql += ") ON [PRIMARY]" mycmd.CommandText = cu_sql
mycmd.ExecuteNonQuery() cu_sql = "CREATE TABLE [dbo].[Frais] ("
cu_sql += "[id] [char] (10) COLLATE French_CI_AS NULL ," cu_sql +=
"[id_frais] uniqueidentifier ROWGUIDCOL NOT NULL ," cu_sql += "
[idtype] [int] NULL ," cu_sql += " [nomtype] [varchar] (50) COLLATE
French_CI_AS NULL ," cu_sql += " [montant] [money] NOT NULL ,"
cu_sql += " [id_perso] [int] NOT NULL ," cu_sql += " [datefrais]
[datetime] NOT NULL " cu_sql += ") ON [PRIMARY]" mycmd.CommandText
= cu_sql
-
.NET Compact Framework 33 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
mycmd.ExecuteNonQuery() cu_sql = "CREATE TABLE
[dbo].[Commerciaux] (" cu_sql += "[idperso] [int] NOT NULL ,"
cu_sql += "[nom] [varchar] (50) COLLATE French_CI_AS NOT NULL ,"
cu_sql += "[prenom] [varchar] (50) COLLATE French_CI_AS NOT NULL ,"
cu_sql += "[login] [varchar] (50) COLLATE French_CI_AS NOT NULL ,"
cu_sql += "[password] [varchar] (50) COLLATE French_CI_AS NOT NULL
" cu_sql += ") ON [PRIMARY]" mycmd.CommandText = cu_sql
mycmd.ExecuteNonQuery() Catch ex As Exception MsgBox(ex.Message,
MsgBoxStyle.Exclamation) End Try End If End Sub End Class
3.3.4. Insérer des données La man une base de données SQL Server
CE se fait en utilisant les
xemple en C# :
ipulation des données stockées dans objets ADO.Net « classiques
» adaptés au serveur SQL Server CE. Ainsi, l’insertion de données
peut se faire en ouvrant un objet de type SqlCeConnection et en
définissant un objet de type SqlCeCommand qui exécute l’insertion.
E public void InsertFrais(string text_type, int montant,
System.DateTime datefrais) { string requete; SqlCeConnection
myconnection = new SqlCeConnection("datasource = " + CeDBFileName);
SqlCeDataReader myr; int idtype = -1; myconnection.Open();
SqlCeCommand command = new SqlCeCommand("select idtype from types
where nom='" + text_type + "'", myconnection); myr =
command.ExecuteReader; if (myr.Read()) { idtype = myr(0); } if
(idtype != -1) { requete = "insert into fr id
,nomtype,montant,id_persais( o,date_frais) values (" + idtype +
type",NULL," + montant + ",1," + datefrais + ")"; } else { requete
= "insert into frais(idtype,nomtype,montant,id_perso,date_frais)
values (NULL," + text_type + "," + montant + ",1," + datefrais +
")";
-
.NET Compact Framework 34 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
} SqlCeCommand myInsertCmd = new SqlCeCommand(requete);
myInsertCmd.ExecuteNonQuery(); myInsertCmd.Dispose(); myr.Close();
myr.Dispose(); myconnection.Close(); myconnection.Dispose(); }
Exemple en VB.net : Public Sub InsertFrais(ByVal text_type As
String, ByVal montant As Integer, ByVal datefrais As Date) Dim
requete As String Dim myconnection As New
SqlCeConnection("datasource = " & CeDBFileName) Dim myr As
SqlCeDataReader Dim idtype As Integer = -1 myconnection.Open() Dim
command As SqlCeCommand = New SqlCeCommand("select idtype from
types where nom='" & text_type & "'", myconnection) myr =
command.ExecuteReader If myr.Read() Then idtype = myr(0) End If If
idtype -1 Then requete = "insert into
frais(idtype,nomtype,montant,id_perso,date_frais) values (" &
idtype & ",NULL," & montant & ",1," & datefrais
& ")" Else requete = "insert into
frais(idtype,nomtype,montant,id_perso,date_frais) values (NULL,"
& text_type & "," & montant & ",1," & datefrais
& ")" End If Dim myInsertCmd As New SqlCeCommand(requete)
myInsertCmd.ExecuteNonQuery() myInsertCmd.Dispose() myr.Close()
myr.Dispose() myconnection.Close() myconnection.Dispose() End
Sub
3.3.5. Modifier des données lusieurs méthodes pour modifier vos
données présentes dans une base de données SQL
Server C• in de modifier vos données en effectuant un UPDATE
en
er un DataSet océdure à suivre est très simple : Exemple en C#
:
Il existe pE :
utiliser un objet SQLCeCommand afSQL
• utilis . Dans ce cas là, la pr
//Ouverture d'une connexion MyConnection.Open(); DataSet
MyDataset = new DataSet(); MyDataAdapter.fill(MyDataSet);
//Remplissage du dataset //modification du dataset via votre
code...
-
.NET Compact Framework 35 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
//Pour valider la modification
MyDataAdapter.Update(MyDataSet,"NomTable"); MyConnection.Close();
MyConnection.Dispose();
3.3.6. Lire des données oit en mode déconnecté grâce à un
DataAdapter et un DataSet, ou
alors en der. Nous allons illustrer ce deuxième cas, car le
remplissage de Data précédent.
La lecture des données se fait s mode connecté via un DataReaSet
a déjà été vu dans l’exemple
Exemple en C# : SqlCeConnection myconnection = new
SqlCeConnection("datasource = " + CeDBFileName); SqlCeDataReader
myr; myconnection.Open(); SqlCeCommand command = new
SqlCeCommand("select * from frais", myconnection); myr =
command.ExecuteReader; while (myr.Read) {
listbox1.Items.Add(myr("montant")); } myr.Close(); myr.Dispose();
myconnection.Close(); myconnection.Dispose(); Exemple en VB.Net :
Dim myconnection As New SqlCeConnection("datasource = " &
CeDBFileName) Dim myr As SqlCeDataReader myconnection.Open() Dim
command As SqlCeCommand = New SqlCeCommand("select * from frais",
myconnection) myr = command.ExecuteReader While myr.Read
listbox1.Items.Add(myr("montant")) End While myr.Close()
myr.Dispose() myconnection.Close() myconnection.Dispose()
-
.NET Compact Framework 36 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
4. Accéder à des données distantes Une des besoins des
applications mobiles est qu’elles peuvent avoir besoin d’accéder à
des bases de données distantes, et en temps réel. C'est-à-dire que
l’application doit pouvoir consulter immédiatement des
informations, sans passer par un processus de synchronisation. Pour
pouvoir se connecter à des bases de données, il existe plusieurs
techniques :
• Interrogation d’un Web Service • Accès direct à une base de
données SQL Server grâce aux fournisseurs d’accès aux données
SQL Server • Autres méthodes qui seront peu détaillées
4.1. Interrogation d’un Web Service Les Web Services offre la
meilleure solution d’accès aux données distantes. En effet, ils
offrent les possibilités suivantes :
1 accéder à de multiples sources de donnée de différents SGBD :
le Compact Framework n’inclut en standard que les fournisseurs
d’accès SQL Server. Si vous voulez accéder à des bases de données
d’autre SGBD, il faut que vous passiez par un Web Service
2 Travailler en mode déconnecté : les Web Services ne renvoient
que des DataSet, qui sont des « copies locales » d’une partie de la
base de donnés
3 Accès aux données simplifié : comme les Web Services
fonctionnent avec le protocole http, il est possible dans la majeur
partie des cas d’accéder aux données à partir d’Internet.
4 Interopérabilité : le Web Service peut être mis à disposition
pour d’autres applications.
4.1.1. Création d’un Web Service Cette partie présente
rapidement, comment créer un Web Service. Il est possible de
trouver plus d’information sur la création des Web Services, grâce
au cours Web Service à l’adresse suivante :
http://www.labo-dotnet.com/cours/Cours%20du%20Laboratoire/Services%20Web/0/1290.aspx
Les Web Service repose sur des standards d’Internet, c'est-à-dire
http, XML et SOAP. En conséquence, les Web Services offrent un
grande accessibilité à tous type de client : il n’est plus
obligatoire d’ouvrir un port sur le Firewall, le port 80 étant
généralement ouvert. Pour créer un Web Service, il faut avoir IIS
d’installer sur le serveur qui fournira les donnés a votre
périphérique mobiles. Les Web Services se basent sur IIS pour gérer
les requêtes HTTP. Ensuite grâce à Microsoft Visual Studio 2003,
nous allons créer un Web Service. La création d’un Web Service se
résume à 3 étapes (ces étapes sont partiellement automatisées dans
Visual Studio):
• Première étapes : création un répertoire virtuel dans IIS Dans
Visual Studio, créer un nouveau projet de type ASP.NET Web Service
:
-
.NET Compact Framework 37 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 31 - Fenêtre de création d'un ASP.NET Web Service
Visual Studio créée alors les fichiers suivant :
• AssemblyInfo.cs contient les informations de votre
assemblé.
• Global.asax Service1.asmx est le fichier qui contient votre
code du Web Service.
• Web.config est le fichier de configuration de votre Web
Service.
• Deuxième étapes : création des méthodes exposées par le Web
Service (WebMethode)
Les méthodes exposées par un Web Service possèdent l’attribut de
méthode WebMethode et ont une visibilité public. L’attribut
WebMethode possède des paramètres supplémentaires dont vous
trouverez la liste dans le tableau ci-dessous.
-
.NET Compact Framework 38 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Attribut Description
CacheDuration Cet attribut permet de mettre le résultat du
WebService en cache pendant la durée spécifiée.
[WebMethod(CacheDuration=60)] public int AddNumbers(int num1, int
num2) Le résultat de l’exécution de la WebMethode AddNumbers sera
mis en cache pendant 60 secondes
Description Cet attribut permet d’ajouter une description à
votre WebMethode.EnableSession Cet attribut autorise l’accès aux
objet de la collection Session
(http.Context.Current.Session) MessageName Cet attribut renomme
la WebMethode. En effet, il est impossible que
des WebMethodes possèdent le même nom.
[WebMethod(MessageName="AjouteEntier")] public int AddNumbers(int
num1, int num2) { return (num1+num2); }
[WebMethod(MessageName="AjouteLong")] public long AddNumbers(long
num1, long num2) { return (num1+num2); }
Tableau 5- Description des attributs d'une Web méthode Dans le
fichier Service1.asmx, créer une WebMethode,
GetTenMostExpensiveProducts. Cette méthode renvoie une liste de 10
produits les plus chers de la base de données Northwind de SQL
Server. [WebMethod()] public DataSet GetTenMostExpensiveProducts()
{ System.Data.SqlClient.SqlConnection myConnection = new
System.Data.SqlClient.SqlConnection("server=localhost;database=northwind;Trusted_Connection=yes");
System.Data.SqlClient.SqlDataAdapter myAdapter = new
System.Data.SqlClient.SqlDataAdapter("Ten Most Expensive
Products",myConnection); myAdapter.SelectCommand.CommandType=
System.Data.CommandType.StoredProcedure; DataSet results = new
DataSet(); myAdapter.Fill(results); return results; }
• Troisième étapes : appelle du WebService à l’aide d’Internet
Explorer Cette étapes permet de vérifiez si votre WebService
fonctionne. Pour cela, cliquez que Debug. Visual Studio lance alors
IE :
-
.NET Compact Framework 39 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 32 - Vérification du Web Service
La page ci-dessus décrit le Web Service. Il est possible alors
d’afficher les résultats de la WebMethode
GetTenMostExpensiveProducts en cliquant sur le lien
GetTenMostExpensiveProducts.
-
.NET Compact Framework 40 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 33 - Affichage du résultat de l'appel de la Web
méthode
En cliquant sur Invoke, vous obtenez un fichier XML qui est le
résultat de votre WebMethode. En cliquant sur Invoke, la webMethod
est executée. Si vous avez placé des points d’arrêts, vous pouvez
deboguer Note : si vous développez avec Microsoft Windows 2003, ou
avec IIS6, le bouton Invoke n’est pas disponible pour des raison de
sécurité. Après avoir créer notre Web Service, nous allons
l’interroger.
4.1.2. Interrogation du Web Service à partir d’une application
mobile Pour utiliser un Web Service, il faut ajouter une Web
Référence. L’ajout de la Web Reference vas permettre de créer une
class Proxy qui vas faire la jonction entre le service Web et votre
code. Pour créer cette Web Référence, nous allons utiliser Visual
Studio. Dans votre projet Pocket PC, faites un clic droit sur
Référence et sélectionnez Ajouter une Web Référence (voir
ci-dessous)
-
.NET Compact Framework 41 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 34 - Ajouter une Web Référence à l'aire de Visual
Studio
Ensuite, il faut spécifier l’URL du Web Service. Vous avez
plusieurs possibilités :
• Vous connaissez l’adresse du Web Service. Dans ce cas la, vous
la spécifiez. • Vous ne connaissez pas l’adresse du Web Service au
sein de votre intranet. Dans ce cas la,
vous allez interroger un serveur UDDI de l’intranet. Un serveur
UDDI est un annuaire de Web Service, qui peut regrouper tous les
Web Service exposés sur votre intranet.
• Vous ne connaissez pas l’adresse du Web Service sur Internet.
Vous allez interroger l’UDDI de Microsoft. Vous allez spécifier des
critères de recherche, et UDDI vous exposera des Web Services
répondant à vos critères.
Figure 35 - Fenêtre de localisation du Web Service
Nous avons donc développé un Service Web locale service1.asmx,
qui nous permet à l’aide de la Web méthode HelloWorld de renvoyer
une String Hello World. Nous faisons une référence vers ce service
et nommons cette référence hello. En cliquant sur Add Reference,
une class proxy est automatiquement créée. C’est cette classe que
nous appelons pour utiliser le Web Service.
-
.NET Compact Framework 42 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 36 - Ajout de la Web Reference dans le projet PPC
Voici le code qui appelle la Web Méthode : hello.Service1 temp =
new PPC.hello.Service1(); label1.Text = temp.HelloWorld(); Note :
Il est possible de faire des appels à des Web méthode de façon
asynchrone. Les appels asynchrones permettent de ne pas attendre la
fin de l’appel de la Web méthode. En effet, en fonction du trafic
sur votre réseau ou d’Internet, la réponse de la Web méthode peut
prendre du temps. Dans le cas des appels synchrones, le programme
attend la fin d’exécution de la méthode et donc bloque
l’application, ce qui n’est pas le cas avec les appels
asynchrones.
4.2. Accès directe à une base de données SQL Server Une autre
méthode pour accéder à des bases de données distantes, est de
communiquer directement avec le SGBD, grâce à ADO.NET (en mode
connecté). L’avantage d’une connexion directe à la base de donnée,
c'est-à-dire sans pas utiliser les DataSet, est d’offrir des
meilleures performances et une diminution de la bande passante. Par
contre, les applications qui utilisent des connexions directes à la
base de donnée peuvent limiter les cas d’utilisations. En effet, le
périphérique doit être constamment être connecté au réseau, où se
situe le SGBD. Le code suivant permet d’afficher dans une ListBox,
la liste des produits de la base de donnée Northwind. SqlConnection
connection = new
SqlConnection("server=172.16.104.63;database=northwind; User
Id='sa';pwd='as';Integrated Security=sspi"); SqlCommand command =
new SqlCommand("SELECT * FROM products",connection);
command.CommandType = CommandType.Text; connection.Open();
SqlDataReader reader = command.ExecuteReader(); while
(reader.Read()) { listBox1.Items.Add(reader.GetString(1)); }
-
.NET Compact Framework 43 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
reader.Close(); connection.Close(); Le principe est le suivant
:
• Création d’une connexion vers le SGBD grâce à l’objet
SqlConnection • Définition de la commande SQL à exécuter grâce à
l’objet SqlCommand. • Création d’un objet SqlDataReader pour
récupérer les données • Ouverture de la connexion vers le SGBD,
grâce à la méthode Open de l’objet
SqlConnection • Récupération des données dans le SqlDataReader,
grâce à la commande ExecuteReader
de l’objet SqlCommand • Traitement des données avec le
SqlDataReader • Après traitement, fermeture de la connexion vers le
SGBD.
Note : Ne pas oublier d’ajouter la référence
System.Data.SqlClient au projet, pour utiliser les objets
SqlConnection, SqlCommand et SqlDataReader. Il est possible
d’utiliser l’authentification intégrée, cependant il faut, soit,
autoriser l’utilisateur Invité ou Guest à accéder à la base de
donnée, ou alors s’authentifier en passant par un VPN ou en
accédant à un partage sur le serveur SQL. Tout comme avec le
Framework, l’utilisation des procédures stockées est implémentée.
Elle offre une sécurité avancée, dans la mesure ou le DBA peut
contrôler l’accès aux données. C'est-à-dire, il peut par exemple
donner uniquement accès aux procédures stockées, et interdire
toutes lectures sur les tables ou autres objets de la base de
données. SqlConnection connection = new
SqlConnection("server=172.16.104.17;database=northwind; User
Id='sa';pwd='aqzsed123.';Integrated Security=no"); SqlCommand
command = new SqlCommand("Employee Sales by Country",connection);
command.CommandType = CommandType.StoredProcedure; SqlParameter
myParam = new SqlParameter("@Beginning_Date",SqlDbType.DateTime);
myParam.Value = "08/16/1996"; command.Parameters.Add(myParam);
SqlParameter myParam1 = new
SqlParameter("@Ending_Date",SqlDbType.DateTime); myParam1.Value =
"09/10/1996"; command.Parameters.Add(myParam1); connection.Open();
SqlDataReader reader = command.ExecuteReader(); while
(reader.Read()) { listBox1.Items.Add(reader.GetString(1)); }
reader.Close(); connection.Close(); Le principe dans l’exemple
ci-dessus a un peu changé. Dans l’objet SqlCommand, la requête SQL
a été remplacée par le nom de la procédure stockée "Employee Sales
by Country". La propriété CommmandType de l’objet SqlCommand permet
de spécifier que l’on appelle une procédure stockée.
-
.NET Compact Framework 44 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Les paramètres nécessaires à la procédure stockée sont créés par
l’instanciation de la classe SqlParameter. Remarque : dans cet
exemple, les directions des paramètres ne sont pas précisées. La
propriété Direction permet de spécifier la direction du paramètre.
Dans le cas de procédure stockée, qui renvoit des paramètres (ces
paramètres sont déclarés comme Output dans la procédure stockée),
il faut définir la direction Output aux objets SqlParameter qui
récupèrent les valeurs. Ils sont ensuite ajoutés à la collection
Parameters de l’objet SqlCommand par la méthode Add. La suite est
identique : ouverture de la connexion, récupération des
données…
-
.NET Compact Framework 45 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
5. Synchronisation de SQL Server CE 5.1. Introduction
La synchronisation est une des étapes essentielles de la gestion
des données pour des périphériques mobiles. En effet, il est
fréquemment nécessaire de pouvoir télécharger et uploader les
données locales stockées sur le périphérique mobile vers un serveur
de l’entreprise. Microsoft propose pour cela deux technologies
différentes :
• Remote Data Access (RDA) permet d’effectuer des
synchronisations vers un serveur SQL Server 6.5 service pack 5 ou
ultérieur. Cette API, simple à utiliser, vous permet de récupérer
des enregistrements et d’en uploader en peu de lignes de code.
• Merge Replication qui nécessite SQL Server 2000
Ces deux technologies nécessitent une base de données SQL Server
pour fonctionner mais il est également possible de synchroniser des
données vers tout autre type des serveur de données (Oracle,
AS/400, fichiers, etc…) en utilisant par exemple les serveurs
liés.
5.2. Remote Data Access Remote Data Access (RDA) est une API
simple à utiliser qui permet de synchroniser des données entre un
serveur SQL Server CE et un serveur SQL Server 6.5 et ultérieur.
Pour ce faire, cette synchronisation s’appuie sur le protocole HTTP
et nécessite la présence d’Internet Information Server (IIS) sur le
serveur SQL Server 6.5 ou ultérieur.. On pourra donc si besoin
utiliser les fonctionnalités d’authentification / autorisation de
IIS et même utiliser le protocole SSL afin de chiffrer les données,
lors de la communication entre les deux serveurs de bases de
données. Cette API se résume à l’utilisation de trois méthodes
:
• Pull (récupération de données), • Push (Envoi de données), •
SubmitSQL (exécute des requêtes SQL sur un poste distant).
L’API RDA se site au niveau du namespace
System.Data.SqlServerCe.SqlCeRemoteDataAccess. Il est donc pratique
de faire un using (C#) ou un Imports (VB.Net) afin de manipuler les
objets du namespace plus simplement.
5.2.1. Installation Il est nécessaire d’installer le SQL Server
CE Agent sur le poste distant. Cet agent est un filtre ISAPI qui
s’exécute via IIS et qui exécute toutes les opérations sur le SQL
Server distant comme le montre la figure ci-dessous.
-
.NET Compact Framework 46 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 37 - Synchronisation de SQL Server CE avec RDA
Vous pouvez télécharger SQL Server CE, à l’adresse suivante :
http://www.microsoft.com/downloads/details.aspx?displaylang=fr&FamilyID=b974ba7a-a9fa-49d1-bbb7-2bee43cf64d7
(Version pour SQL Server 2000 Service Pack 3)
Figure 38 - Installation de SQL Server CE Agent
N’oubliez pas de cochez pas « Server Tools » pour installer les
bibliothèques serveur nécessaire à l’exécution des synchronisation
via RDA. Une fois l’installation effectuée, un nouvel assistant
s’affiche et vous permet de créer le répertoire virtuel utilisé par
le filtre ISAPI du SQL Server CE Server Agent (Sscesa20.dll).
http://www.microsoft.com/downloads/details.aspx?displaylang=fr&FamilyID=b974ba7a-a9fa-49d1-bbb7-2bee43cf64d7http://www.microsoft.com/downloads/details.aspx?displaylang=fr&FamilyID=b974ba7a-a9fa-49d1-bbb7-2bee43cf64d7
-
.NET Compact Framework 47 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 39 - Assistant d'installation
Entrez le nom du répertoire virtuel à créer. Par exemple :
rda
Figure 40 - Définition du serveur IIS
SQL Server CE Server Agent est un filtre ISAPI (Sscesa20.dll) et
s’appuie donc sur Internet Information Server (IIS). Vous pouvez
donc profiter des mécanismes du serveur web de Microsoft afin de
mettre en place une synchronisation sécurisée :
-
.NET Compact Framework 48 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 41 - Définition des sécurités du serveur IIS
Les 3 types d’authentification sont possibles :
• Accès anonyme : Aucun crédential (Login/password) n’est
nécessaire, le compte IUSR_NOMMACHINE sera utilisé pour se
connecter.
• Authentification basique : une authentification basique sera
effectuée, l’utilisateur devra fournir un login mot de passe qui
seront transmis en clair durant la connexion. Il est donc
préférable de coupler ce type d’authentification avec SSL qui
cryptera toutes les communications afin d’éviter que le login/mot
de passe ne soient interceptés durant le transport réseau.
• Authentification Windows : les informations du compte
utilisateur de Windows seront utilisées pour
l’authentification.
L’étape suivante permet de spécifier si vous allez mettre en
place une « Merge Replication ». Décochez cette case pour le
moment.
-
.NET Compact Framework 49 / 55
http://www.labo-dotnet.com Ce document est la propriété de
SUPINFO et est soumis aux règles de droits d’auteurs
Figure 42 – Activation du Mege Replication
Pour vérifier que l’installation du SQL Server CE Server Agent
s’est bien déroulée, afficher l’url
http://localhost/rda/sscesa20.dll dans votre navigateur (si RDA est
le répertoire virtuel que vous avez créé). La chaîne « SQL Server
CE Server Agent » sera alors affichée si l’installation s’est bien
déroulée.
Figure 43 - Vérification de l'installation de SQL Server CE
Note : Vous pouvez modifier les paramètres entrés durant
l’installation
5.2.2. Récupération de données grâce à la méthode PULL La
méthode PULL permet de récupérer de