NET Compact Framework - Freeentrepotforall.free.fr/Cours 2004-2005/Dotnet/NET Compact Framew… · .Net ne sont pas incluses comme par exemple ASP.Net qui est totalement inutile

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



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).



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/



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



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).



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 ».



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



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



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.



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"));



// 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 /// /// ///



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.



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).



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;



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): {



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"; }



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.



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).



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 :



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



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...



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"));



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)



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



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. » 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



'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)



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



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.



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 ,";



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



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 + ")";



} 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...



//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()



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 :



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.



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 :



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.



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)



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.



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)); }



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.



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…



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.



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



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 :



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.



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

Documents

NET Compact Framework - Freeentrepotforall.free.fr/Cours 2004-2005/Dotnet/NET Compact Framew… · .Net ne sont pas incluses comme par exemple ASP.Net qui est totalement inutile