Vous êtes sur la page 1sur 123

Contents

Découvrir
Qu’est-ce que Xamarin
Installation
Installation de Xamarin sur Windows
Installation des préversions Xamarin (Windows)
Désinstallation de Xamarin de Visual Studio
Installation de Visual Studio pour Mac
Installation des préversions Xamarin (Mac)
Désinstallation de Visual Studio pour Mac
Instructions de configuration du pare-feu Xamarin
Plateformes prises en charge
Première application
Démarrages rapides
Fichier > Nouveau
Multipage
Base de données
Style
Immersion
Tutoriels
Disposition de pile
Étiquette
Bouton
Entrée de texte
Éditeur de texte
Images
Disposition de grille
Listes
Fenêtres contextuelles
Cycle de vie de l'application
Base de données locale
SERVICES WEB
En savoir plus sur Xamarin
Développeurs .NET
Développeurs Java
Développeurs Objective-C
Azure
Conseils de développement
Qu’est-ce que Xamarin ?
05/10/2020 • 9 minutes to read • Edit Online

Xamarin est une plateforme open source qui permet de générer des applications modernes et performantes pour
iOS, Android et Windows avec .NET. Xamarin est une couche d’abstraction qui gère la communication entre le code
partagé et le code de plateforme sous-jacent. Xamarin s’exécute dans un environnement managé qui offre des
commodités telles que l’allocation de mémoire et le garbage collection.
Xamarin permet aux développeurs de partager en moyenne 90 % de leur application entre les plateformes. Ce
modèle permet aux développeurs d’écrire toute leur logique métier dans un seul langage (ou de réutiliser du code
d’application existant) tout en obtenant des performances, une apparence et une convivialité natives sur chaque
plateforme.
Les applications Xamarin peuvent être écrites sur PC ou Mac et être compilées dans des paquets d’application
natifs, par exemple un fichier .apk sur Android ou un fichier .ipa sur iOS.

NOTE
La compilation et le déploiement d’applications pour iOS nécessitent une machine macOS. Pour plus d’informations sur les
exigences relatives au développement, consultez Configuration requise.

À qui s’adresse Xamarin


Xamarin s’adresse aux développeurs qui ont les objectifs suivants :
Partager le code, les tests et la logique métier entre les plateformes.
Écrire des applications multiplateformes en C# avec Visual Studio

Fonctionnement de Xamarin
Le diagramme montre l’architecture globale d’une application Xamarin multiplateforme. Xamarin vous permet de
créer une IU native sur chaque plateforme et d’écrire une logique métier en C#, qui est partagée entre les
plateformes. Dans la plupart des cas, 80 % du code d’application peut être partagé à l’aide de Xamarin.
Xamarin repose sur .NET, qui gère automatiquement les tâches telles que l’allocation de mémoire, les garbage
collection et l’interopérabilité avec les plateformes sous-jacentes.
Pour plus d’informations sur l’architecture spécifique à la plateforme, consultez Xamarin.Android et Xamarin.iOS.
Fonctionnalités ajoutées
Xamarin combine les fonctionnalités des plateformes natives et ajoute un certain nombre de fonctionnalités,
notamment :
1. Liaison complète pour les kits SDK sous-jacents - Xamarin contient des liaisons pour la quasi-totalité des
kits SDK de plateforme sous-jacents, à la fois pour iOS et Android. En outre, ces liaisons sont fortement typées,
ce qui signifie qu’il est facile de les parcourir et de les utiliser. En outre, elles fournissent un contrôle de type
robuste au moment de la compilation et pendant le développement. Les liaisons fortement typées entraînent
moins d’erreurs d’exécution et produisent des applications de meilleure qualité.
2. Objective-C, Java, C et C++ Interop - Xamarin fournit des fonctionnalités qui permettent d’appeler
directement les bibliothèques Objective-C, Java, C et C++. Ainsi, vous pouvez utiliser du code tiers dans un large
éventail de scénarios. Cette fonctionnalité vous permet d’utiliser les bibliothèques iOS et Android existantes
écrites en Objective-C, Java ou C/C++. De plus, Xamarin propose des projets de liaison qui vous permettent de
lier des bibliothèques Objective-C et Java natives à l’aide d’une syntaxe déclarative.
3. Constructions de langage moderne - Les applications Xamarin sont écrites en C#. Ce langage moderne
inclut des améliorations significatives par rapport à Objective-C et Java par exemple les fonctionnalités de
langage dynamique, les constructions fonctionnelles telles que les lambdas, LINQ, la programmation parallèle,
les génériques et bien d’autres choses encore.
4. Bibliothèque de classes de base robuste - Les applications Xamarin utilisent la BCL (bibliothèque de classes
de base) .NET. Il s’agit d’une vaste collection de classes qui comprennent des fonctionnalités complètes,
rationalisées et puissantes, telles que la prise en charge du langage XML, des bases de données, de la
sérialisation, des E/S, des chaînes, des réseaux, et bien d’autres choses encore. Vous pouvez compiler du code C#
existant pour l’utiliser dans une application. Ainsi, vous avez accès à des milliers de bibliothèques qui offrent des
fonctionnalités supplémentaires dont ne dispose pas la BCL.
5. IDE (environnement de développement intégré) moderne - Xamarin utilise Visual Studio, un IDE
moderne qui inclut des fonctionnalités telles que l’autocomplétion du code, un système de gestion de projets et
de solutions sophistiqué, une bibliothèque complète de modèles de projet, un contrôle de code source intégré,
et bien d’autres choses encore.
6. Prise en charge multiplateforme mobile - Xamarin offre une prise en charge multiplateforme sophistiquée
pour les trois principales plateformes : iOS, Android et Windows. Les applications peuvent être écrites pour
partager jusqu’à 90% de leur code et Xamarin.Essentials offrent une API unifiée pour accéder aux ressources
communes sur les trois plateformes. En utilisant du code partagé, les développeurs mobiles peuvent réduire
considérablement les coûts de développement et les délais de commercialisation.
Xamarin.Android

Les applications Xamarin.Android sont compilées du C# en IL (langage intermédiaire) , lequel fait ensuite l’objet
d’une compilation JIT ( juste-à-temps) en assembly natif au moment du lancement de l’application. Les
applications Xamarin.Android s’exécutent dans l’environnement d’exécution Mono, côte à côte avec la machine
virtuelle ART (Android Runtime). Xamarin fournit des liaisons .NET aux espaces de noms Android.* et Java.*.
L’environnement d’exécution Mono fait appel à ces espaces de noms via les wrappers MCW (Managed Callable
Wrappers) , et fournit les wrappers ACW (Android Callable Wrappers) à la machine virtuelle ART, ce qui
permet aux deux environnements d’appeler du code.
Pour plus d’informations, consultez Architecture de Xamarin.Android.
Xamarin.iOS

Les applications Xamarin.iOS sont entièrement compilées AOT (Ahead Of Time) du C# en code d’assembly ARM
natif. Xamarin utilise des sélecteurs pour exposer Objective-C au C# managé et des registres pour exposer le
code C# managé à Objective-C. Les sélecteurs et les registres sont collectivement appelés des « liaisons », et
permettent à Objective-C et C# de communiquer.
Pour plus d’informations, consultez Architecture de Xamarin.iOS.
Xamarin.Essentials
Xamarin.Essentialsest une bibliothèque qui fournit des API multiplateforme pour les fonctionnalités d’appareils
natifs. Comme Xamarin lui-même, Xamarin.Essentials est une abstraction qui simplifie le processus d’accès aux
fonctionnalités natives. Voici quelques exemples de fonctionnalités fournies par Xamarin.Essentials :
Informations sur l’appareil
Système de fichiers
Accéléromètre
Numéroteur téléphonique
Synthèse vocale
Verrouillage d’écran
Pour plus d’informations, consultez Xamarin.Essentials.
Xamarin.Forms
Xamarin.Formsest une infrastructure d’interface utilisateur Open source. Xamarin.Formspermet aux développeurs
de générer des applications Xamarin. iOS, Xamarin. Android et Windows à partir d’un code base partagé unique.
Xamarin.Formspermet aux développeurs de créer des interfaces utilisateur en XAML avec code-behind en C#. Ces
interfaces utilisateur sont affichées en tant que contrôles natifs performants sur chaque plateforme. Voici quelques
exemples de fonctionnalités fournies par Xamarin.Forms :
Langage d’interface utilisateur XAML
Liaison de données
Mouvements
Effets
Styles
Pour plus d’informations, consultez Xamarin.Forms.

Bien démarrer
Les guides suivants vont vous aider à générer votre première application à l’aide de Xamarin :
Prise en main deXamarin.Forms
Bien démarrer avec Xamarin.Android
Bien démarrer avec Xamarin.iOS
Bien démarrer avec Xamarin.Mac

Vidéo connexe
Retrouvez d’autres vidéos Xamarin sur Channel 9 et YouTube.
Installation de Xamarin
05/10/2020 • 4 minutes to read • Edit Online

Guide pratique pour configurer Visual Studio et Xamarin afin de commencer à générer des applications mobiles
avec .NET.

Installation de Xamarin sur Windows

Instructions pas à pas


Vous pouvez installer Xamarin dans le cadre d’une nouvelle installation de Visual Studio 2019, en effectuant les
étapes suivantes :
1. Téléchargez Visual Studio 2019 Community, Visual Studio Professional ou Visual Studio Enterprise à partir
de la page de Visual Studio (les liens de téléchargement se trouvent au bas de la page).
2. Double-cliquez sur le paquet téléchargé pour démarrer l’installation.
3. Sélectionnez la charge de travail Développement mobile en .NET dans l’écran d’installation :

4. Une fois que vous êtes prêt à démarrer l’installation de Visual Studio 2019, cliquez sur le bouton Installer
en bas à droite :

Utilisez les barres de progression pour superviser l’installation :


5. Une fois l’installation de Visual Studio 2019 effectuée, cliquez sur le bouton Lancer pour démarrer Visual
Studio :

Ajout de Xamarin à Visual Studio 2019


Si Visual Studio 2019 est déjà installé, ajoutez Xamarin en réexécutant le programme d’installation de Visual
Studio 2019 pour modifier les charges de travail (pour plus d’informations, consultez Modifier Visual Studio).
Ensuite, suivez les étapes répertoriées ci-dessus pour installer Xamarin.
Pour plus d’informations sur le téléchargement et l’installation de Visual Studio 2019, consultez Installer Visual
Studio 2019.

Installation de Xamarin sur Windows

Instructions pas à pas


Xamarin peut être installé dans le cadre d’une nouvelle installation de Visual Studio 2017, en effectuant les étapes
suivantes :
1. Téléchargez Visual Studio 2017 Community, Visual Studio Professional ou Visual Studio Enterprise dans la
page Visual Studio (les liens de téléchargement se trouvent au bas de la page).
2. Double-cliquez sur le paquet téléchargé pour démarrer l’installation.
3. Sélectionnez la charge de travail Développement mobile en .NET dans l’écran d’installation :
4. Une fois l’option Développement mobile en .NET sélectionnée, regardez le panneau Détails de
l’installation à droite. Ici, vous pouvez désélectionner les options de développement mobile que vous ne
souhaitez pas installer.

5. Quand vous êtes prêt à installer Visual Studio 2017, cliquez sur le bouton Installer en bas à droite :

Selon l’édition de Visual Studio 2017 que vous installez, le processus d’installation peut prendre un certain
temps. Vous pouvez surveiller l’installation à l’aide des barres de progression :
6. Quand l’installation de Visual Studio 2017 est terminée, cliquez sur le bouton Lancer pour démarrer Visual
Studio :

Ajout de Xamarin à Visual Studio 2017


Si Visual Studio 2017 est déjà installé, ajoutez Xamarin en réexécutant le programme d’installation de Visual
Studio 2017 pour modifier les charges de travail (pour plus d’informations, consultez Modifier Visual Studio).
Ensuite, suivez les étapes répertoriées ci-dessus pour installer Xamarin.
Pour plus d’informations sur le téléchargement et l’installation de Visual Studio 2017, consultez Téléchargement et
installation de Visual Studio.

Installation de Xamarin sur macOS

Instructions pas à pas


En plus de cette vidéo, il existe un guide d’installation pas à pas, qui traite de Visual Studio pour Mac et de Xamarin.

Liens connexes
Désinstallation de Xamarin
Instructions de configuration du pare-feu Xamarin
Installation de Xamarin dans Visual Studio 2019
05/10/2020 • 3 minutes to read • Edit Online

Vérifiez la configuration requise avant de commencer.

Installation
Vous pouvez installer Xamarin dans le cadre d’une nouvelle installation de Visual Studio 2019, en effectuant les
étapes suivantes :
1. Téléchargez Visual Studio 2019 Community, Visual Studio Professional ou Visual Studio Enterprise à partir
de la page de Visual Studio (les liens de téléchargement se trouvent au bas de la page).
2. Double-cliquez sur le paquet téléchargé pour démarrer l’installation.
3. Sélectionnez la charge de travail Développement mobile en .NET dans l’écran d’installation :

4. Une fois que vous êtes prêt à démarrer l’installation de Visual Studio 2019, cliquez sur le bouton Installer
en bas à droite :

Utilisez les barres de progression pour superviser l’installation :

5. Une fois l’installation de Visual Studio 2019 effectuée, cliquez sur le bouton Lancer pour démarrer Visual
Studio :

Ajout de Xamarin à Visual Studio 2019


Si Visual Studio 2019 est déjà installé, ajoutez Xamarin en réexécutant le programme d’installation de Visual
Studio 2019 pour modifier les charges de travail (pour plus d’informations, consultez Modifier Visual Studio).
Ensuite, suivez les étapes répertoriées ci-dessus pour installer Xamarin.
Pour plus d’informations sur le téléchargement et l’installation de Visual Studio 2019, consultez Installer Visual
Studio 2019.
Dans Visual Studio 2019, vérifiez que Xamarin est installé en cliquant sur le menu Aide . Si Xamarin est installé,
vous devriez voir l’élément de menu Xamarin , comme dans cette capture d’écran :

Vous pouvez cliquer sur Aide > À propos de Microsoft Visual Studio , puis faire défiler la liste des produits
installés pour voir si Xamarin y figure :
Pour savoir où trouver les informations de version, consultez Où trouver les informations de version et les
journaux ?.

Étapes suivantes
L’installation de Xamarin dans Visual Studio 2019 vous permet d’écrire du code pour vos applications. Toutefois,
vous devez procéder à une configuration supplémentaire pour générer et déployer vos applications sur un
simulateur, un émulateur ou un appareil. Consultez les guides suivants pour terminer l’installation et commencer la
création d’applications multiplateformes.
iOS
Pour plus d’informations, consultez le guide Installation de Xamarin.iOS sur un système Windows.
1. Installer Visual Studio pour Mac
2. Connecter Visual Studio à votre hôte de build Mac
3. Configuration développeur iOS (nécessaire pour exécuter votre application sur l’appareil)
4. Remoted iOS Simulator
5. Introduction à Xamarin.iOS pour Visual Studio
Android
Pour plus d’informations, consultez le guide Installation de Xamarin.Android sur un système Windows.
1. Configuration de Xamarin.Android
2. Utilisation de Xamarin Android SDK Manager
3. Émulateur du kit Android SDK
4. Configurer un appareil pour le développement
Installation de la préversion Xamarin sur W
05/10/2020 • 2 minutes to read • Edit Online

Visual Studio 2019 et Visual Studio 2017 ne prennent pas en charge les canaux alpha, bêta et stables de la même
manière que les versions antérieures. Au lieu de cela, il n’existe que deux options :
Mise en production : équivalente au canal Stable dans Visual Studio pour Mac
Préversion : équivalent aux canaux Alpha et Bêta dans Visual Studio pour Mac

TIP
Pour tester les fonctionnalités de préversion, vous devez télécharger le programme d’installation de Visual Studio Preview, qui
permet d’installer des préversions (Preview ) de Visual Studio côte à côte avec la version stable (version release). Pour plus
d’informations sur les nouveautés de Visual Studio 2019, consultez les notes de publication.

La Préversion de Visual Studio peut inclure Des Préversions correspondantes de la fonctionnalité Xamarin, y
compris :
Xamarin.Forms
Xamarin.iOS
Xamarin.Android
Xamarin Profiler
Xamarin Inspector
Xamarin Remote iOS Simulator
La capture d’écran Programme d’installation de la préversion ci-dessous affiche les options Préversion et
Mise en production (Notez les numéros de version en gris : la version 15.0 est mise en production et la version 15.1
est une Préversion) :
Pendant le processus d’installation, un Surnom de l’Installation peuvent être appliqués à l’installation côte à côte
(afin de pouvoir les distinguer dans le menu Démarrer), comme indiqué ci-dessous :

Désinstallation de Visual Studio 2019 Preview


Vous devez également utiliser le programme Visual Studio Installer pour désinstaller les préversions de Visual
Studio 2019. Lisez le guide de désinstallation Xamarin pour plus d’informations.
Désinstaller Xamarin de Visual Studio
05/10/2020 • 4 minutes to read • Edit Online

Ce guide explique comment supprimer Xamarin de Visual Studio sur Windows.

Visual Studio 2019 et Visual Studio 2017


Pour désinstaller Xamarin de Visual Studio 2019 et Visual Studio 2017, utilisez le programme d’installation :
1. Utilisez le menu Démarrer pour ouvrir Visual Studio Installer .
2. Appuyez sur le bouton Modifier pour l’instance que vous souhaitez modifier.

3. Sous l’onglet Charges de travail , décochez l’option ** Développement mobile en .NET** (dans la section
Mobile et jeux ).

4. Cliquez sur le bouton Modifier situé en bas à droite de la fenêtre.


5. Visual Studio Installer va supprimer les composants qui ont été désélectionnés (Visual Studio 2017 doit être
fermé pour que Visual Studio Installer puisse apporter les modifications nécessaires).

Les composants Xamarin individuels (tels que le profileur ou les classeurs) peuvent être désinstallés en basculant
vers l’onglet composants individuels à l’étape 3 et en dévérifiant des composants spécifiques :
Pour désinstaller entièrement Visual Studio 2017, choisissez Désinstaller dans le menu en regard du bouton
Lancer (représenté par trois barres superposées).

IMPORTANT
Si vous avez installé deux instances (ou plus) de Visual Studio côte à côte (SxS), par exemple une Version et une Préversion, la
désinstallation d’une instance peut supprimer certaines fonctionnalités Xamarin de la ou des autres instances de Visual
Studio, notamment :
Xamarin Profiler
Xamarin Workbooks/Inspector
Xamarin Remote iOS Simulator
SDK Apple Bonjour
Sous certaines conditions, la désinstallation de l’une des instances côte à côte peut entraîner la suppression de ces
fonctionnalités. Cela peut alors dégrader les performances de la plateforme Xamarin sur les instances restantes de Visual
Studio.
Pour résoudre ce problème, exécutez l’option Réparer dans Visual Studio Installer, qui réinstallera les composants
manquants.

Visual Studio 2015 et versions antérieures


Pour désinstaller intégralement Visual Studio 2015, utilisez la réponse du support sur visualstudio.com.
Sur les ordinateurs Windows, Xamarin peut être désinstallé via le Panneau de configuration . Accédez à
Programmes et fonctionnalités ou à Programmes > Désinstaller un programme , comme illustré ci-
dessous :
Dans le Panneau de configuration, désinstallez les éléments de votre choix présents ici :
Xamarin
Xamarin pour Windows
Xamarin.Android
Xamarin.iOS
Xamarin pour Visual Studio
Dans l’Explorateur, supprimez tous les fichiers restants des dossiers d’extension Xamarin Visual Studio (toutes les
versions, y compris Fichiers programme et Fichiers programme (x86)) :

C:\Program Files*\Microsoft Visual Studio 1*.0\Common7\IDE\Extensions\Xamarin

Supprimez le répertoire de cache du composant MEF de Visual Studio, qui devrait se trouver à l’emplacement
suivant :

%LOCALAPPDATA%\Microsoft\VisualStudio\1*.0\ComponentModelCache

Vérifiez dans le répertoire Vir tualStore pour voir si Windows a stocké des fichiers de superposition dans les
répertoires Extensions\Xamarin ou ComponentModelCache :

%LOCALAPPDATA%\VirtualStore

Ouvrez l’Éditeur du Registre (regedit) et recherchez la clé suivante :

HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\SharedDlls

Recherchez et supprimez toutes les entrées qui correspondent à ce modèle :

C:\Program Files*\Microsoft Visual Studio 1*.0\Common7\IDE\Extensions\Xamarin

Recherchez cette clé :

HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\1*.0\ExtensionManager\PendingDeletions
Supprimez les entrées qui semblent éventuellement liées à Xamarin. Par exemple, tout élément contenant les
termes mono ou xamarin .
Ouvrez une invite de commandes cmd.exe administrateur, puis exécutez les commandes devenv /setup et
devenv /updateconfiguration pour chaque version installée de Visual Studio. Par exemple, pour Visual Studio 2015 :

"%ProgramFiles(x86)%\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe" /setup


"%ProgramFiles(x86)%\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe" /updateconfiguration
Instructions de configuration du pare-feu Xamarin
05/10/2020 • 3 minutes to read • Edit Online

Une liste d’hôtes que vous devez autoriser dans votre pare-feu afin de permettre à la plateforme de Xamarin de
fonctionner pour votre entreprise.
Pour que les produits Xamarin puissent être installés et fonctionner correctement, certains points de terminaison
doivent être accessibles pour télécharger les outils et les mises à jour nécessaires. Si vos paramètres de pare-feu ou
ceux de votre entreprise sont stricts, vous pouvez rencontrer des problèmes avec l’installation, la gestion des
licences ou certains composants, par exemple. Ce document décrit certains des points de terminaison connus qui
doivent être autorisés dans votre pare-feu pour permettre à Xamarin de fonctionner. Cette liste ne comprend pas
les points de terminaison qui sont nécessaires pour les outils tiers inclus dans le téléchargement. Si vous
rencontrez encore des problèmes après avoir étudié cette liste, reportez-vous aux guides de dépannage de
l’installation pour les produits Apple ou Android.

Points de terminaison à autoriser


Programme d’installation de Xamarin
Les adresses connues suivantes doivent être ajoutées à la liste pour que les logiciels soient installés correctement à
l’aide de la dernière version du programme d’installation Xamarin :
xamarin.com (manifestes du programme d’installation)
dl.xamarin.com (emplacement de téléchargement du paquet)
dl.google.com (pour télécharger Android SDK)
download.oracle.com (JDK)
visualstudio.com (emplacement de téléchargement des paquets d’installation)
go.microsoft.com (résolution de l’URL d’installation)
aka.ms (résolution de l’URL d’installation)
Si vous utilisez un ordinateur Mac et rencontrez des problèmes d’installation avec Xamarin.Android, vérifiez que
Mac OS est en mesure de télécharger Java.
NuGet (y compris Xamarin.Forms )
Les adresses suivantes doivent être ajoutées pour accéder à NuGet ( Xamarin.Forms est empaqueté en tant que
NuGet) :
www.nuget.org (pour accéder à NuGet)
globalcdn.nuget.org (téléchargements NuGet)
dl-ssl.google.com (composants Google pour Android et Xamarin.Forms )
Mises à jour logicielles
Les adresses suivantes doivent être ajoutées à la liste pour que les mises à jour logicielles puissent être
téléchargées correctement :
software.xamarin.com (service de mise à jour)
download.visualstudio.microsoft.com
dl.xamarin.com

Mac Agent Xamarin


Pour connecter Visual Studio à un Build Host Mac avec Mac Agent Xamarin, vous devez ouvrir le port SSH. Par
défaut, il s’agit du por t 22 .
Xamarin.FormsPlateformes prises en charge
05/10/2020 • 3 minutes to read • Edit Online

Xamarin.Formsles applications peuvent être écrites pour les systèmes d’exploitation suivants :
iOS 9 ou ultérieur.
Android 4.4 (API 19) ou ultérieur (plus d’informations). Toutefois, Android 5.0 (API 21) est recommandé comme
API minimale. Cela garantit une compatibilité complète avec toutes les bibliothèques de prise en charge
Android, tout en ciblant toujours la majorité des appareils Android.
Plateforme Windows universelle Windows 10
Xamarin.Formsles applications pour iOS, Android et le plateforme Windows universelle (UWP) peuvent être créées
dans Visual Studio. Toutefois, un Mac en réseau est nécessaire pour le développement iOS avec la dernière version
de Xcode et la version minimale de macOS spécifiée par Apple. Pour plus d’informations, consultez Configuration
requise de Windows.
Xamarin.Formsvous pouvez créer des applications pour iOS et Android dans Visual Studio pour Mac. Pour plus
d’informations, consultez Configuration requise de macOS.

NOTE
Le développement d’applications à l’aide Xamarin.Forms de nécessite une connaissance .NET standard.

Prise en charge de plateforme supplémentaire


Xamarin.Formsprend en charge des plateformes supplémentaires autres que iOS, Android et Windows :
Samsung Tizen
macOS 10,13 ou version ultérieure
GTK#
WPF
L’état de ces plateformes est disponible sur le Xamarin.Forms wiki de prise en charge de la plateforme GitHub.

Prise en charge des plateformes Android


Les dernières versions d’Android SDK Tools et de la plateforme d’API Android doivent être installées. Vous pouvez
effectuer une mise à jour vers les versions les plus récentes à l’aide du Gestionnaire Android SDK.
De plus, la version cible/de compilation pour les projets Android doit avoir la valeur Utiliser la dernière plateforme
installée. Toutefois, vous pouvez définir la version minimale à API 19, ce qui vous permet de continuer à prendre en
charge les appareils utilisant Android 4.4 et les versions ultérieures. Ces valeurs sont définies dans les Options du
projet :
Visual Studio
Visual Studio pour Mac
Options du projet > Application > Propriétés de l’application
Plateformes dépréciées
Ces plateformes ne sont pas prises en charge lors de l’utilisation Xamarin.Forms de 3,0 ou plus récente :
Windows 8.1 / Windows Phone 8.1 WinRT
Windows Phone 8 Silverlight
Créer votre première Xamarin.Forms application
05/10/2020 • 6 minutes to read • Edit Online

Regardez cette vidéo et suivez la procédure pour créer votre première application mobile avec Xamarin.Forms .

Instructions pas à pas pour Windows


Télécharger l’exemple
Suivez ces étapes, ainsi que la vidéo ci-dessus :
1. Choisissez Fichier > Nouveau > Projet , ou appuyez sur le bouton Créer un projet :

2. Recherchez « Xamarin », ou choisissez Mobile dans le menu Type de projet . Sélectionnez le type de projet
application mobile ( Xamarin.Forms ) :
3. Choisissez un nom de projet. L’exemple utilise « AwesomeApp » :

4. Cliquez sur le type de projet Vide , puis vérifiez qu’Android et iOS sont sélectionnés :

5. Attendez que les paquets NuGet soient restaurés (un message indiquant la fin de la restauration s’affiche
dans la barre d’état).
6. Les nouvelles installations de Visual Studio 2019 ne disposent pas d’un Émulateur Android configuré.
Cliquez sur la flèche déroulante vers le bas du bouton Déboguer , puis choisissez Créer un émulateur
Android pour lancer l’écran de création de l’émulateur :
7. Dans l’écran de création de l’émulateur, utilisez les paramètres par défaut, puis cliquez sur le bouton Créer :

8. La création d’un émulateur vous ramène à la fenêtre du Gestionnaire d’appareils. Cliquez sur le bouton
Démarrer pour lancer le nouvel émulateur :

9. Visual Studio 2019 doit maintenant afficher le nom du nouvel émulateur sur le bouton Déboguer :

10. Cliquez sur le bouton Déboguer pour générer et déployer l’application sur l’Émulateur Android :

Personnaliser l’application
Vous pouvez personnaliser l’application pour ajouter des fonctionnalités interactives. Effectuez les étapes suivantes
pour ajouter à l’application une fonctionnalité d’interaction avec l’utilisateur :
1. Modifiez MainPage.xaml en ajoutant ce code XAML avant la fin de </StackLayout> :

<Button Text="Click Me" Clicked="Button_Clicked" />

2. Modifiez MainPage.xaml.cs en ajoutant ce code à la fin de la classe :

int count = 0;
void Button_Clicked(object sender, System.EventArgs e)
{
count++;
((Button)sender).Text = $"You clicked {count} times.";
}

3. Déboguez l’application sur Android :

NOTE
L’exemple d’application comprend la fonctionnalité interactive supplémentaire qui n’est pas abordée dans la vidéo.

Générer une application iOS dans Visual Studio 2019


Vous pouvez générer et déboguer l’application iOS à partir de Visual Studio à l’aide d’un ordinateur Mac en réseau.
Pour plus d’informations, consultez les instructions de configuration.
Cette vidéo décrit le processus de génération et de test d’une application iOS à l’aide de Visual Studio 2019 sur
Windows :
Instructions pas à pas pour Windows
Télécharger l’exemple
Suivez ces étapes, ainsi que la vidéo ci-dessus :
1. Choisissez fichier > nouveau > projet... ou appuyez sur le bouton créer un nouveau projet. .., puis
sélectionnez Visual C# > multiplateforme > application mobile ( Xamarin.Forms ) :

2. Vérifiez qu’Android et iOS sont sélectionnés, ainsi que le partage de code .NET Standard :

3. Attendez que les paquets NuGet soient restaurés (un message indiquant la fin de la restauration s’affiche
dans la barre d’état).
4. Lancez l’émulateur Android en appuyant sur le bouton de débogage (ou sur l’élément de menu Déboguer
> Démarrer le débogage ).
5. Modifiez MainPage.xaml en ajoutant ce code XAML avant la fin de </StackLayout> :

<Button Text="Click Me" Clicked="Button_Clicked" />

6. Modifiez MainPage.xaml.cs en ajoutant ce code à la fin de la classe :


int count = 0;
void Button_Clicked(object sender, System.EventArgs e)
{
count++;
((Button)sender).Text = $"You clicked {count} times.";
}

7. Déboguez l’application sur Android :

TIP
Il est possible de générer et déboguer l’application iOS à partir de Visual Studio avec un ordinateur Mac en réseau.
Pour plus d’informations, consultez les instructions de configuration.

Instructions pas à pas pour Mac


Télécharger l’exemple
Suivez ces étapes, ainsi que la vidéo ci-dessus :
1. Choisissez Fichier > Nouvelle solution , ou appuyez sur le bouton Nouveau projet , puis sélectionnez
Multiplateforme > Application > Application Forms vide :
2. Vérifiez qu’Android et iOS sont sélectionnés, ainsi que le partage de code .NET Standard :

3. Restaurez les paquets NuGet en cliquant avec le bouton droit sur la solution :

4. Lancez l’émulateur Android en appuyant sur le bouton de débogage (ou sur Exécuter > Démarrer le
débogage ).
5. Modifiez MainPage.xaml en ajoutant ce code XAML avant la fin de </StackLayout> :

<Button Text="Click Me" Clicked="Handle_Clicked" />

6. Modifiez MainPage.xaml.cs en ajoutant ce code à la fin de la classe :

int count = 0;
void Handle_Clicked(object sender, System.EventArgs e)
{
count++;
((Button)sender).Text = $"You clicked {count} times.";
}

7. Déboguez l’application sur Android :


8. Cliquez avec le bouton droit pour définir le projet de démarrage à iOS :

9. Déboguez l’application sur iOS :


Vous pouvez télécharger le code complet à partir de la galerie d’exemples ou le voir sur GitHub.

Étapes suivantes
Démarrage rapide : application monopage – Générer une application plus opérationnelle.
Xamarin.Forms Exemples – Téléchargez et exécutez des exemples de code et des exemples d’applications.
Création d’Mobile Apps livre électronique – Chapitres détaillés qui enseignent Xamarin.Forms le
développement, disponibles au format PDF et qui incluent des centaines d’exemples supplémentaires.
Xamarin.FormsDémarrages rapides
05/10/2020 • 2 minutes to read • Edit Online

Découvrez comment créer des applications mobiles avec Xamarin.Forms .

Créer une application à page unique Xamarin.Forms


Apprenez à créer une application multiplateforme de page unique Xamarin.Forms , qui vous permet d’entrer une
note et de la conserver dans le stockage de l’appareil.

Effectuer une navigation dans une application à plusieurs pages


Xamarin.Forms
Découvrez comment activer une application sur une seule page, capable de stocker une seule note, dans une
application comportant plusieurs pages, capable de stocker plusieurs notes.

Stocker des données dans une base de données SQLite.NET locale


Apprenez à stocker des données dans une base de données SQLite.NET locale.

Styliser une application multiplateforme Xamarin.Forms


Découvrez comment styliser une Xamarin.Forms application multiplateforme à l’aide de styles XAML.

Démarrage rapide en immersion


Découvrez les principes de base du développement d’applications à l’aide de Xamarin.Forms , en vous concentrant
sur l’application développée tout au long des Démarrages rapides.
Créer une application à page unique Xamarin.Forms
05/10/2020 • 24 minutes to read • Edit Online

Télécharger l’exemple
Dans ce guide de démarrage rapide, vous allez apprendre à :
Créer une Xamarin.Forms application multiplateforme.
Définir l’interface utilisateur d’une page à l’aide du langage XAML (Extensible Application Markup Language)
Interagir avec des éléments d’interface utilisateur XAML à partir du code
Le Guide de démarrage rapide vous guide dans la création d’une Xamarin.Forms application multiplateforme, qui
vous permet d’entrer une note et de la conserver dans le stockage de l’appareil. L’application finale est indiquée ci-
dessous :

Conditions préalables requises


Installation de Visual Studio 2019 (dernière version) et de la charge de travail Développement mobile en
.NET .
Connaissance de C#.
(facultatif) Un Mac couplé pour générer l’application sur iOS.
Pour plus d’informations sur ces prérequis, consultez Installation de Xamarin. Pour plus d’informations sur la
connexion de Visual Studio 2019 à un hôte de build Mac, consultez l’article Appairer avec un Mac pour le
développement Xamarin.iOS.

Bien démarrer avec Visual Studio 2019


1. Lancez Visual Studio 2019, puis dans la fenêtre de démarrage, cliquez sur Créer un projet pour créer un
projet :
2. Dans la fenêtre créer un nouveau projet , sélectionnez mobile dans la liste déroulante type de projet ,
sélectionnez le modèle application mobile ( Xamarin.Forms ) , puis cliquez sur le bouton suivant :

3. Dans la fenêtre Configurer votre nouveau projet , affectez à Nom du projet la valeur Notes ,
choisissez un emplacement approprié pour le projet, puis cliquez sur le bouton Créer :
IMPORTANT
Pour les extraits C# et XAML de ce guide de démarrage rapide, la solution doit se nommer Notes . L’utilisation d’un
autre nom entraîne des erreurs de build quand vous copiez le code à partir de ce guide de démarrage rapide dans la
solution.

4. Dans la boîte de dialogue Nouvelle application multiplateforme , cliquez sur Application vide , puis
cliquez sur le bouton OK :

Pour plus d’informations sur la bibliothèque de .NET Standard qui est créée, consultez anatomie d’une
Xamarin.Forms application dans la présentation Xamarin.Forms approfondie des Démarrages rapides.
5. Dans l’Explorateur de solutions , dans le projet Notes , double-cliquez sur MainPage.xaml pour l’ouvrir :
6. Dans MainPage. Xaml , supprimez tout le code du modèle et remplacez-le par le code suivant :

<?xml version="1.0" encoding="utf-8"?>


<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.MainPage">
<StackLayout Margin="10,35,10,10">
<Label Text="Notes"
HorizontalOptions="Center"
FontAttributes="Bold" />
<Editor x:Name="editor"
Placeholder="Enter your note"
HeightRequest="100" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Button Text="Save"
Clicked="OnSaveButtonClicked" />
<Button Grid.Column="1"
Text="Delete"
Clicked="OnDeleteButtonClicked"/>
</Grid>
</StackLayout>
</ContentPage>

Ce code définit de manière déclarative l’interface utilisateur de la page, qui se compose d’un Label pour
afficher du texte, d’une Editor entrée de texte et de deux Button instances qui indiquent à l’application
d’enregistrer ou de supprimer un fichier. Les deux Button instances sont disposées horizontalement dans
un Grid , avec Label , Editor , et Grid disposées verticalement dans un StackLayout . Pour plus
d’informations sur la création de l’interface utilisateur, consultez interface utilisateur dans la présentation
Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les modifications apportées à MainPage.xaml en appuyant sur Ctrl+S et fermez le fichier.
7. Dans l’Explorateur de solutions , dans le projet Notes , développez MainPage.xaml , puis double-cliquez
sur MainPage.xaml.cs pour l’ouvrir :
8. Dans MainPage.Xaml.cs , supprimez tout le code du modèle et remplacez-le par le code suivant :

using System;
using System.IO;
using Xamarin.Forms;

namespace Notes
{
public partial class MainPage : ContentPage
{
string _fileName =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "notes.txt");

public MainPage()
{
InitializeComponent();

if (File.Exists(_fileName))
{
editor.Text = File.ReadAllText(_fileName);
}
}

void OnSaveButtonClicked(object sender, EventArgs e)


{
File.WriteAllText(_fileName, editor.Text);
}

void OnDeleteButtonClicked(object sender, EventArgs e)


{
if (File.Exists(_fileName))
{
File.Delete(_fileName);
}
editor.Text = string.Empty;
}
}
}
Ce code définit un champ _fileName , qui référence un fichier nommé notes.txt qui stocke les données de
notes dans le dossier de données d’application locale pour l’application. Lors de l’exécution du constructeur
de page, le fichier est lu, s’il existe, et affiché dans le Editor . Lorsque l' enregistrement Button est activé
OnSaveButtonClicked , le gestionnaire d’événements est exécuté, ce qui permet d’enregistrer le contenu du
Editor dans le fichier. Lorsque la suppression Button est activée, le OnDeleteButtonClicked Gestionnaire
d’événements est exécuté, ce qui supprime le fichier, à condition qu’il existe, et supprime tout texte de
Editor . Pour plus d’informations sur l’interaction avec l’utilisateur, consultez réponse à l’interaction de
l’utilisateur dans la présentation Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les modifications apportées à MainPage.xaml.cs en appuyant sur Ctrl+S et fermez le fichier.
Génération du guide de démarrage rapide
1. Dans Visual Studio, sélectionnez l’élément de menu Générer > Générer la solution (ou appuyez sur F6).
La solution est générée et un message de réussite s’affiche dans la barre d’état Visual Studio :

En cas d’erreurs, répétez les étapes précédentes et corrigez les erreurs éventuelles jusqu’à ce que la solution
soit générée.
2. Dans la barre d’outils de Visual Studio, appuyez sur le bouton Démarrer (le bouton triangulaire qui
ressemble à un bouton Lire) pour lancer l’application dans l’émulateur Android de votre choix :

Entrez une note et appuyez sur le bouton Enregistrer .


Pour plus d’informations sur la façon dont l’application est lancée sur chaque plateforme, consultez
lancement de l’application sur chaque plateforme dans le Xamarin.Forms didacticiel de démarrage rapide.

NOTE
Les étapes suivantes doivent être effectuées uniquement si vous disposez d’un Mac couplé qui répond à la
configuration système requise pour le Xamarin.Forms développement.

3. Dans la barre d’outils Visual Studio, cliquez avec le bouton droit sur le projet Notes.iOS , puis sélectionnez
Définir comme projet de démarrage .

4. Dans la barre d’outils de Visual Studio, appuyez sur le bouton Démarrer (le bouton triangulaire qui
ressemble à un bouton Lire) pour lancer l’application dans le simulateur distant iOS de votre choix :

Entrez une note et appuyez sur le bouton Enregistrer .


Pour plus d’informations sur la façon dont l’application est lancée sur chaque plateforme, consultez
lancement de l’application sur chaque plateforme dans le Xamarin.Forms didacticiel de démarrage rapide.
Conditions préalables requises
Installation de Visual Studio 2017 et de la charge de travail Développement mobile en .NET .
Connaissance de C#.
(facultatif) Un Mac couplé pour générer l’application sur iOS.
Pour plus d’informations sur ces prérequis, consultez Installation de Xamarin. Pour plus d’informations sur la
connexion de Visual Studio 2019 à un hôte de build Mac, consultez l’article Appairer avec un Mac pour le
développement Xamarin.iOS.

Bien démarrer avec Visual Studio 2017


1. Lancez Visual Studio 2017, puis dans la page de démarrage, cliquez sur Créer un projet pour créer un
projet :

2. Dans la boîte de dialogue nouveau projet , cliquez sur multiplateforme , sélectionnez le modèle
application mobile ( Xamarin.Forms ) , définissez le nom sur Notes , choisissez un emplacement
approprié pour le projet et cliquez sur le bouton OK :

IMPORTANT
Pour les extraits C# et XAML de ce guide de démarrage rapide, la solution doit se nommer Notes . L’utilisation d’un
autre nom entraîne des erreurs de build quand vous copiez le code à partir de ce guide de démarrage rapide dans la
solution.

3. Dans la boîte de dialogue Nouvelle application multiplateforme , cliquez sur Application vide ,
sélectionnez .NET Standard comme stratégie de partage de code et cliquez sur le bouton OK :

Pour plus d’informations sur la bibliothèque de .NET Standard qui est créée, consultez anatomie d’une
Xamarin.Forms application dans la présentation Xamarin.Forms approfondie des Démarrages rapides.
4. Dans l’Explorateur de solutions , dans le projet Notes , double-cliquez sur MainPage.xaml pour l’ouvrir :

5. Dans MainPage. Xaml , supprimez tout le code du modèle et remplacez-le par le code suivant :
<?xml version="1.0" encoding="utf-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.MainPage">
<StackLayout Margin="10,35,10,10">
<Label Text="Notes"
HorizontalOptions="Center"
FontAttributes="Bold" />
<Editor x:Name="editor"
Placeholder="Enter your note"
HeightRequest="100" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Button Text="Save"
Clicked="OnSaveButtonClicked" />
<Button Grid.Column="1"
Text="Delete"
Clicked="OnDeleteButtonClicked"/>
</Grid>
</StackLayout>
</ContentPage>

Ce code définit de manière déclarative l’interface utilisateur de la page, qui se compose d’un Label pour
afficher du texte, d’une Editor entrée de texte et de deux Button instances qui indiquent à l’application
d’enregistrer ou de supprimer un fichier. Les deux Button instances sont disposées horizontalement dans
un Grid , avec Label , Editor , et Grid disposées verticalement dans un StackLayout . Pour plus
d’informations sur la création de l’interface utilisateur, consultez interface utilisateur dans la présentation
Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les modifications apportées à MainPage.xaml en appuyant sur Ctrl+S et fermez le fichier.
6. Dans l’Explorateur de solutions , dans le projet Notes , développez MainPage.xaml , puis double-cliquez
sur MainPage.xaml.cs pour l’ouvrir :
7. Dans MainPage.Xaml.cs , supprimez tout le code du modèle et remplacez-le par le code suivant :
using System;
using System.IO;
using Xamarin.Forms;

namespace Notes
{
public partial class MainPage : ContentPage
{
string _fileName =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "notes.txt");

public MainPage()
{
InitializeComponent();

if (File.Exists(_fileName))
{
editor.Text = File.ReadAllText(_fileName);
}
}

void OnSaveButtonClicked(object sender, EventArgs e)


{
File.WriteAllText(_fileName, editor.Text);
}

void OnDeleteButtonClicked(object sender, EventArgs e)


{
if (File.Exists(_fileName))
{
File.Delete(_fileName);
}
editor.Text = string.Empty;
}
}
}

Ce code définit un champ _fileName , qui référence un fichier nommé notes.txt qui stocke les données de
notes dans le dossier de données d’application locale pour l’application. Lors de l’exécution du constructeur
de page, le fichier est lu, s’il existe, et affiché dans le Editor . Lorsque l' enregistrement Button est activé
OnSaveButtonClicked , le gestionnaire d’événements est exécuté, ce qui permet d’enregistrer le contenu du
Editor dans le fichier. Lorsque la suppression Button est activée, le OnDeleteButtonClicked Gestionnaire
d’événements est exécuté, ce qui supprime le fichier, à condition qu’il existe, et supprime tout texte de
Editor . Pour plus d’informations sur l’interaction avec l’utilisateur, consultez réponse à l’interaction de
l’utilisateur dans la présentation Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les modifications apportées à MainPage.xaml.cs en appuyant sur Ctrl+S et fermez le fichier.
Génération du guide de démarrage rapide
1. Dans Visual Studio, sélectionnez l’élément de menu Générer > Générer la solution (ou appuyez sur F6).
La solution est générée et un message de réussite s’affiche dans la barre d’état Visual Studio :
En cas d’erreurs, répétez les étapes précédentes et corrigez les erreurs éventuelles jusqu’à ce que la solution
soit générée.
2. Dans la barre d’outils de Visual Studio, appuyez sur le bouton Démarrer (le bouton triangulaire qui
ressemble à un bouton Lire) pour lancer l’application dans l’émulateur Android de votre choix :

Entrez une note et appuyez sur le bouton Enregistrer .


Pour plus d’informations sur la façon dont l’application est lancée sur chaque plateforme, consultez
lancement de l’application sur chaque plateforme dans le Xamarin.Forms didacticiel de démarrage rapide.

NOTE
Les étapes suivantes doivent être effectuées uniquement si vous disposez d’un Mac couplé qui répond à la
configuration système requise pour le Xamarin.Forms développement.

3. Dans la barre d’outils Visual Studio, cliquez avec le bouton droit sur le projet Notes.iOS , puis sélectionnez
Définir comme projet de démarrage .
4. Dans la barre d’outils de Visual Studio, appuyez sur le bouton Démarrer (le bouton triangulaire qui
ressemble à un bouton Lire) pour lancer l’application dans le simulateur distant iOS de votre choix :

Entrez une note et appuyez sur le bouton Enregistrer .


Pour plus d’informations sur la façon dont l’application est lancée sur chaque plateforme, consultez
lancement de l’application sur chaque plateforme dans le Xamarin.Forms didacticiel de démarrage rapide.
Conditions préalables requises
Visual Studio pour Mac (dernière version) avec installation de la prise en charge des plateformes iOS et
Android.
Xcode (dernière version).
Connaissance de C#.
Pour plus d’informations sur ces prérequis, consultez Installation de Xamarin.

Bien démarrer avec Visual Studio pour Mac


1. Lancez Visual Studio pour Mac, puis dans la fenêtre de démarrage, cliquez sur Nouveau pour créer un
projet :

2. Dans la boîte de dialogue Choisir un modèle pour votre nouveau projet , cliquez sur
Multiplateforme > Application , sélectionnez le modèle Application Forms vide , puis cliquez sur le
bouton Suivant :

3. Dans la boîte de dialogue Configurer une application Forms vide , nommez la nouvelle application
Notes , vérifiez que la case d’option Utiliser .NET Standard est sélectionnée, puis cliquez sur le bouton
Suivant :
4. Dans la boîte de dialogue Configurer votre nouvelle application Forms vide , laissez Notes comme
noms de la solution et du projet, choisissez un emplacement approprié pour le projet, puis cliquez sur le
bouton Créer pour créer le projet :
IMPORTANT
Pour les extraits C# et XAML de ce guide de démarrage rapide, la solution et le projet doivent se nommer Notes .
L’utilisation d’un autre nom entraîne des erreurs de build quand vous copiez le code à partir de ce guide de
démarrage rapide dans le projet.

Pour plus d’informations sur la bibliothèque de .NET Standard qui est créée, consultez anatomie d’une
Xamarin.Forms application dans la présentation Xamarin.Forms approfondie des Démarrages rapides.
5. Dans le Panneau Solutions , dans le projet Notes , double-cliquez sur MainPage.xaml pour l’ouvrir :

6. Dans MainPage. Xaml , supprimez tout le code du modèle et remplacez-le par le code suivant :

<?xml version="1.0" encoding="utf-8"?>


<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.MainPage">
<StackLayout Margin="10,35,10,10">
<Label Text="Notes"
HorizontalOptions="Center"
FontAttributes="Bold" />
<Editor x:Name="editor"
Placeholder="Enter your note"
HeightRequest="100" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Button Text="Save"
Clicked="OnSaveButtonClicked" />
<Button Grid.Column="1"
Text="Delete"
Clicked="OnDeleteButtonClicked"/>
</Grid>
</StackLayout>
</ContentPage>

Ce code définit de manière déclarative l’interface utilisateur de la page, qui se compose d’un Label pour
afficher du texte, d’une Editor entrée de texte et de deux Button instances qui indiquent à l’application
d’enregistrer ou de supprimer un fichier. Les deux Button instances sont disposées horizontalement dans
un Grid , avec Label , Editor , et Grid disposées verticalement dans un StackLayout . Pour plus
d’informations sur la création de l’interface utilisateur, consultez interface utilisateur dans la présentation
Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les modifications apportées à MainPage.xaml en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ) et fermez le fichier.
7. Dans le Panneau Solutions , dans le projet Notes , développez MainPage.xaml , puis double-cliquez sur
MainPage.xaml.cs pour l’ouvrir :
8. Dans MainPage.Xaml.cs , supprimez tout le code du modèle et remplacez-le par le code suivant :

using System;
using System.IO;
using Xamarin.Forms;

namespace Notes
{
public partial class MainPage : ContentPage
{
string _fileName =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "notes.txt");

public MainPage()
{
InitializeComponent();

if (File.Exists(_fileName))
{
editor.Text = File.ReadAllText(_fileName);
}
}

void OnSaveButtonClicked(object sender, EventArgs e)


{
File.WriteAllText(_fileName, editor.Text);
}

void OnDeleteButtonClicked(object sender, EventArgs e)


{
if (File.Exists(_fileName))
{
File.Delete(_fileName);
}
editor.Text = string.Empty;
}
}
}

Ce code définit un champ _fileName , qui référence un fichier nommé notes.txt qui stocke les données de
notes dans le dossier de données d’application locale pour l’application. Lors de l’exécution du constructeur
de page, le fichier est lu, s’il existe, et affiché dans le Editor . Lorsque l' enregistrement Button est activé
OnSaveButtonClicked , le gestionnaire d’événements est exécuté, ce qui permet d’enregistrer le contenu du
Editor dans le fichier. Lorsque la suppression Button est activée, le OnDeleteButtonClicked Gestionnaire
d’événements est exécuté, ce qui supprime le fichier, à condition qu’il existe, et supprime tout texte de
Editor . Pour plus d’informations sur l’interaction avec l’utilisateur, consultez réponse à l’interaction de
l’utilisateur dans la présentation Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les modifications apportées à MainPage.xaml.cs en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ) et fermez le fichier.
Génération du guide de démarrage rapide
1. Dans Visual Studio pour Mac, sélectionnez l’élément de menu Générer > Générer tout (ou appuyez sur
⌘ +B ). Les projets sont générés et un message de réussite s’affiche dans la barre d’outils Visual Studio pour
Mac.

En cas d’erreurs, répétez les étapes précédentes et corrigez les erreurs éventuelles jusqu’à ce que les projets
soient générés.
2. Dans le Panneau Solutions , sélectionnez le projet Notes.iOS , cliquez avec le bouton droit, puis
sélectionnez Définir en tant que projet de démarrage :

3. Dans la barre d’outils Visual Studio pour Mac, appuyez sur le bouton Démarrer (le bouton triangulaire qui
ressemble à un bouton Lire) pour lancer l’application dans le simulateur iOS de votre choix :

Entrez une note et appuyez sur le bouton Enregistrer .


Pour plus d’informations sur la façon dont l’application est lancée sur chaque plateforme, consultez
lancement de l’application sur chaque plateforme dans le Xamarin.Forms didacticiel de démarrage rapide.
4. Dans le Panneau Solutions , sélectionnez le projet Notes.Droid , cliquez avec le bouton droit, puis
sélectionnez Définir en tant que projet de démarrage :

5. Dans la barre d’outils Visual Studio pour Mac, appuyez sur le bouton Démarrer (le bouton triangulaire qui
ressemble à un bouton Lire) pour lancer l’application dans l’émulateur Android de votre choix :

Entrez une note et appuyez sur le bouton Enregistrer .


Pour plus d’informations sur la façon dont l’application est lancée sur chaque plateforme, consultez
lancement de l’application sur chaque plateforme dans le Xamarin.Forms didacticiel de démarrage rapide.

Étapes suivantes
Dans ce démarrage rapide, vous avez appris comment :
Créer une Xamarin.Forms application multiplateforme.
Définir l’interface utilisateur d’une page à l’aide du langage XAML (Extensible Application Markup Language)
Interagir avec des éléments d’interface utilisateur XAML à partir du code
Pour transformer cette application monopage en application multipage, passez au prochain guide de démarrage
rapide.
Next
Liens connexes
Notes (exemple)
Xamarin.Forms Présentation approfondie des Démarrages rapides
Effectuer une navigation dans une application à
plusieurs pages Xamarin.Forms
05/10/2020 • 26 minutes to read • Edit Online

Télécharger l’exemple
Dans ce guide de démarrage rapide, vous allez apprendre à :
Ajoutez des pages supplémentaires à une Xamarin.Forms solution.
Naviguer entre des pages
Utiliser la liaison de données pour synchroniser les données entre les éléments d’interface utilisateur et leur
source de données
Le Guide de démarrage rapide vous guide dans la manière de transformer une application multiplateforme à une
seule page, qui est Xamarin.Forms en mesure de stocker une seule note dans une application à plusieurs pages,
qui est en mesure de stocker plusieurs notes. L’application finale est indiquée ci-dessous :

Page de page

Conditions préalables requises


Vous devez suivre correctement le précédent guide de démarrage rapide avant de tenter de suivre ce guide de
démarrage rapide. Vous pouvez également télécharger l’exemple du précédent guide de démarrage rapide, et
l’utiliser comme point de départ pour ce guide de démarrage rapide.

Mettre à jour l’application avec Visual Studio


1. Lancez Visual Studio. Dans la fenêtre de démarrage, cliquez dans la liste des derniers projets/solutions sur
la solution Notes , ou cliquez sur Ouvrir un projet ou une solution , puis dans la boîte de dialogue
Ouvrir une solution/un projet , sélectionnez le fichier solution du projet Notes :
2. Dans l’Explorateur de solutions , cliquez avec le bouton droit sur le projet Notes , puis sélectionnez
Ajouter > Nouveau dossier :

3. Dans l’Explorateur de solutions , nommez le nouveau dossier Modèles :


4. Dans l’Explorateur de solutions , sélectionnez le dossier Modèles , cliquez avec le bouton droit, puis
sélectionnez Ajouter > Nouvel élément :

5. Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez Éléments Visual C# > Classe ,
nommez le nouveau fichier Note , puis cliquez sur le bouton Ajouter :

Cela permet d’ajouter une classe nommée Note au dossier Modèles du projet Notes .
6. Dans Note.cs , supprimez l’ensemble du code du modèle, puis remplacez-le par le code suivant :
using System;

namespace Notes.Models
{
public class Note
{
public string Filename { get; set; }
public string Text { get; set; }
public DateTime Date { get; set; }
}
}

Cette classe définit un modèle Note , qui stocke les données relatives à chaque note de l’application.
Enregistrez les changements apportés à Note.cs en appuyant sur Ctrl+S , puis fermez le fichier.
7. Dans Explorateur de solutions , cliquez avec le bouton droit sur le projet Notes et sélectionnez Ajouter
> nouvel élément... Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez éléments
Visual C# > Xamarin.Forms > page contenu , nommez le nouveau fichier NoteEntr yPage , puis
cliquez sur le bouton Ajouter :

Cela permet d’ajouter une nouvelle page nommée NoteEntr yPage au dossier racine du projet. Cette page
est la deuxième page de l’application.
8. Dans NoteEntr yPage.xaml , supprimez l’ensemble du code du modèle, puis remplacez-le par le code
suivant :
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NoteEntryPage"
Title="Note Entry">
<StackLayout Margin="20">
<Editor Placeholder="Enter your note"
Text="{Binding Text}"
HeightRequest="100" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Button Text="Save"
Clicked="OnSaveButtonClicked" />
<Button Grid.Column="1"
Text="Delete"
Clicked="OnDeleteButtonClicked"/>
</Grid>
</StackLayout>
</ContentPage>

Ce code définit de manière déclarative l’interface utilisateur de la page, qui se compose d’un Editor pour
la saisie de texte, et de deux Button instances qui indiquent à l’application d’enregistrer ou de supprimer un
fichier. Les deux Button instances sont présentées horizontalement dans un Grid , avec Editor et Grid
disposés verticalement dans un StackLayout . De plus, Editor utilise la liaison de données pour établir
une liaison à la propriété Text du modèle Note . Pour plus d’informations sur la liaison de données,
consultez liaison de données dans l' Xamarin.Forms exploration approfondie des Démarrages rapides.
Enregistrez les changements apportés à NoteEntr yPage.xaml en appuyant sur Ctrl+S , puis fermez le
fichier.
9. Dans NoteEntr yPage.xaml.cs , supprimez l’ensemble du code du modèle, puis remplacez-le par le code
suivant :
using System;
using System.IO;
using Xamarin.Forms;
using Notes.Models;

namespace Notes
{
public partial class NoteEntryPage : ContentPage
{
public NoteEntryPage()
{
InitializeComponent();
}

async void OnSaveButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;

if (string.IsNullOrWhiteSpace(note.Filename))
{
// Save
var filename = Path.Combine(App.FolderPath, $"{Path.GetRandomFileName()}.notes.txt");
File.WriteAllText(filename, note.Text);
}
else
{
// Update
File.WriteAllText(note.Filename, note.Text);
}

await Navigation.PopAsync();
}

async void OnDeleteButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;

if (File.Exists(note.Filename))
{
File.Delete(note.Filename);
}

await Navigation.PopAsync();
}
}
}

Ce code stocke une Note instance, qui représente une seule note dans le BindingContext de la page.
Lorsque l' enregistrement Button est activé OnSaveButtonClicked , le gestionnaire d’événements est
exécuté, ce qui permet d’enregistrer le contenu du Editor dans un nouveau fichier avec un nom de fichier
généré de manière aléatoire ou un fichier existant si une note est mise à jour. Dans les deux cas, le fichier est
stocké dans le dossier de données d’application local de l’application. La méthode revient ensuite à la page
précédente. Lorsque la suppression Button est activée, le OnDeleteButtonClicked Gestionnaire
d’événements est exécuté, ce qui a pour effet de supprimer le fichier, à condition qu’il existe, et de revenir à
la page précédente. Pour plus d’informations sur la navigation, consultez navigation dans la présentation
Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les changements apportés à NoteEntr yPage.xaml.cs en appuyant sur Ctrl+S , puis fermez le
fichier.
WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

10. Dans Explorateur de solutions , cliquez avec le bouton droit sur le projet Notes et sélectionnez Ajouter
> nouvel élément... Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez éléments
Visual C# > Xamarin.Forms > page contenu , nommez le nouveau fichier NotesPage , puis cliquez sur
le bouton Ajouter .
Cela permet d’ajouter une page nommée NotesPage au dossier racine du projet. Cette page représente la
page racine de l’application.
11. Dans NotesPage.xaml , supprimez l’ensemble du code du modèle, puis remplacez-le par le code suivant :

<?xml version="1.0" encoding="UTF-8"?>


<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NotesPage"
Title="Notes">
<ContentPage.ToolbarItems>
<ToolbarItem Text="+"
Clicked="OnNoteAddedClicked" />
</ContentPage.ToolbarItems>
<ListView x:Name="listView"
Margin="20"
ItemSelected="OnListViewItemSelected">
<ListView.ItemTemplate>
<DataTemplate>
<TextCell Text="{Binding Text}"
Detail="{Binding Date}" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
</ContentPage>

Ce code définit de manière déclarative l’interface utilisateur de la page, qui se compose d’un ListView et
d’un ToolbarItem . ListView utilise la liaison de données pour afficher les notes récupérées par
l’application. La sélection d’une note permet d’accéder à NoteEntryPage , où elle peut être modifiée. Vous
pouvez également créer une note en appuyant sur ToolbarItem . Pour plus d’informations sur la liaison de
données, consultez liaison de données dans l' Xamarin.Forms exploration approfondie des Démarrages
rapides.
Enregistrez les changements apportés à NotesPage.xaml en appuyant sur Ctrl+S , puis fermez le fichier.
12. Dans NotesPage.xaml.cs , supprimez l’ensemble du code du modèle, puis remplacez-le par le code
suivant :
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Xamarin.Forms;
using Notes.Models;

namespace Notes
{
public partial class NotesPage : ContentPage
{
public NotesPage()
{
InitializeComponent();
}

protected override void OnAppearing()


{
base.OnAppearing();

var notes = new List<Note>();

var files = Directory.EnumerateFiles(App.FolderPath, "*.notes.txt");


foreach (var filename in files)
{
notes.Add(new Note
{
Filename = filename,
Text = File.ReadAllText(filename),
Date = File.GetCreationTime(filename)
});
}

listView.ItemsSource = notes
.OrderBy(d => d.Date)
.ToList();
}

async void OnNoteAddedClicked(object sender, EventArgs e)


{
await Navigation.PushAsync(new NoteEntryPage
{
BindingContext = new Note()
});
}

async void OnListViewItemSelected(object sender, SelectedItemChangedEventArgs e)


{
if (e.SelectedItem != null)
{
await Navigation.PushAsync(new NoteEntryPage
{
BindingContext = e.SelectedItem as Note
});
}
}
}
}

Ce code définit les fonctionnalités de NotesPage . Lorsque la page s’affiche, la OnAppearing méthode est
exécutée, qui remplit le ListView avec toutes les notes qui ont été récupérées à partir du dossier de
données d’application local. Lorsque le ToolbarItem est activé OnNoteAddedClicked , le gestionnaire
d’événements est exécuté. Cette méthode navigue vers NoteEntryPage , en affectant la valeur
BindingContext NoteEntryPage à une nouvelle Note instance de. Quand un élément de ListView est
sélectionné, le gestionnaire d’événements OnListViewItemSelected s’exécute. Cette méthode navigue vers
NoteEntryPage , en affectant BindingContext à l' NoteEntryPage instance sélectionnée la valeur de Note .
Pour plus d’informations sur la navigation, consultez navigation dans la présentation Xamarin.Forms
approfondie des Démarrages rapides.
Enregistrez les changements apportés à NotesPage.xaml.cs en appuyant sur Ctrl+S , puis fermez le
fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

13. Dans l’Explorateur de solutions , double-cliquez sur App.xaml.cs pour l’ouvrir. Remplacez ensuite le
code existant par le code suivant :

using System;
using System.IO;
using Xamarin.Forms;

namespace Notes
{
public partial class App : Application
{
public static string FolderPath { get; private set; }

public App()
{
InitializeComponent();
FolderPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
MainPage = new NavigationPage(new NotesPage());
}
// ...
}
}

Ce code ajoute une déclaration d’espace de noms pour l’espace de noms System.IO ainsi qu’une
déclaration pour une propriété FolderPath statique de type string . La propriété FolderPath permet de
stocker le chemin sur l’appareil où les données de notes doivent être stockées. En outre, le code initialise la
FolderPath propriété dans le App constructeur et initialise la MainPage propriété pour qu’elle soit un
NavigationPage qui héberge une instance de NotesPage . Pour plus d’informations sur la navigation,
consultez navigation dans la présentation Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les modifications apportées à App.xaml.cs en appuyant sur Ctrl+S et fermez le fichier.
14. Dans l’Explorateur de solutions , dans le projet Notes , cliquez avec le bouton droit sur MainPage.xaml ,
puis sélectionnez Supprimer . Dans la boîte de dialogue qui s’affiche, appuyez sur le bouton OK pour
supprimer le fichier de votre disque dur.
Cela entraîne la suppression d’une page qui n’est plus utilisée.
15. Générez et exécutez le projet sur chaque plateforme. Pour plus d’informations, consultez Génération du
guide de démarrage rapide.
Dans NotesPage , appuyez sur le bouton + pour accéder à NoteEntr yPage , puis entrez une note. Une fois
que vous avez enregistré la note, l’application revient à NotesPage .
Entrez un certain nombre de notes, de longueur variable, pour observer le comportement de l’application.
Mettre à jour l’application avec Visual Studio pour Mac
1. Lancez Visual Studio pour Mac. Dans la fenêtre de démarrage, cliquez sur Ouvrir , puis dans la boîte de
dialogue, sélectionnez le fichier solution du projet Notes :

2. Dans le Panneau Solutions , sélectionnez le projet Notes , cliquez avec le bouton droit, puis sélectionnez
Ajouter > Nouveau dossier :

3. Dans le Panneau Solutions , nommez le nouveau dossier Modèles :


4. Dans le Panneau Solutions , sélectionnez le dossier Modèles , cliquez avec le bouton droit, puis
sélectionnez Ajouter > Nouveau fichier :

5. Dans la boîte de dialogue Nouveau fichier , sélectionnez Général > Classe vide , nommez le nouveau
fichier Note , puis cliquez sur le bouton Nouveau :

Cela permet d’ajouter une classe nommée Note au dossier Modèles du projet Notes .
6. Dans Note.cs , supprimez l’ensemble du code du modèle, puis remplacez-le par le code suivant :
using System;

namespace Notes.Models
{
public class Note
{
public string Filename { get; set; }
public string Text { get; set; }
public DateTime Date { get; set; }
}
}

Cette classe définit un modèle Note , qui stocke les données relatives à chaque note de l’application.
Enregistrez les changements apportés à Note.cs en choisissant Fichier > Enregistrer (ou en appuyant
sur ⌘ +S ), puis fermez le fichier.
7. Dans le panneau solutions , sélectionnez le projet Notes , cliquez avec le bouton droit, puis sélectionnez
Ajouter > nouveau fichier.... Dans la boîte de dialogue nouveau fichier , sélectionnez formulaires >
Forms ContentPage XAML , nommez le nouveau fichier NoteEntr yPage , puis cliquez sur le bouton
nouveau :

Cela permet d’ajouter une nouvelle page nommée NoteEntr yPage au dossier racine du projet. Cette page
est la deuxième page de l’application.
8. Dans NoteEntr yPage.xaml , supprimez l’ensemble du code du modèle, puis remplacez-le par le code
suivant :
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NoteEntryPage"
Title="Note Entry">
<StackLayout Margin="20">
<Editor Placeholder="Enter your note"
Text="{Binding Text}"
HeightRequest="100" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Button Text="Save"
Clicked="OnSaveButtonClicked" />
<Button Grid.Column="1"
Text="Delete"
Clicked="OnDeleteButtonClicked"/>
</Grid>
</StackLayout>
</ContentPage>

Ce code définit de manière déclarative l’interface utilisateur de la page, qui se compose d’un Editor pour
la saisie de texte, et de deux Button instances qui indiquent à l’application d’enregistrer ou de supprimer un
fichier. Les deux Button instances sont présentées horizontalement dans un Grid , avec Editor et Grid
disposés verticalement dans un StackLayout . De plus, Editor utilise la liaison de données pour établir
une liaison à la propriété Text du modèle Note . Pour plus d’informations sur la liaison de données,
consultez liaison de données dans l' Xamarin.Forms exploration approfondie des Démarrages rapides.
Enregistrez les changements apportés à NoteEntr yPage.xaml en choisissant Fichier > Enregistrer (ou
en appuyant sur ⌘ +S ), puis fermez le fichier.
9. Dans NoteEntr yPage.xaml.cs , supprimez l’ensemble du code du modèle, puis remplacez-le par le code
suivant :
using System;
using System.IO;
using Xamarin.Forms;
using Notes.Models;

namespace Notes
{
public partial class NoteEntryPage : ContentPage
{
public NoteEntryPage()
{
InitializeComponent();
}

async void OnSaveButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;

if (string.IsNullOrWhiteSpace(note.Filename))
{
// Save
var filename = Path.Combine(App.FolderPath, $"{Path.GetRandomFileName()}.notes.txt");
File.WriteAllText(filename, note.Text);
}
else
{
// Update
File.WriteAllText(note.Filename, note.Text);
}

await Navigation.PopAsync();
}

async void OnDeleteButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;

if (File.Exists(note.Filename))
{
File.Delete(note.Filename);
}

await Navigation.PopAsync();
}
}
}

Ce code stocke une Note instance, qui représente une seule note dans le BindingContext de la page.
Lorsque l' enregistrement Button est activé OnSaveButtonClicked , le gestionnaire d’événements est
exécuté, ce qui permet d’enregistrer le contenu du Editor dans un nouveau fichier avec un nom de fichier
généré de manière aléatoire ou un fichier existant si une note est mise à jour. Dans les deux cas, le fichier est
stocké dans le dossier de données d’application local de l’application. La méthode revient ensuite à la page
précédente. Lorsque la suppression Button est activée, le OnDeleteButtonClicked Gestionnaire
d’événements est exécuté, ce qui a pour effet de supprimer le fichier, à condition qu’il existe, et de revenir à
la page précédente. Pour plus d’informations sur la navigation, consultez navigation dans la présentation
Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les changements apportés à NoteEntr yPage.xaml.cs en choisissant Fichier > Enregistrer
(ou en appuyant sur ⌘ +S ), puis fermez le fichier.
WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

10. Dans le panneau solutions , sélectionnez le projet Notes , cliquez avec le bouton droit, puis sélectionnez
Ajouter > nouveau fichier.... Dans la boîte de dialogue nouveau fichier , sélectionnez formulaires >
Forms ContentPage XAML , nommez le nouveau fichier NotesPage , puis cliquez sur le bouton nouveau
.
Cela permet d’ajouter une page nommée NotesPage au dossier racine du projet. Cette page représente la
page racine de l’application.
11. Dans NotesPage.xaml , supprimez l’ensemble du code du modèle, puis remplacez-le par le code suivant :

<?xml version="1.0" encoding="UTF-8"?>


<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NotesPage"
Title="Notes">
<ContentPage.ToolbarItems>
<ToolbarItem Text="+"
Clicked="OnNoteAddedClicked" />
</ContentPage.ToolbarItems>
<ListView x:Name="listView"
Margin="20"
ItemSelected="OnListViewItemSelected">
<ListView.ItemTemplate>
<DataTemplate>
<TextCell Text="{Binding Text}"
Detail="{Binding Date}" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
</ContentPage>

Ce code définit de manière déclarative l’interface utilisateur de la page, qui se compose d’un ListView et
d’un ToolbarItem . ListView utilise la liaison de données pour afficher les notes récupérées par
l’application. La sélection d’une note permet d’accéder à NoteEntryPage , où elle peut être modifiée. Vous
pouvez également créer une note en appuyant sur ToolbarItem . Pour plus d’informations sur la liaison de
données, consultez liaison de données dans l' Xamarin.Forms exploration approfondie des Démarrages
rapides.
Enregistrez les changements apportés à NotesPage.xaml en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ), puis fermez le fichier.
12. Dans NotesPage.xaml.cs , supprimez l’ensemble du code du modèle, puis remplacez-le par le code
suivant :
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Xamarin.Forms;
using Notes.Models;

namespace Notes
{
public partial class NotesPage : ContentPage
{
public NotesPage()
{
InitializeComponent();
}

protected override void OnAppearing()


{
base.OnAppearing();

var notes = new List<Note>();

var files = Directory.EnumerateFiles(App.FolderPath, "*.notes.txt");


foreach (var filename in files)
{
notes.Add(new Note
{
Filename = filename,
Text = File.ReadAllText(filename),
Date = File.GetCreationTime(filename)
});
}

listView.ItemsSource = notes
.OrderBy(d => d.Date)
.ToList();
}

async void OnNoteAddedClicked(object sender, EventArgs e)


{
await Navigation.PushAsync(new NoteEntryPage
{
BindingContext = new Note()
});
}

async void OnListViewItemSelected(object sender, SelectedItemChangedEventArgs e)


{
if (e.SelectedItem != null)
{
await Navigation.PushAsync(new NoteEntryPage
{
BindingContext = e.SelectedItem as Note
});
}
}
}
}

Ce code définit les fonctionnalités de NotesPage . Lorsque la page s’affiche, la OnAppearing méthode est
exécutée, qui remplit le ListView avec toutes les notes qui ont été récupérées à partir du dossier de
données d’application local. Lorsque le ToolbarItem est activé OnNoteAddedClicked , le gestionnaire
d’événements est exécuté. Cette méthode navigue vers NoteEntryPage , en affectant la valeur
BindingContext NoteEntryPage à une nouvelle Note instance de. Quand un élément de ListView est
sélectionné, le gestionnaire d’événements OnListViewItemSelected s’exécute. Cette méthode navigue vers
NoteEntryPage , en affectant BindingContext à l' NoteEntryPage instance sélectionnée la valeur de Note .
Pour plus d’informations sur la navigation, consultez navigation dans la présentation Xamarin.Forms
approfondie des Démarrages rapides.
Enregistrez les changements apportés à NotesPage.xaml.cs en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ), puis fermez le fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

13. Dans le Panneau Solutions , double-cliquez sur App.xaml.cs pour l’ouvrir. Remplacez ensuite le code
existant par le code suivant :

using System;
using System.IO;
using Xamarin.Forms;

namespace Notes
{
public partial class App : Application
{
public static string FolderPath { get; private set; }

public App()
{
InitializeComponent();
FolderPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
MainPage = new NavigationPage(new NotesPage());
}
// ...
}
}

Ce code ajoute une déclaration d’espace de noms pour l’espace de noms System.IO ainsi qu’une
déclaration pour une propriété FolderPath statique de type string . La propriété FolderPath permet de
stocker le chemin sur l’appareil où les données de notes doivent être stockées. En outre, le code initialise la
FolderPath propriété dans le App constructeur et initialise la MainPage propriété pour qu’elle soit un
NavigationPage qui héberge une instance de NotesPage . Pour plus d’informations sur la navigation,
consultez navigation dans la présentation Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les modifications apportées à App.xaml.cs en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ) et fermez le fichier.
14. Dans le Panneau Solutions , dans le projet Notes , cliquez avec le bouton droit sur MainPage.xaml , puis
sélectionnez Supprimer . Dans la boîte de dialogue qui s’affiche, appuyez sur le bouton Supprimer pour
supprimer le fichier de votre disque dur.
Cela entraîne la suppression d’une page qui n’est plus utilisée.
15. Générez et exécutez le projet sur chaque plateforme. Pour plus d’informations, consultez Génération du
guide de démarrage rapide.
Dans NotesPage , appuyez sur le bouton + pour accéder à NoteEntr yPage , puis entrez une note. Une fois
que vous avez enregistré la note, l’application revient à NotesPage .
Entrez un certain nombre de notes, de longueur variable, pour observer le comportement de l’application.
Étapes suivantes
Dans ce démarrage rapide, vous avez appris comment :
Ajoutez des pages supplémentaires à une Xamarin.Forms solution.
Naviguer entre des pages
Utiliser la liaison de données pour synchroniser les données entre les éléments d’interface utilisateur et leur
source de données
Pour modifier l’application afin qu’elle stocke ses données dans une base de données SQLite.NET locale, passez au
prochain guide de démarrage rapide.
Next

Liens connexes
Notes (exemple)
Xamarin.Forms Présentation approfondie des Démarrages rapides
Stocker des données dans une base de données
SQLite.NET locale
05/10/2020 • 18 minutes to read • Edit Online

Télécharger l’exemple
Dans ce guide de démarrage rapide, vous allez apprendre à :
Utilisez le Gestionnaire de package NuGet pour ajouter un paquet NuGet à un projet.
Stockez les données localement dans une base de données SQLite.NET.
Le guide de démarrage rapide explique comment stocker des données dans une base de données SQLite.NET
locale. L’application finale est indiquée ci-dessous :

Page de page

Conditions préalables requises


Vous devez suivre correctement le précédent guide de démarrage rapide avant de tenter de suivre ce guide de
démarrage rapide. Vous pouvez également télécharger l’exemple du précédent guide de démarrage rapide, et
l’utiliser comme point de départ pour ce guide de démarrage rapide.

Mettre à jour l’application avec Visual Studio


1. Lancez Visual Studio, puis ouvrez la solution Notes.
2. Dans l’Explorateur de solutions , sélectionnez le projet Notes , cliquez avec le bouton droit, puis
sélectionnez Gérer les packages NuGet :
3. Dans le Gestionnaire de package NuGet , sélectionnez l’onglet Parcourir , recherchez et sélectionnez le
package NuGet sqlite-net-pcl , puis cliquez sur le bouton Installer pour l’ajouter au projet :

NOTE
Il existe plusieurs packages NuGet portant des noms similaires. Le package correct possède ces attributs :
Auteur (s) : Frank A. Krueger
ID sqlite-net-pcl
Lien NuGet : sqlite-net-pcl
Ne vous fiez pas au nom du package. Vous devez utiliser ce package NuGet dans les projets .NET Standard.

Ce package sera utilisé pour incorporer les opérations de base de données dans l’application.
4. Dans l’Explorateur de solutions , dans le projet Notes , ouvrez Note.cs dans le dossier Models , puis
remplacez le code existant par le code suivant :
using System;
using SQLite;

namespace Notes.Models
{
public class Note
{
[PrimaryKey, AutoIncrement]
public int ID { get; set; }
public string Text { get; set; }
public DateTime Date { get; set; }
}
}

Cette classe définit un modèle Note , qui stocke les données relatives à chaque note de l’application. La
propriété ID est marquée avec les attributs PrimaryKey et AutoIncrement pour garantir que chaque
instance de Note dans la base de données SQLite.NET a un ID unique fourni par SQLite.NET.
Enregistrez les changements apportés à Note.cs en appuyant sur Ctrl+S , puis fermez le fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

5. Dans l’Explorateur de solutions , ajoutez un nouveau dossier nommé Data au projet Notes .
6. Dans l’Explorateur de solutions , dans le projet Notes , ajoutez une nouvelle classe nommée
NoteDatabase au dossier Data .
7. Dans NoteDatabase.cs , remplacez le code existant par le code suivant :
using System.Collections.Generic;
using System.Threading.Tasks;
using SQLite;
using Notes.Models;

namespace Notes.Data
{
public class NoteDatabase
{
readonly SQLiteAsyncConnection _database;

public NoteDatabase(string dbPath)


{
_database = new SQLiteAsyncConnection(dbPath);
_database.CreateTableAsync<Note>().Wait();
}

public Task<List<Note>> GetNotesAsync()


{
return _database.Table<Note>().ToListAsync();
}

public Task<Note> GetNoteAsync(int id)


{
return _database.Table<Note>()
.Where(i => i.ID == id)
.FirstOrDefaultAsync();
}

public Task<int> SaveNoteAsync(Note note)


{
if (note.ID != 0)
{
return _database.UpdateAsync(note);
}
else
{
return _database.InsertAsync(note);
}
}

public Task<int> DeleteNoteAsync(Note note)


{
return _database.DeleteAsync(note);
}
}
}

Cette classe contient du code qui permet de créer la base de données, de lire les données existantes, d’en
écrire de nouvelles ou d’en supprimer. Le code utilise des API SQLite.NET asynchrones qui déplacent les
opérations de base de données vers les threads d’arrière-plan. De plus, le constructeur NoteDatabase prend
le chemin du fichier de base de données en tant qu’argument. Ce chemin est fourni par la classe App à
l’étape suivante.
Enregistrez les changements apportés à NoteDatabase.cs en appuyant sur Ctrl+S , puis fermez le fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

8. Dans l’Explorateur de solutions , dans le projet Notes , double-cliquez sur App.xaml.cs pour l’ouvrir.
Remplacez ensuite le code existant par le code suivant :
using System;
using System.IO;
using Xamarin.Forms;
using Notes.Data;

namespace Notes
{
public partial class App : Application
{
static NoteDatabase database;

public static NoteDatabase Database


{
get
{
if (database == null)
{
database = new
NoteDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"Notes.db3"));
}
return database;
}
}

public App()
{
InitializeComponent();
MainPage = new NavigationPage(new NotesPage());
}

protected override void OnStart()


{
// Handle when your app starts
}

protected override void OnSleep()


{
// Handle when your app sleeps
}

protected override void OnResume()


{
// Handle when your app resumes
}
}
}

Ce code définit une propriété Database , qui crée une instance de NoteDatabase en tant que singleton et
passe le nom de fichier de la base de données en tant qu’argument au constructeur NoteDatabase . Lorsque
vous exposez la base de données comme un singleton, une connexion de base de données unique est créée
et reste ouverte lors de l’exécution de l’application. Ainsi, vous évitez les dépenses liées à l’ouverture et à la
fermeture du fichier de base de données chaque fois qu’une opération de base de données est effectuée.
Enregistrez les modifications apportées à App.xaml.cs en appuyant sur Ctrl+S et fermez le fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

9. Dans l’Explorateur de solutions , dans le projet Notes , double-cliquez sur NotesPage.xaml.cs pour
l’ouvrir. Remplacez ensuite la méthode OnAppearing par le code suivant :
protected override async void OnAppearing()
{
base.OnAppearing();

listView.ItemsSource = await App.Database.GetNotesAsync();


}

Ce code remplit la ListView avec toutes les notes stockées dans la base de données.
Enregistrez les changements apportés à NotesPage.xaml.cs en appuyant sur Ctrl+S , puis fermez le
fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

10. Dans l’Explorateur de solutions , double-cliquez sur NoteEntr yPage.xaml.cs pour l’ouvrir. Remplacez
ensuite les méthodes OnSaveButtonClicked et OnDeleteButtonClicked par le code suivant :

async void OnSaveButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;
note.Date = DateTime.UtcNow;
await App.Database.SaveNoteAsync(note);
await Navigation.PopAsync();
}

async void OnDeleteButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;
await App.Database.DeleteNoteAsync(note);
await Navigation.PopAsync();
}

NoteEntryPage Stocke une Note instance, qui représente une seule note dans le BindingContext de la page.
Quand le gestionnaire d’événements OnSaveButtonClicked s’exécute, l’instance de Note est enregistrée
dans la base de données, et l’application revient à la page précédente. Quand le gestionnaire d’événements
OnDeleteButtonClicked s’exécute, l’instance de Note est supprimée de la base de données, et l’application
revient à la page précédente.
Enregistrez les changements apportés à NoteEntr yPage.xaml.cs en appuyant sur Ctrl+S , puis fermez le
fichier.
11. Générez et exécutez le projet sur chaque plateforme. Pour plus d’informations, consultez Génération du
guide de démarrage rapide.
Dans NotesPage , appuyez sur le bouton + pour accéder à NoteEntr yPage , puis entrez une note. Une fois
que vous avez enregistré la note, l’application revient à NotesPage .
Entrez un certain nombre de notes, de longueur variable, pour observer le comportement de l’application.

Mettre à jour l’application avec Visual Studio pour Mac


1. Lancez Visual Studio pour Mac, puis ouvrez le projet Notes.
2. Dans le Panneau Solutions , sélectionnez le projet Notes , cliquez avec le bouton droit, puis sélectionnez
Ajouter > Ajouter des paquets NuGet :
3. Dans la fenêtre Ajouter des packages , recherchez et sélectionnez le package NuGet sqlite-net-pcl , puis
cliquez sur le bouton Ajouter un package pour l’ajouter au projet :

NOTE
Il existe plusieurs packages NuGet portant des noms similaires. Le package correct possède ces attributs :
Author : Frank A. Krueger
ID sqlite-net-pcl
Lien NuGet : sqlite-net-pcl
Ne vous fiez pas au nom du package. Vous devez utiliser ce package NuGet dans les projets .NET Standard.

Ce package sera utilisé pour incorporer les opérations de base de données dans l’application.
4. Dans le Panneau Solutions , dans le projet Notes , ouvrez Note.cs dans le dossier Models , puis
remplacez le code existant par le code suivant :
using System;
using SQLite;

namespace Notes.Models
{
public class Note
{
[PrimaryKey, AutoIncrement]
public int ID { get; set; }
public string Text { get; set; }
public DateTime Date { get; set; }
}
}

Cette classe définit un modèle Note , qui stocke les données relatives à chaque note de l’application. La
propriété ID est marquée avec les attributs PrimaryKey et AutoIncrement pour garantir que chaque
instance de Note dans la base de données SQLite.NET a un ID unique fourni par SQLite.NET.
Enregistrez les changements apportés à Note.cs en choisissant Fichier > Enregistrer (ou en appuyant
sur ⌘ +S ), puis fermez le fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

5. Dans le Panneau Solutions , ajoutez un nouveau dossier nommé Data au projet Notes .
6. Dans le Panneau Solutions , dans le projet Notes , ajoutez une nouvelle classe nommée NoteDatabase
au dossier Data .
7. Dans NoteDatabase.cs , remplacez le code existant par le code suivant :
using System.Collections.Generic;
using System.Threading.Tasks;
using SQLite;
using Notes.Models;

namespace Notes.Data
{
public class NoteDatabase
{
readonly SQLiteAsyncConnection _database;

public NoteDatabase(string dbPath)


{
_database = new SQLiteAsyncConnection(dbPath);
_database.CreateTableAsync<Note>().Wait();
}

public Task<List<Note>> GetNotesAsync()


{
return _database.Table<Note>().ToListAsync();
}

public Task<Note> GetNoteAsync(int id)


{
return _database.Table<Note>()
.Where(i => i.ID == id)
.FirstOrDefaultAsync();
}

public Task<int> SaveNoteAsync(Note note)


{
if (note.ID != 0)
{
return _database.UpdateAsync(note);
}
else
{
return _database.InsertAsync(note);
}
}

public Task<int> DeleteNoteAsync(Note note)


{
return _database.DeleteAsync(note);
}
}
}

Cette classe contient du code qui permet de créer la base de données, de lire les données existantes, d’en
écrire de nouvelles ou d’en supprimer. Le code utilise des API SQLite.NET asynchrones qui déplacent les
opérations de base de données vers les threads d’arrière-plan. De plus, le constructeur NoteDatabase prend
le chemin du fichier de base de données en tant qu’argument. Ce chemin est fourni par la classe App à
l’étape suivante.
Enregistrez les changements apportés à NoteDatabase.cs en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ), puis fermez le fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

8. Dans le Panneau Solutions , dans le projet Notes , double-cliquez sur App.xaml.cs pour l’ouvrir.
Remplacez ensuite le code existant par le code suivant :

using System;
using System.IO;
using Xamarin.Forms;
using Notes.Data;

namespace Notes
{
public partial class App : Application
{
static NoteDatabase database;

public static NoteDatabase Database


{
get
{
if (database == null)
{
database = new
NoteDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"Notes.db3"));
}
return database;
}
}

public App()
{
InitializeComponent();
MainPage = new NavigationPage(new NotesPage());
}

protected override void OnStart()


{
// Handle when your app starts
}

protected override void OnSleep()


{
// Handle when your app sleeps
}

protected override void OnResume()


{
// Handle when your app resumes
}
}
}

Ce code définit une propriété Database , qui crée une instance de NoteDatabase en tant que singleton et
passe le nom de fichier de la base de données en tant qu’argument au constructeur NoteDatabase . Lorsque
vous exposez la base de données comme un singleton, une connexion de base de données unique est créée
et reste ouverte lors de l’exécution de l’application. Ainsi, vous évitez les dépenses liées à l’ouverture et à la
fermeture du fichier de base de données chaque fois qu’une opération de base de données est effectuée.
Enregistrez les modifications apportées à App.xaml.cs en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ) et fermez le fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.
9. Dans le Panneau Solutions , dans le projet Notes , double-cliquez sur NotesPage.xaml.cs pour l’ouvrir.
Remplacez ensuite la méthode OnAppearing par le code suivant :

protected override async void OnAppearing()


{
base.OnAppearing();

listView.ItemsSource = await App.Database.GetNotesAsync();


}

Ce code remplit la ListView avec toutes les notes stockées dans la base de données.
Enregistrez les changements apportés à NotesPage.xaml.cs en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ), puis fermez le fichier.

WARNING
À ce stade, si vous tentez de générer l’application, cela entraîne des erreurs qui seront corrigées plus tard.

10. Dans le Panneau Solutions , double-cliquez sur NoteEntr yPage.xaml.cs pour l’ouvrir. Remplacez ensuite
les méthodes OnSaveButtonClicked et OnDeleteButtonClicked par le code suivant :

async void OnSaveButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;
note.Date = DateTime.UtcNow;
await App.Database.SaveNoteAsync(note);
await Navigation.PopAsync();
}

async void OnDeleteButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;
await App.Database.DeleteNoteAsync(note);
await Navigation.PopAsync();
}

NoteEntryPage Stocke une Note instance, qui représente une seule note dans le BindingContext de la page.
Quand le gestionnaire d’événements OnSaveButtonClicked s’exécute, l’instance de Note est enregistrée
dans la base de données, et l’application revient à la page précédente. Quand le gestionnaire d’événements
OnDeleteButtonClicked s’exécute, l’instance de Note est supprimée de la base de données, et l’application
revient à la page précédente.
Enregistrez les changements apportés à NoteEntr yPage.xaml.cs en choisissant Fichier > Enregistrer
(ou en appuyant sur ⌘ +S ), puis fermez le fichier.
11. Générez et exécutez le projet sur chaque plateforme. Pour plus d’informations, consultez Génération du
guide de démarrage rapide.
Dans NotesPage , appuyez sur le bouton + pour accéder à NoteEntr yPage , puis entrez une note. Une fois
que vous avez enregistré la note, l’application revient à NotesPage .
Entrez un certain nombre de notes, de longueur variable, pour observer le comportement de l’application.

Étapes suivantes
Dans ce démarrage rapide, vous avez appris comment :
Utilisez le Gestionnaire de package NuGet pour ajouter un paquet NuGet à un projet.
Stockez les données localement dans une base de données SQLite.NET.
Pour appliquer des styles à l’application à l’aide de styles XAML, passez au prochain guide de démarrage rapide.
Next

Liens connexes
Notes (exemple)
Xamarin.Forms Présentation approfondie des Démarrages rapides
Styliser une application multiplateforme
Xamarin.Forms
05/10/2020 • 10 minutes to read • Edit Online

Télécharger l’exemple
Dans ce guide de démarrage rapide, vous allez apprendre à :
Stylisez une Xamarin.Forms application à l’aide de styles XAML.
Le Guide de démarrage rapide explique comment styliser une Xamarin.Forms application multiplateforme à l’aide
de styles XAML. L’application finale est indiquée ci-dessous :

Page de page

Conditions préalables requises


Vous devez suivre correctement le précédent guide de démarrage rapide avant de tenter de suivre ce guide de
démarrage rapide. Vous pouvez également télécharger l’exemple du précédent guide de démarrage rapide, et
l’utiliser comme point de départ pour ce guide de démarrage rapide.

Mettre à jour l’application avec Visual Studio


1. Lancez Visual Studio, puis ouvrez la solution Notes.
2. Dans l’Explorateur de solutions , dans le projet Notes , double-cliquez sur App.xaml pour l’ouvrir.
Remplacez ensuite le code existant par le code suivant :
<?xml version="1.0" encoding="utf-8"?>
<Application xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.App">
<Application.Resources>

<Thickness x:Key="PageMargin">20</Thickness>

<!-- Colors -->


<Color x:Key="AppBackgroundColor">AliceBlue</Color>
<Color x:Key="NavigationBarColor">#1976D2</Color>
<Color x:Key="NavigationBarTextColor">White</Color>

<!-- Implicit styles -->


<Style TargetType="{x:Type NavigationPage}">
<Setter Property="BarBackgroundColor"
Value="{StaticResource NavigationBarColor}" />
<Setter Property="BarTextColor"
Value="{StaticResource NavigationBarTextColor}" />
</Style>

<Style TargetType="{x:Type ContentPage}"


ApplyToDerivedTypes="True">
<Setter Property="BackgroundColor"
Value="{StaticResource AppBackgroundColor}" />
</Style>

</Application.Resources>
</Application>

Ce code définit une Thickness valeur, une série de Color valeurs et des styles implicites pour
NavigationPage et ContentPage . Notez que ces styles, qui sont au niveau de l’application
ResourceDictionary , peuvent être utilisés dans l’ensemble de l’application. Pour plus d’informations sur le
style XAML, consultez l’article sur les styles dans la présentation Xamarin.Forms approfondie des
Démarrages rapides.
Enregistrez les changements apportés à App.xaml en appuyant sur Ctrl+S , puis fermez le fichier.
3. Dans l’Explorateur de solutions , dans le projet Notes , double-cliquez sur NotesPage.xaml pour l’ouvrir.
Remplacez ensuite le code existant par le code suivant :
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NotesPage"
Title="Notes">
<ContentPage.Resources>
<!-- Implicit styles -->
<Style TargetType="{x:Type ListView}">
<Setter Property="BackgroundColor"
Value="{StaticResource AppBackgroundColor}" />
</Style>
</ContentPage.Resources>

<ContentPage.ToolbarItems>
<ToolbarItem Text="+"
Clicked="OnNoteAddedClicked" />
</ContentPage.ToolbarItems>

<ListView x:Name="listView"
Margin="{StaticResource PageMargin}"
ItemSelected="OnListViewItemSelected">
<ListView.ItemTemplate>
<DataTemplate>
<TextCell Text="{Binding Text}"
TextColor="Black"
Detail="{Binding Date}" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>

</ContentPage>

Ce code ajoute un style implicite à au niveau de la ListView page ResourceDictionary et affecte à la


ListView.Margin propriété une valeur définie au niveau de l’application ResourceDictionary . Notez que le
style implicite de ListView a été ajouté à ResourceDictionary au niveau de la page, car il est uniquement
consommé par NotesPage . Pour plus d’informations sur le style XAML, consultez l’article sur les styles dans
la présentation Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les changements apportés à NotesPage.xaml en appuyant sur Ctrl+S , puis fermez le fichier.
4. Dans l’Explorateur de solutions , dans le projet Notes , double-cliquez sur NoteEntr yPage.xaml pour
l’ouvrir. Remplacez ensuite le code existant par le code suivant :
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NoteEntryPage"
Title="Note Entry">
<ContentPage.Resources>
<!-- Implicit styles -->
<Style TargetType="{x:Type Editor}">
<Setter Property="BackgroundColor"
Value="{StaticResource AppBackgroundColor}" />
</Style>

<Style TargetType="Button"
ApplyToDerivedTypes="True"
CanCascade="True">
<Setter Property="FontSize" Value="Medium" />
<Setter Property="BackgroundColor" Value="#1976D2" />
<Setter Property="TextColor" Value="White" />
<Setter Property="CornerRadius" Value="5" />
</Style>
</ContentPage.Resources>

<StackLayout Margin="{StaticResource PageMargin}">


<Editor Placeholder="Enter your note"
Text="{Binding Text}"
HeightRequest="100" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Button Text="Save"
Clicked="OnSaveButtonClicked" />
<Button Grid.Column="1"
Text="Delete"
Clicked="OnDeleteButtonClicked" />
</Grid>
</StackLayout>

</ContentPage>

Ce code ajoute des styles implicites pour les Editor Button vues et au niveau de la page
ResourceDictionary , et affecte StackLayout.Margin à la propriété une valeur définie au niveau de
l’application ResourceDictionary . Notez que les styles implicites de Editor et Button ont été ajoutés à
ResourceDictionary au niveau de la page, car ils sont consommés uniquement par NoteEntryPage . Pour
plus d’informations sur le style XAML, consultez l’article sur les styles dans la présentation Xamarin.Forms
approfondie des Démarrages rapides.
Enregistrez les changements apportés à NoteEntr yPage.xaml en appuyant sur Ctrl+S , puis fermez le
fichier.
5. Générez et exécutez le projet sur chaque plateforme. Pour plus d’informations, consultez Génération du
guide de démarrage rapide.
Dans NotesPage , appuyez sur le bouton + pour accéder à NoteEntr yPage , puis entrez une note. Sur
chaque page, notez la façon dont le style a changé par rapport au précédent guide de démarrage rapide.

Mettre à jour l’application avec Visual Studio pour Mac


1. Lancez Visual Studio pour Mac, puis ouvrez le projet Notes.
2. Dans le Panneau Solutions , dans le projet Notes , double-cliquez sur App.xaml pour l’ouvrir. Remplacez
ensuite le code existant par le code suivant :

<?xml version="1.0" encoding="utf-8"?>


<Application xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.App">
<Application.Resources>

<Thickness x:Key="PageMargin">20</Thickness>

<!-- Colors -->


<Color x:Key="AppBackgroundColor">AliceBlue</Color>
<Color x:Key="NavigationBarColor">#1976D2</Color>
<Color x:Key="NavigationBarTextColor">White</Color>

<!-- Implicit styles -->


<Style TargetType="{x:Type NavigationPage}">
<Setter Property="BarBackgroundColor"
Value="{StaticResource NavigationBarColor}" />
<Setter Property="BarTextColor"
Value="{StaticResource NavigationBarTextColor}" />
</Style>

<Style TargetType="{x:Type ContentPage}"


ApplyToDerivedTypes="True">
<Setter Property="BackgroundColor"
Value="{StaticResource AppBackgroundColor}" />
</Style>

</Application.Resources>
</Application>

Ce code définit une Thickness valeur, une série de Color valeurs et des styles implicites pour
NavigationPage et ContentPage . Notez que ces styles, qui sont au niveau de l’application
ResourceDictionary , peuvent être utilisés dans l’ensemble de l’application. Pour plus d’informations sur le
style XAML, consultez l’article sur les styles dans la présentation Xamarin.Forms approfondie des
Démarrages rapides.
Enregistrez les changements apportés à App.xaml en choisissant Fichier > Enregistrer (ou en appuyant
sur ⌘ +S ), puis fermez le fichier.
3. Dans le Panneau Solutions , dans le projet Notes , double-cliquez sur NotesPage.xaml pour l’ouvrir.
Remplacez ensuite le code existant par le code suivant :
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NotesPage"
Title="Notes">
<ContentPage.Resources>
<!-- Implicit styles -->
<Style TargetType="{x:Type ListView}">
<Setter Property="BackgroundColor"
Value="{StaticResource AppBackgroundColor}" />
</Style>
</ContentPage.Resources>

<ContentPage.ToolbarItems>
<ToolbarItem Text="+"
Clicked="OnNoteAddedClicked" />
</ContentPage.ToolbarItems>

<ListView x:Name="listView"
Margin="{StaticResource PageMargin}"
ItemSelected="OnListViewItemSelected">
<ListView.ItemTemplate>
<DataTemplate>
<TextCell Text="{Binding Text}"
TextColor="Black"
Detail="{Binding Date}" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>

</ContentPage>

Ce code ajoute un style implicite à au niveau de la ListView page ResourceDictionary et affecte à la


ListView.Margin propriété une valeur définie au niveau de l’application ResourceDictionary . Notez que le
style implicite de ListView a été ajouté à ResourceDictionary au niveau de la page, car il est uniquement
consommé par NotesPage . Pour plus d’informations sur le style XAML, consultez l’article sur les styles dans
la présentation Xamarin.Forms approfondie des Démarrages rapides.
Enregistrez les changements apportés à NotesPage.xaml en choisissant Fichier > Enregistrer (ou en
appuyant sur ⌘ +S ), puis fermez le fichier.
4. Dans le Panneau Solutions , dans le projet Notes , double-cliquez sur NoteEntr yPage.xaml pour l’ouvrir.
Remplacez ensuite le code existant par le code suivant :
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NoteEntryPage"
Title="Note Entry">
<ContentPage.Resources>
<!-- Implicit styles -->
<Style TargetType="{x:Type Editor}">
<Setter Property="BackgroundColor"
Value="{StaticResource AppBackgroundColor}" />
</Style>

<Style TargetType="Button"
ApplyToDerivedTypes="True"
CanCascade="True">
<Setter Property="FontSize" Value="Medium" />
<Setter Property="BackgroundColor" Value="#1976D2" />
<Setter Property="TextColor" Value="White" />
<Setter Property="CornerRadius" Value="5" />
</Style>
</ContentPage.Resources>

<StackLayout Margin="{StaticResource PageMargin}">


<Editor Placeholder="Enter your note"
Text="{Binding Text}"
HeightRequest="100" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Button Text="Save"
Clicked="OnSaveButtonClicked" />
<Button Grid.Column="1"
Text="Delete"
Clicked="OnDeleteButtonClicked" />
</Grid>
</StackLayout>

</ContentPage>

Ce code ajoute des styles implicites pour les Editor Button vues et au niveau de la page
ResourceDictionary , et affecte StackLayout.Margin à la propriété une valeur définie au niveau de
l’application ResourceDictionary . Notez que les styles implicites de Editor et Button ont été ajoutés à
ResourceDictionary au niveau de la page, car ils sont consommés uniquement par NoteEntryPage . Pour
plus d’informations sur le style XAML, consultez l’article sur les styles dans la présentation Xamarin.Forms
approfondie des Démarrages rapides.
Enregistrez les changements apportés à NoteEntr yPage.xaml en choisissant Fichier > Enregistrer (ou
en appuyant sur ⌘ +S ), puis fermez le fichier.
5. Générez et exécutez le projet sur chaque plateforme. Pour plus d’informations, consultez Génération du
guide de démarrage rapide.
Dans NotesPage , appuyez sur le bouton + pour accéder à NoteEntr yPage , puis entrez une note. Sur
chaque page, notez la façon dont le style a changé par rapport au précédent guide de démarrage rapide.

Étapes suivantes
Dans ce démarrage rapide, vous avez appris comment :
Stylisez une Xamarin.Forms application à l’aide de styles XAML.
Pour en savoir plus sur les notions de base du développement d’applications à l’aide de Xamarin.Forms , passez à
la présentation approfondie des Démarrages rapides.
Next

Liens connexes
Notes (exemple)
Xamarin.Forms Présentation approfondie des Démarrages rapides
Xamarin.Forms Présentation approfondie
des Démarrages rapides
05/10/2020 • 35 minutes to read • Edit Online

Dans le Guide de Xamarin.Forms démarrage rapide, l’application notes a été générée. Cet article
passe en revue ce qui a été conçu pour comprendre les principes de base du fonctionnement des
Xamarin.Forms applications.

Introduction à Visual Studio


Visual Studio organise le code en solutions et projets. Une solution est un conteneur qui peut
comprendre un ou plusieurs projets. Un projet peut être une application, une bibliothèque de
prise en charge, une application de test, etc. L’application Notes se compose d’une solution qui
contient quatre projets, comme le montre la capture d’écran suivante :

Les projets sont :


Remarques - Ce projet est le projet de bibliothèque .NET Standard qui contient l’ensemble du
code partagé et de l’IU partagée.
Notes.Android - Ce projet contient du code spécifique à Android et constitue le point d’entrée
pour l’application Android.
Notes.iOS - Ce projet contient du code spécifique à iOS et constitue le point d’entrée pour
l’application iOS.
Notes.UWP - Ce projet contient du code spécifique à la plateforme UWP (plateforme Windows
universelle) et constitue le point d’entrée pour l’application UWP.

Anatomie d’une Xamarin.Forms application


La capture d’écran suivante montre le contenu du projet de bibliothèque .NET Standard Notes
dans Visual Studio :
Le projet a un nœud dépendances qui contient les nœuds NuGet et SDK :
NuGet – les Xamarin.Forms packages NuGet et SQLite-net-PCL qui ont été ajoutés au projet.
SDK – Métapaquet NETStandard.Library qui référence l’ensemble complet des paquets NuGet
définissant .NET Standard.

Introduction à Visual Studio pour Mac


Tout comme Visual Studio, Visual Studio pour Mac organise le code en solutions et en projets.
Une solution est un conteneur qui peut comprendre un ou plusieurs projets. Un projet peut être
une application, une bibliothèque de prise en charge, une application de test, etc. L’application
Notes se compose d’une solution qui contient trois projets, comme le montre la capture d’écran
suivante :

Les projets sont :


Remarques - Ce projet est le projet de bibliothèque .NET Standard qui contient l’ensemble du
code partagé et de l’IU partagée.
Notes.Android - Ce projet contient du code spécifique à Android et constitue le point d’entrée
pour les applications Android.
Notes.iOS - Ce projet contient du code spécifique à iOS et constitue le point d’entrée pour les
applications iOS.

Anatomie d’une Xamarin.Forms application


La capture d’écran suivante montre le contenu du projet de bibliothèque .NET Standard Notes
dans Visual Studio pour Mac :
Le projet a un nœud dépendances qui contient les nœuds NuGet et SDK :
NuGet – les Xamarin.Forms packages NuGet et SQLite-net-PCL qui ont été ajoutés au projet.
SDK – Métapaquet NETStandard.Library qui référence l’ensemble complet des paquets NuGet
définissant .NET Standard.
Le projet comprend également un certain nombre de fichiers :
Data\NoteDatabase.cs - Cette classe contient du code qui permet de créer la base de
données, de lire les données existantes, d’en écrire de nouvelles ou d’en supprimer.
Models\Note.cs - Cette classe définit un modèle Note dont les instances stockent les
données relatives à chaque note de l’application.
App.xaml : balisage XAML pour la classe App , qui définit un dictionnaire de ressources pour
l’application.
App.xaml.cs : code-behind pour la classe App , qui est chargé de l’instanciation de la
première page affichée par l’application sur chaque plateforme et de la gestion des
événements du cycle de vie de l’application.
AssemblyInfo.cs - Ce fichier contient un attribut d’application sur le projet, qui est appliqué
au niveau de l’assembly.
NotesPage.xaml - Balisage XAML pour la classe NotesPage , qui définit l’IU de la page
affichée au lancement de l’application.
NotesPage.xaml.cs - Code-behind de la classe NotesPage , qui contient la logique métier
exécutée quand l’utilisateur interagit avec la page.
NoteEntr yPage.xaml - Balisage XAML pour la classe NoteEntryPage , qui définit l’IU de la
page affichée quand l’utilisateur entre une note.
NoteEntr yPage.xaml.cs - Code-behind de la classe NoteEntryPage , qui contient la logique
métier exécutée quand l’utilisateur interagit avec la page.
Pour plus d’informations sur la structure d’une application Xamarin.iOS, consultez Structure
d’une application Xamarin.iOS. Pour plus d’informations sur la structure d’une application
Xamarin.Android, consultez Structure d’une application Xamarin.Android.

Concepts fondamentaux de l’architecture et de l’application


Une Xamarin.Forms application est structurée de la même façon qu’une application
multiplateforme traditionnelle. En général, le code partagé est placé dans une bibliothèque .NET
Standard et les applications spécifiques à la plateforme consomment le code partagé. Le
diagramme suivant présente une vue d’ensemble de cette relation pour l’application Notes :

Pour optimiser la réutilisation du code de démarrage, les Xamarin.Forms applications ont une
seule classe nommée App qui est chargée d’instancier la première page qui sera affichée par
l’application sur chaque plateforme, comme illustré dans l’exemple de code suivant :
using Xamarin.Forms;

namespace Notes
{
public partial class App : Application
{
public App()
{
InitializeComponent();
MainPage = new NavigationPage(new NotesPage());
}
...
}
}

Ce code affecte MainPage à la propriété de la App classe une NavigationPage instance dont le
contenu est une NotesPage instance.
De plus, le fichier AssemblyInfo.cs contient un seul attribut d’application, qui est appliqué au
niveau de l’assembly :

using Xamarin.Forms.Xaml;

[assembly: XamlCompilation(XamlCompilationOptions.Compile)]

L' XamlCompilation attribut Active le compilateur XAML, afin que le XAML soit compilé
directement en langage intermédiaire. Pour plus d’informations, consultez Compilation XAML.

Lancement de l’application sur chaque plateforme


iOS
Pour lancer la Xamarin.Forms page initiale dans iOS, le projet notes. iOS définit la AppDelegate
classe qui hérite de la FormsApplicationDelegate classe :

namespace Notes.iOS
{
[Register("AppDelegate")]
public partial class AppDelegate :
global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate
{
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
global::Xamarin.Forms.Forms.Init();
LoadApplication(new App());
return base.FinishedLaunching(app, options);
}
}
}

La FinishedLaunching substitution Initialise le Xamarin.Forms Framework en appelant la Init


méthode. Cela entraîne le chargement de l’implémentation spécifique à iOS Xamarin.Forms dans
l’application avant que le contrôleur d’affichage racine soit défini par l’appel à la LoadApplication
méthode.
Android
Pour lancer la Xamarin.Forms page initiale dans Android, le projet notes. Android comprend du
code qui crée un Activity avec l' MainLauncher attribut, avec l’activité qui hérite de la
FormsAppCompatActivity classe :

namespace Notes.Droid
{
[Activity(Label = "Notes",
Icon = "@mipmap/icon",
Theme = "@style/MainTheme",
MainLauncher = true,
ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]
public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
{
protected override void OnCreate(Bundle savedInstanceState)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;

base.OnCreate(savedInstanceState);
global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
LoadApplication(new App());
}
}
}

La OnCreate substitution Initialise le Xamarin.Forms Framework en appelant la Init méthode.


Cela entraîne le chargement de l’implémentation spécifique à Android Xamarin.Forms dans
l’application avant le chargement de l' Xamarin.Forms application.
Plateforme Windows universelle
Dans les applications plateforme Windows universelle (UWP), la Init méthode qui initialise l'
Xamarin.Forms infrastructure est appelée à partir de la App classe :

Xamarin.Forms.Forms.Init (e);

if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
...
}

Cela entraîne le chargement de l’implémentation spécifique Xamarin.Forms à UWP dans


l’application. La Xamarin.Forms page initiale est lancée par la MainPage classe :

namespace Notes.UWP
{
public sealed partial class MainPage
{
public MainPage()
{
this.InitializeComponent();
this.LoadApplication(new Notes.App());
}
}
}

L' Xamarin.Forms application est chargée avec la LoadApplication méthode.


NOTE
Plateforme Windows universelle applications peuvent être générées avec Xamarin.Forms , mais
uniquement à l’aide de Visual Studio sur Windows.

Interface utilisateur
Quatre groupes de contrôles principaux sont utilisés pour créer l’interface utilisateur d’une
Xamarin.Forms application :
1. Pages : les Xamarin.Forms pages représentent des écrans d’application mobile
multiplateforme. L’application notes utilise la ContentPage classe pour afficher des écrans
uniques. Pour plus d’informations sur les pages, consultez Xamarin.Forms pages.
2. Vues : Xamarin.Forms les vues sont les contrôles affichés dans l’interface utilisateur, tels que
les étiquettes, les boutons et les zones de saisie de texte. L’application notes terminée utilise
les ListView Editor vues, et Button . Pour plus d’informations sur les affichages, consultez
Xamarin.Forms vues.
3. Dispositions : Xamarin.Forms les dispositions sont des conteneurs utilisés pour composer
des vues en structures logiques. L’application notes utilise la StackLayout classe pour
réorganiser les vues dans une pile verticale, et la Grid classe pour réorganiser les boutons
horizontalement. Pour plus d’informations sur les dispositions, consultez Xamarin.Forms
dispositions.
4. Cellules : Xamarin.Forms les cellules sont des éléments spécialisés utilisés pour les éléments
d’une liste et décrivent comment chaque élément d’une liste doit être dessiné. L’application
notes utilise le TextCell pour afficher deux éléments pour chaque ligne de la liste. Pour plus
d’informations sur les cellules, consultez Xamarin.Forms Cells.
Lors de l’exécution, chaque contrôle est mappé à son équivalent natif, ce qui sera affiché.
Layout
L’application notes utilise le StackLayout pour simplifier le développement d’applications
interplateformes en organisant automatiquement des vues sur l’écran, quelle que soit la taille de
l’écran. Les éléments enfants sont placés les uns après les autres, horizontalement ou
verticalement dans l’ordre dans lequel ils ont été ajoutés. La quantité d’espace que le
StackLayout doit utiliser dépend de la façon dont les HorizontalOptions VerticalOptions
Propriétés et sont définies, mais par défaut, le StackLayout essaie d’utiliser la totalité de l’écran.
Le code XAML suivant illustre un exemple d’utilisation d’un StackLayout pour mettre en page le
NoteEntryPage :
<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NoteEntryPage"
Title="Note Entry">
...
<StackLayout Margin="{StaticResource PageMargin}">
<Editor Placeholder="Enter your note"
Text="{Binding Text}"
HeightRequest="100" />
<Grid>
...
</Grid>
</StackLayout>
</ContentPage>

Par défaut, le StackLayout suppose une orientation verticale. Toutefois, il peut être remplacé par
une orientation horizontale en affectant StackLayout.Orientation à la propriété le membre de l'
StackOrientation.Horizontal énumération.

NOTE
Vous pouvez définir la taille des vues à l’aide des propriétés HeightRequest et WidthRequest .

Pour plus d’informations sur la StackLayout classe, consultez StackLayout.


Réponse aux interactions de l’utilisateur
Un objet défini en XAML peut déclencher un événement qui est géré dans le fichier code-behind.
L’exemple de code suivant montre la OnSaveButtonClicked méthode dans le code-behind pour la
NoteEntryPage classe, qui est exécutée en réponse à l' Clicked événement déclenché sur le
bouton Enregistrer .

async void OnSaveButtonClicked(object sender, EventArgs e)


{
var note = (Note)BindingContext;
note.Date = DateTime.UtcNow;
await App.Database.SaveNoteAsync(note);
await Navigation.PopAsync();
}

La méthode OnSaveButtonClicked enregistre la note dans la base de données, puis revient à la


page précédente.

NOTE
Le fichier code-behind d’une classe XAML peut accéder à un objet défini en XAML en utilisant le nom qui
lui est affecté avec l’attribut x:Name . La valeur affectée à cet attribut suit les mêmes règles que les
variables C# : elle doit commencer par une lettre ou un trait de soulignement et ne contenir aucun
espace incorporé.

L’association du bouton d’enregistrement à la méthode OnSaveButtonClicked se produit dans le


balisage XAML pour la classe NoteEntryPage :
<Button Text="Save"
Clicked="OnSaveButtonClicked" />

Listes
ListViewEst chargé d’afficher une collection d’éléments verticalement dans une liste. Chaque
élément de ListView est contenu dans une seule cellule.
L’exemple de code suivant montre le ListView à partir du NotesPage :

<ListView x:Name="listView"
Margin="{StaticResource PageMargin}"
ItemSelected="OnListViewItemSelected">
<ListView.ItemTemplate>
<DataTemplate>
<TextCell Text="{Binding Text}"
Detail="{Binding Date}" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>

La disposition de chaque ligne du ListView est définie dans l' ListView.ItemTemplate élément et
utilise la liaison de données pour afficher toutes les notes récupérées par l’application. La
ListView.ItemsSource propriété est définie sur la source de données, dans NotesPage.xaml.cs :

protected override async void OnAppearing()


{
base.OnAppearing();

listView.ItemsSource = await App.Database.GetNotesAsync();


}

Ce code remplit la ListView avec toutes les notes stockées dans la base de données.
Lorsqu’une ligne est sélectionnée dans le ListView , l' ItemSelected événement se déclenche.
Un gestionnaire d’événements, nommé OnListViewItemSelected , s’exécute quand l’événement se
déclenche :

async void OnListViewItemSelected(object sender, SelectedItemChangedEventArgs e)


{
if (e.SelectedItem != null)
{
...
}
}

L' ItemSelected événement peut accéder à l’objet qui a été associé à la cellule par le biais de la
e.SelectedItem propriété.
Pour plus d’informations sur la ListView classe, consultez ListView.

Navigation
Xamarin.Forms fournit un certain nombre d’expériences de navigation entre les pages différentes,
selon le Page type utilisé. Pour les ContentPage instances, la navigation peut être hiérarchique
ou modale. Pour plus d’informations sur la navigation modale, consultez Xamarin.Forms pages
modales.
NOTE
Les CarouselPage MasterDetailPage classes, et TabbedPage fournissent d’autres expériences de
navigation. Pour plus d’informations, consultez Navigation.

Dans la navigation hiérarchique, la NavigationPage classe est utilisée pour naviguer dans une pile
d' ContentPage objets, vers l’avant et vers l’arrière, selon les besoins. La classe implémente la
navigation sous la forme d’une pile d’objets LIFO (dernier entré, premier sorti) Page . Pour
passer d’une page à une autre, une application envoie une nouvelle page dans la pile de
navigation, où elle devient la page active. Pour revenir à la page précédente, l’application dépile la
page actuelle, et la nouvelle page tout en haut devient la page active.
La classe NavigationPage ajoute également une barre de navigation en haut de la page qui
affiche un titre et un bouton Précédent approprié à la plateforme qui permet de revenir à la
page précédente.
La première page ajoutée à une pile de navigation est appelée la page racine de l’application.
L’exemple de code suivant illustre le déroulement de l’opération dans l’application Notes :

public App ()
{
...
MainPage = new NavigationPage (new NotesPage ());
}

Toutes les ContentPage instances ont une Navigation propriété qui expose des méthodes pour
modifier la pile de pages. Ces méthodes ne doivent être appelées que si l’application comprend
un NavigationPage . Pour naviguer jusqu’au NoteEntryPage , il est nécessaire d’appeler [
PushAsync ] (XREF : Xamarin.Forms . NavigationPage. PushAsync ( Xamarin.Forms . Page)),
comme illustré dans l’exemple de code ci-dessous :

await Navigation.PushAsync(new NoteEntryPage());

Ainsi, le nouvel objet NoteEntryPage est envoyé (push) vers la pile de navigation, où il devient la
page active.
La page active peut être retirée de la pile de navigation en appuyant sur le bouton Précédent sur
l’appareil, qu’il s’agisse d’un bouton physique sur l’appareil ou d’un bouton à l’écran. Pour revenir
par programmation à la page d’origine, l' NoteEntryPage objet doit appeler la PopAsync méthode,
comme illustré dans l’exemple de code ci-dessous :

await Navigation.PopAsync();

Pour plus d’informations sur la navigation hiérarchique, consultez Navigation hiérarchique.

Liaison de données
La liaison de données permet de simplifier la façon dont une Xamarin.Forms application s’affiche
et interagit avec ses données. Elle établit une connexion entre l’interface utilisateur et l’application
sous-jacente. La BindableObject classe contient une grande partie de l’infrastructure pour
prendre en charge la liaison de données.
La liaison de données connecte deux objets, appelés la source et la cible. L’objet source fournit les
données. L’objet cible consomme (et affiche souvent) les données de l’objet source. Par exemple,
un Editor (objetcible ) lie généralement sa Text propriété à une propriété publique string
dans un objet source . Le diagramme suivant illustre la relation de liaison :

Le principal avantage de la liaison de données est que vous n’avez plus à vous soucier de la
synchronisation des données entre les vues et la source de données. Les modifications apportées
à l’objet source sont automatiquement envoyées à l’objet cible dans les coulisses par le
framework de liaison, et les modifications apportées à l’objet cible peuvent éventuellement être
renvoyées à l’objet source.
L’établissement de la liaison de données est un processus en deux étapes :
La BindingContext propriété de l’objet cible doit être définie sur la source.
Une liaison doit être établie entre la cible et la source. En XAML, cela est effectué à l’aide de l'
Binding extension de balisage.

Dans l’application notes, la cible de liaison est le Editor qui affiche une note, tandis que l' Note
instance définie en tant que BindingContext de NoteEntryPage est la source de liaison.
Le BindingContext de NoteEntryPage est défini pendant la navigation dans la page, comme
illustré dans l’exemple de code suivant :

async void OnNoteAddedClicked(object sender, EventArgs e)


{
await Navigation.PushAsync(new NoteEntryPage
{
BindingContext = new Note()
});
}

async void OnListViewItemSelected(object sender, SelectedItemChangedEventArgs e)


{
if (e.SelectedItem != null)
{
await Navigation.PushAsync(new NoteEntryPage
{
BindingContext = e.SelectedItem as Note
});
}
}

Dans la OnNoteAddedClicked méthode, qui est exécutée lorsqu’une nouvelle note est ajoutée à
l’application, BindingContext la NoteEntryPage valeur de est définie sur une nouvelle Note
instance. Dans la OnListViewItemSelected méthode, qui est exécutée quand une note existante est
sélectionnée dans le ListView , le BindingContext du NoteEntryPage est défini sur l' Note
instance sélectionnée, accessible via la e.SelectedItem propriété.
IMPORTANT
La BindingContext propriété de chaque objet cible peut être définie individuellement, ce qui n’est pas
nécessaire. BindingContext est une propriété spéciale qui est héritée par tous ses enfants. Par
conséquent, lorsque le BindingContext sur ContentPage est défini sur une Note instance de, tous
les enfants de l' ContentPage objet ont le même BindingContext et peuvent effectuer une liaison aux
propriétés publiques de l' Note objet.

Le Editor dans NoteEntryPage crée alors une liaison avec la Text propriété de l' Note objet :

<Editor Placeholder="Enter your note"


Text="{Binding Text}"
... />

Une liaison entre la Editor.Text propriété et la Text propriété de l’objet source est établie. Les
changements apportés dans Editor sont automatiquement propagés à l’objet Note . De même,
si des modifications sont apportées à la Note.Text propriété, le Xamarin.Forms moteur de
liaison mettra également à jour le contenu du Editor . Il s’agit là d’une liaison bidirectionnelle.
Pour plus d’informations sur la liaison de données, consultez Xamarin.Forms liaison de données.

Styles
Xamarin.Forms les applications contiennent souvent plusieurs éléments visuels qui ont une
apparence identique. La définition de l’apparence de chaque élément visuel peut être répétitive et
sujette aux erreurs. À la place, vous pouvez créer des styles qui définissent l’apparence, puis les
appliquer aux éléments visuels nécessaires.
La Style classe regroupe une collection de valeurs de propriété dans un objet qui peut ensuite
être appliqué à plusieurs instances d’éléments visuels. Les styles sont stockés dans un, au niveau
de l’application, au niveau de ResourceDictionary la page ou au niveau de la vue. Le fait de
choisir où définir Style impacte l’emplacement où il peut être utilisé :
Style les instances définies au niveau de l’application peuvent être appliquées dans
l’ensemble de l’application.
Style les instances définies au niveau de la page peuvent être appliquées à la page et à ses
enfants.
Style les instances définies au niveau de la vue peuvent être appliquées à la vue et à ses
enfants.

IMPORTANT
Tous les styles utilisés dans l’application sont stockés dans le dictionnaire de ressources de l’application
pour éviter la duplication. Toutefois, le code XAML qui est spécifique à une page ne doit pas être inclus
dans le dictionnaire de ressources de l’application, car les ressources sont alors analysées au démarrage
de l’application et non lorsqu’une page le demande.

Chaque instance contient une collection d’un ou de plusieurs Setter objets, chacun
Style
Setter ayant un Property et un Value . Property est le nom de la propriété pouvant être liée
de l’élément auquel le style est appliqué, et Value est la valeur qui est appliquée à la propriété.
L’exemple de code suivant illustre un style de NoteEntryPage :
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.NoteEntryPage"
Title="Note Entry">
<ContentPage.Resources>
<!-- Implicit styles -->
<Style TargetType="{x:Type Editor}">
<Setter Property="BackgroundColor"
Value="{StaticResource AppBackgroundColor}" />
</Style>
...
</ContentPage.Resources>
...
</ContentPage>

Ce style est appliqué à toutes les Editor instances de la page.


Lors de la création d’un Style , la TargetType propriété est toujours obligatoire.

NOTE
Le style d’une Xamarin.Forms application est généralement effectué à l’aide de styles XAML. Toutefois,
Xamarin.Forms prend également en charge le style des éléments visuels à l’aide d’feuilles de style en
cascade (CSS). Pour plus d’informations, consultez stylisation d' Xamarin.Forms applications à l’aide de
feuilles de style en cascade (CSS).

Pour plus d’informations sur les styles XAML, consultez stylisation d' Xamarin.Forms applications
à l’aide de styles XAML.
Fourniture de styles spécifiques à la plateforme
Les extensions de balisage OnPlatform vous permettent de personnaliser l’apparence de l’IU
pour chaque plateforme :

<Application xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.App">
<Application.Resources>
...
<Color x:Key="iOSNavigationBarColor">WhiteSmoke</Color>
<Color x:Key="AndroidNavigationBarColor">#2196F3</Color>
<Color x:Key="iOSNavigationBarTextColor">Black</Color>
<Color x:Key="AndroidNavigationBarTextColor">White</Color>

<Style TargetType="{x:Type NavigationPage}">


<Setter Property="BarBackgroundColor"
Value="{OnPlatform iOS={StaticResource iOSNavigationBarColor},
Android={StaticResource AndroidNavigationBarColor}}"
/>
<Setter Property="BarTextColor"
Value="{OnPlatform iOS={StaticResource iOSNavigationBarTextColor},
Android={StaticResource
AndroidNavigationBarTextColor}}" />
</Style>
...
</Application.Resources>
</Application>

Cela permet de définir des Color valeurs différentes pour les BarBackgroundColor
Style
BarTextColor Propriétés et de NavigationPage , en fonction de la plateforme utilisée.
Pour plus d’informations sur les extensions de balisage XAML, consultez Extensions de balisage
XAML. Pour plus d’informations sur l’extension de balisage OnPlatform , consultez Extension de
balisage OnPlatform.

Tests et déploiement
Visual Studio pour Mac et Visual Studio proposent tous deux de nombreuses options pour tester
et déployer les applications. Le débogage d’applications est une partie courante du cycle de vie
de développement des applications et permet de diagnostiquer les problèmes de code. Pour plus
d’informations, consultez Définir un point d’arrêt, Exécuter du code pas à pas et Informations de
sortie dans la fenêtre de journal.
Les simulateurs constituent un endroit judicieux pour commencer à déployer et tester une
application, et comportent des fonctionnalités utiles pour le test des applications. Toutefois, les
utilisateurs ne consommant pas l’application finale dans un simulateur, les applications doivent
être testées tôt et souvent sur des appareils réels. Pour plus d’informations sur le
provisionnement des appareils iOS, consultez Provisionnement des appareils. Pour plus
d’informations sur le provisionnement des appareils Android, consultez Configurer un appareil
pour le développement.

Étapes suivantes
Cette présentation approfondie a examiné les notions de base du développement d’applications à
l’aide de Xamarin.Forms . Les étapes suggérées ci-dessous incluent la découverte des
fonctionnalités suivantes :
Quatre groupes de contrôles principaux sont utilisés pour créer l’interface utilisateur d’une
Xamarin.Forms application. Pour plus d’informations, consultez Informations de référence sur
les contrôles.
La liaison de données est une technique qui permet de lier les propriétés de deux objets afin
que les changements d’une propriété soient automatiquement répercutés sur l’autre
propriété. Pour plus d’informations, consultez Liaison de données.
Xamarin.Forms fournit un certain nombre d’expériences de navigation entre les pages
différentes, en fonction du type de page utilisé. Pour plus d’informations, consultez
Navigation.
Les styles contribuent à réduire le balisage répétitif et permettent de modifier plus facilement
l’apparence des applications. Pour plus d’informations, consultez application d’un style aux
Xamarin.Forms applications.
Les extensions de balisage XAML étendent la puissance et la flexibilité du langage XAML en
permettant de définir des attributs d’éléments à partir de sources autres que des chaînes de
texte littéral. Pour plus d’informations, consultez Extensions de balisage XAML.
Les modèles de données permettent de définir la présentation des données sur les affichages
pris en charge. Pour plus d’informations, consultez Modèles de données.
Chaque page, disposition et affichage est restitué différemment sur chaque plateforme avec
une classe Renderer qui crée ensuite un contrôle natif, le dispose à l’écran et ajoute le
comportement spécifié dans le code partagé. Les développeurs peuvent implémenter leurs
propres classes Renderer pour personnaliser l’apparence et/ou le comportement d’un
contrôle. Pour plus d’informations, consultez Renderers personnalisés.
Les effets permettent également de personnaliser les contrôles natifs sur chaque plateforme.
Les effets sont créés dans des projets spécifiques à la plateforme en sous-classant la
PlatformEffect classe et sont consommés en les joignant à un Xamarin.Forms contrôle
approprié. Pour plus d’informations, consultez Effets.
Le code partagé peut accéder aux fonctionnalités natives par le biais de la DependencyService
classe. Pour plus d’informations, consultez Accès aux fonctionnalités natives avec
DependencyService.
Vous pouvez également _créer des Mobile Apps Xamarin.Forms avec _, un livre de Charles
Petzold, pour en savoir plus sur Xamarin.Forms . Le livre est disponible au format PDF ou dans
une variété de formats électroniques.

Liens connexes
XAML (eXtensible Application Markup Language)
Liaison de données
Informations de référence sur les contrôles
Extensions de balisage XAML
Xamarin.Forms Extraits
Exemples de Prise en main
Xamarin.Forms Référence d’API
Autoformation gratuite (vidéo)

Vidéo connexe

Retrouvez d’autres vidéos Xamarin sur Channel 9 et YouTube.


Multiplateforme pour les développeurs de postes de
travail
23/04/2020 • 2 minutes to read • Edit Online

Cette section contient des informations destinées à aider WPF et Windows Forms développeurs à apprendre le
développement d’applications mobiles avec Xamarin, en référençant leurs connaissances et leur expérience
existantes sur des idiomes mobiles et en fournissant des exemples de Portage d’applications de bureau vers des
appareils mobiles.

Comparaison du cycle de vie des applications


Comprendre les différences entre les États de démarrage et d’arrière-plan des applications WPF et Xamarin. Forms.

Comparaison des contrôles d’interface utilisateur


Aide-mémoire pour trouver des contrôles équivalents dans Windows Forms, WPF et Xamarin. Forms, y compris des
conseils supplémentaires sur les différences entre WPF et Xamarin. Forms.

Guide de Portage
Utilisation de l’analyseur de portabilité pour faciliter la migration du code de l’application de bureau (à l’exclusion
de l’interface utilisateur) vers Xamarin. Forms.

Exemples
Exemples de référence illustrant l’architecture des applications d’entreprise et le portage du code de WPF vers
Xamarin. Forms.

En savoir plus
Xamarin pour les développeurs Java
05/10/2020 • 51 minutes to read • Edit Online

Si vous êtes un développeur Java, vous pouvez tirer parti de vos compétences et de votre code existant sur la
plateforme Xamarin tout en bénéficiant des avantages de la réutilisation de code de C#. Vous constaterez que la
syntaxe C# est très similaire à la syntaxe Java, et que les deux langages fournissent des fonctionnalités très
similaires. En outre, vous découvrirez des fonctionnalités propres à C# qui faciliteront votre développement.

Vue d’ensemble
Cet article constitue une introduction à la programmation C# pour les développeurs Java, qui met principalement
l’accent sur les fonctionnalités du langage C# que vous rencontrerez en développant des applications
Xamarin.Android. En outre, cet article explique en quoi ces fonctionnalités diffèrent de leurs équivalents Java et C#,
et présente des fonctionnalités importantes (pertinentes pour Xamarin.Android) qui ne sont pas disponibles dans
Java. Des liens vers des références supplémentaires sont inclus. Vous pouvez donc utiliser cet article comme point
de départ pour approfondir vos connaissances sur C# et .NET.
Si vous êtes familiarisé avec Java, vous n’aurez aucune difficulté à aborder la syntaxe du langage C#. La syntaxe C#
est très similaire à la syntaxe Java – C# est un langage à « accolades », comme Java, C et C++. À bien des égards, la
syntaxe C# peut être vue comme un sur-ensemble de la syntaxe Java, mais avec quelques mots-clés renommés et
ajoutés.
Vous trouverez de nombreuses caractéristiques clés de Java dans C# :
Programmation orientée objet basée sur les classes
Typage fort
Prise en charge des interfaces
Génériques
Garbage collection
Compilation du runtime
Java et C# sont compilés dans un langage intermédiaire qui est exécuté dans un environnement d’exécution géré.
C# et Java sont typés de façon statique, et les deux langages traitent les chaînes en tant que types immuables. Les
deux langages utilisent une hiérarchie de classes à racine unique. Comme Java, C# prend uniquement en charge
l’héritage unique et n’autorise pas les méthodes globales. Dans les deux langages, les objets sont créés sur le tas en
utilisant le mot-clé new et les objets sont récupérés par le garbage collector lorsqu’ils ne sont plus utilisés. Les deux
langages fournissent la prise en charge des exceptions formelles avec une sémantique try / catch . Les deux
prennent en charge la gestion et la synchronisation des threads.
Toutefois, il existe de nombreuses différences entre les Java et C#. Par exemple :
Java (tel qu’il est utilisé sur Android) ne prend pas en charge les variables locales implicitement typées (C#
prend en charge le var mot clé).
En Java, vous pouvez passer des paramètres uniquement par valeur, tandis qu’en C#, vous pouvez passer des
références ou des valeurs. (C# fournit les mots-clés ref et out pour le passage de paramètres par
référencent ; il n’existe pas d’équivalent en Java).
Java ne prend pas en charge les directives de préprocesseur comme #define .
Java ne prend pas en charge les types d’entiers non signés, tandis que C# fournit des types d’entiers non
signés comme ulong , uint , ushort et byte .
Java ne prend pas en charge la surcharge d’opérateur. En C#, vous pouvez surcharger les opérateurs et
conversions.
Dans une instruction switch Java, le code peut passer dans la section switch suivante, mais en C#, la fin de
chaque section switch doit arrêter le switch (la fin de chaque section doit se fermer avec une instruction
break ).

En Java, vous spécifiez les exceptions levées par une méthode avec le mot-clé throws , mais C# n’a aucun
concept des exceptions vérifiées – le mot clé throws n’est pas pris en charge en C#.
C# prend en charge Language-Integrated Query (LINQ), qui vous permet d’utiliser les mots réservés from ,
select , et where pour écrire des requêtes sur des collections d’une manière similaire aux requêtes de base
de données.
Bien entendu, il existe de nombreuses différences supplémentaires entre C# et Java qui ne peuvent être traitées
dans cet article. En outre, Java et C# continuent à évoluer (par exemple, Java 8, ce qui n’est pas encore dans la
chaîne d’outils Android, prend en charge les expressions lambda de style C#), aussi ces différences évoluent au fil
du temps. Les principales différences actuellement rencontrées par les développeurs Java qui découvrent
Xamarin.Android sont décrites ici.
Passer du développement Java à c# fournit une introduction aux différences fondamentales entre C# et Java.
Les fonctionnalités de programmation orientée objet délignent les principales différences de fonctionnalités
orientées objet entre les deux langages.
Différences de mots clés fournit un tableau d’équivalents de mots clés utiles, des mots clés en c#
uniquement et des liens vers les définitions de mots clés c#.
C# propose plusieurs fonctionnalités essentielles dans Xamarin.Android qui ne sont pas actuellement disponibles
pour les développeurs Java sur Android. Ces fonctionnalités peuvent vous aider à mieux écrire votre code, en moins
de temps :
Propriétés – de Avec le système de propriétés de C#, vous pouvez accéder aux variables de membre en toute
sécurité et directement sans avoir à écrire des méthodes setter et getter.
Expressions lambda – En C#, vous pouvez utiliser des méthodes anonymes (également appelées expressions
lambda) pour exprimer vos fonctionnalités plus succinctement et plus efficacement. Vous pouvez éviter
d’avoir à écrire des objets à usage unique, et passer l’état local à une méthode sans avoir à ajouter des
paramètres.
Gestion des événements – C# fournit la prise en charge, au niveau du langage, de la programmation pilotée
par les événements, qui permet d’enregistrer un objet pour qu’il reçoive des notifications quand un
événement d’intérêt se produit. Le mot-clé event définit un mécanisme de diffusion multidiffusion, qu’une
classe d’éditeur peut utiliser pour notifier les abonnés aux événements.
Programmation asynchrone – Les fonctionnalités de programmation asynchrone de C# ( async / await )
conservent les applications réactives. La prise en charge au niveau du langage de cette fonctionnalité rend la
programmation asynchrone facile à implémenter et moins sujette aux erreurs.
Enfin, Xamarin vous permet de tirer parti des ressources Java existantes via une technologie appelée liaison. Vous
pouvez appeler votre code, vos infrastructures et vos bibliothèques Java dans C# en utilisant les générateurs de
liaison automatiques de Xamarin. Pour ce faire, vous créez simplement une bibliothèque statique dans Java et
l’exposez à C# via une liaison.
NOTE
La programmation Android utilise une version spécifique du langage Java qui prend en charge toutes les fonctionnalités Java
7 et un sous-ensemble de Java 8.
Certaines fonctionnalités mentionnées sur cette page (par exemple, le var mot clé en C#) sont disponibles dans les versions
plus récentes de Java (par exemple, var dans Java 10), mais elles ne sont toujours pas disponibles pour les développeurs
Android.

Passer du développement Java au développement C#


Les sections suivantes décrivent les principales différences de prise en main entre les langages C# et Java ; une
section ultérieure décrit les différences de programmation orientée objet entre ces langages.
Bibliothèques et assemblys
Java empaquète généralement les classes connexes dans des fichiers .jar . En C# et en .NET, toutefois, les parties
réutilisables de code précompilé sont empaquetées dans des assemblys, qui sont généralement fournis sous forme
de fichiers .dll. Un assembly est une unité de déploiement pour le code C#/.NET, et chaque assembly est
généralement associé à un projet C#. Les assemblys contiennent le code intermédiaire (IL) qui est compilé juste-à-
temps lors de l’exécution.
Pour plus d’informations sur les assemblys, consultez la rubrique Assemblys et le Global Assembly Cache.
Packages et espaces de noms
C# utilise le mot-clé namespace pour grouper les types associés ensemble ; Cela s’apparente au mot-clé package de
Java. En règle générale, une application Xamarin.Android réside dans un espace de noms créé pour cette
application. Par exemple, le code C# suivant déclare le wrapper d’espace de noms WeatherApp pour une application
météorologique :

namespace WeatherApp
{
...

Importation de types
Lorsque vous utilisez des types définis dans des espaces de noms externes, vous importez ces types avec une
instruction using (qui est très similaire à l’instruction import de Java). En Java, vous pouvez importer un seul type
avec une instruction comme suit :

import javax.swing.JButton

Vous pouvez importer un package Java entier avec une instruction comme celle-ci :

import javax.swing.*

L’instruction using de C# fonctionne de façon très similaire, mais elle vous permet d’importer un package entier
sans spécifier de caractère générique. Par exemple, vous verrez souvent une série d’instructions using au début
des fichiers source Xamarin.Android, comme illustré dans cet exemple :
using System;
using Android.App;
using Android.Content;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Android.OS;
using System.Net;
using System.IO;
using System.Json;
using System.Threading.Tasks;

Ces instructions importent les fonctionnalités des espaces de noms System , Android.App , Android.Content , etc.
Génériques
Java et C# prennent en charge les génériques, qui sont des espaces réservés qui vous permettent de connecter
différents types au moment de la compilation. Toutefois, les génériques fonctionnent différemment en C#. En Java,
l’effacement de type rend les informations de type disponibles uniquement au moment de la compilation, mais pas
au moment de l’exécution. En revanche, le common language runtime (CLR) .NET fournit une prise en charge
explicite des types génériques, ce qui signifie que C# a accès aux informations de type lors de l’exécution. Pour le
développement Xamarin.Android au quotidien, l’importance de cette distinction n’est pas souvent évidente, mais si
vous utilisez la réflexion, cette fonctionnalité est cruciale pour accéder aux informations de type au moment de
l’exécution.
Dans Xamarin.Android, vous verrez souvent la méthode générique FindViewById utilisée pour obtenir une
référence à un contrôle de disposition. Cette méthode accepte un paramètre de type générique qui spécifie le type
de contrôle à rechercher. Par exemple :

TextView label = FindViewById<TextView> (Resource.Id.Label);

Dans cet exemple de code, FindViewById obtient une référence au contrôle TextView qui est défini dans la
disposition en tant que Label , puis la renvoie en tant que type TextView .
Pour plus d’informations sur les génériques, consultez la rubrique Génériques. Notez qu’il existe certaines
limitations de prise en charge des classes génériques C# par Xamarin.Android ; Pour plus d’informations, consultez
Limitations.

Fonctionnalités de programmation orientée objet


Java et C# utilisent des idiomes de programmation orientée objet très similaires :
Toutes les classes sont au final dérivées d’un objet racine unique – Tous les objets Java dérivent de
java.lang.Object , tandis que tous les objets C# dérivent de System.Object .

Les instances de classe sont des types référence.


Lorsque vous accédez à des propriétés et méthodes d’une instance, vous utilisez l’opérateur « . ».
Toutes les instances de classe sont créées sur le tas via l’opérateur new .
Étant donné que les deux langages utilisent le garbage collection, il n’existe aucun moyen de libérer
explicitement les objets non utilisés (il n’y a pas de mot clé delete comme en C++).
Vous pouvez étendre les classes par héritage, et les deux langages autorisent une seule classe de base par
type.
Vous pouvez définir des interfaces, et une classe peut hériter (autrement dit, implémenter) plusieurs
définitions d’interface.
Toutefois, il y a des différences importantes :
Java a deux fonctionnalités puissantes que C# ne prend pas en charge : les classes anonymes et les classes
internes. (Toutefois, C# autorise l’imbrication de définitions de classe – Les classes imbriquées de C# sont
semblables aux classes imbriquées statiques de Java.)
C# prend en charge les types de structure de style C ( struct ), ce que Java ne fait pas.
En C#, vous pouvez implémenter une définition de classe dans des fichiers sources distincts à l’aide du mot
clé partial .
Les interfaces C# ne peuvent pas déclarer de types.
C# utilise une syntaxe de destructeur de style C++ pour exprimer les finaliseurs. La syntaxe est différente de
la méthode finalize de Java, mais la sémantique est quasiment identique. (Notez qu’en C#, les destructeurs
appellent automatiquement le destructeur de classe de base – contrairement à Java où un appel explicite à
super.finalize est utilisé.)

Héritage de classe
Pour étendre une classe Java, vous utilisez le mot-clé extends . Pour étendre une classe en C#, vous utilisez un signe
deux-points ( : ) pour indiquer la dérivation. Par exemple, dans les applications Xamarin.Android, vous verrez
souvent des dérivations de classe qui ressemblent au fragment de code suivant :

public class MainActivity : Activity


{
...

Dans cet exemple, MainActivity hérite de la classe Activity .


Pour déclarer la prise en charge pour une interface en Java, vous utilisez le mot-clé implements . Toutefois, en C#,
vous ajoutez simplement les noms d’interface à la liste des classes à partir desquelles hériter, comme indiqué dans
ce fragment de code :

public class SensorsActivity : Activity, ISensorEventListener


{
...

Dans cet exemple, SensorsActivity hérite de Activity et implémente les fonctionnalités déclarées dans l’interface
ISensorEventListener . Notez que la liste des interfaces doit se trouver après la classe de base (ou vous aurez une
erreur de compilation). Par convention, les noms d’interface C# se finissent par une majuscule « I » ; Il est ainsi
possible de déterminer les classes qui sont des interfaces sans nécessiter de mot-clé implements .
Lorsque vous souhaitez empêcher une classe d’être encore sous-classée en C#, vous faites précéder le nom de la
classe de sealed – dans Java, vous faites précéder le nom de la classe de final .
Pour plus d’informations sur les définitions de classe C#, consultez les rubriques Classes et Héritage.
Propriétés
En Java, les méthodes de mutateurs (setters) et d’inspecteurs (getters) sont souvent utilisées pour contrôler la façon
dont les modifications sont apportées aux membres de classe tout en masquant et protégeant ces membres à
partir de l’extérieur du code. Par exemple, la classe TextView d’Android fournit les méthodes getText et setText .
C# fournit un mécanisme similaire, mais plus direct appelé propriétés. Les utilisateurs d’une classe C# peuvent
accéder à une propriété de la même façon qu’ils accèdent à un champ, mais chaque accès entraîne en fait un appel
de méthode qui est transparent pour l’appelant. Cette méthode « en coulisses » peut implémenter des effets
secondaires, tels que la définition d’autres valeurs, la réalisation de conversions ou la modification d’état des objets.
Les propriétés sont souvent utilisées pour l’accès et modification des membres de l’objet d’interface utilisateur. Par
exemple :

int width = rulerView.MeasuredWidth;


int height = rulerView.MeasuredHeight;
...
rulerView.DrawingCacheEnabled = true;

Dans cet exemple, les valeurs de largeur et de hauteur sont lues à partir de l’objet rulerView en accédant à ses
propriétés MeasuredWidth et MeasuredHeight . Lorsque ces propriétés sont lues, les valeurs de leurs champs associés
(mais masqués) sont extraites en arrière-plan et retournées à l’appelant. L’objet rulerView peut stocker des valeurs
de largeur et de hauteur dans une unité de mesure (par exemple, en pixels) et convertir ces valeurs à la volée en
une autre unité de mesure (par exemple, en millimètres) lorsque les propriétés MeasuredWidth et MeasuredHeight
sont accessibles.
L' rulerView objet a également une propriété appelée DrawingCacheEnabled – l’exemple de code qui affecte la
valeur à cette propriété true pour activer le cache de dessin dans rulerView . En arrière-plan, un champ masqué
associé est mis à jour avec la nouvelle valeur et d’autres aspects de l’état rulerView sont éventuellement modifiés.
Par exemple, lorsque DrawingCacheEnabled est défini sur false , rulerView peut également supprimer toutes les
informations de cache de dessin déjà accumulées dans l’objet.
L’accès aux propriétés peut être en lecture/écriture, en lecture seule ou en écriture seule. En outre, vous pouvez
utiliser des modificateurs d’accès différents pour lire et écrire. Par exemple, vous pouvez définir une propriété qui a
un accès en lecture public mais un accès en écriture privé.
Pour plus d’informations sur les propriétés C#, consultez la rubrique Propriétés.
Appel des méthodes de la classe de base
Pour appeler un constructeur de classe de base en C#, vous utilisez un signe deux-points ( : ) suivi du mot-clé
base et d’une liste d’initialiseurs ; cet appel de constructeur base est placé immédiatement après la liste de
paramètres du constructeur dérivé. Le constructeur de classe de base est appelé sur entrée pour le constructeur
dérivé ; le compilateur insère l’appel au constructeur de base au début du corps de la méthode. Le fragment de
code suivant illustre un constructeur de base appelé à partir d’un constructeur dérivé dans une application
Xamarin.Android :

public class PictureLayout : ViewGroup


{
...
public PictureLayout (Context context)
: base (context)
{
...
}
...
}

Dans cet exemple, la classe PictureLayout est dérivée de ViewGroup . Le constructeur PictureLayout illustré dans
cet exemple de constructeur accepte un argument context et le passe au constructeur ViewGroup via l’appel
base(context) .

Pour appeler une méthode de classe de base en C#, utilisez le mot-clé base . Par exemple, les applications
Xamarin.Android appellent souvent des méthodes de base, comme illustré ici :
public class MainActivity : Activity
{
...
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);

Dans ce cas, la méthode OnCreate définie par la classe dérivée ( MainActivity ) appelle la méthode OnCreate de la
classe de base ( Activity ).
Modificateurs d’accès
Java et C# prennent en charge les modificateurs d’accès public , private et protected . Toutefois, C# prend en
charge deux modificateurs d’accès supplémentaires :
internal –Le membre de classe est accessible uniquement dans l’assembly actuel.
protected internal –Le membre de classe est accessible dans l’assembly de définition, la classe de définition
et les classes dérivées (les classes dérivées à l’intérieur et à l’extérieur de l’assembly ont accès).
Pour plus d’informations sur les modificateurs d’accès C#, consultez la rubrique Modificateurs d’accès.
Méthodes virtuelles et override
Java et C# prennent en charge le polymorphisme, la possibilité de traiter les objets connexes de la même manière.
Dans les deux langages, vous pouvez utiliser une référence de classe de base pour faire référence à un objet de
classe dérivée, et les méthodes d’une classe dérivée peuvent substituer les méthodes de ses classes de base. Les
deux langages ont le concept de méthode virtuelle, une méthode dans une classe de base qui est conçue pour être
remplacée par une méthode dans une classe dérivée. Comme Java, C# prend en charge les classes et méthodes
abstract .

Toutefois, il existe certaines différences entre Java et C# dans la façon de déclarer des méthodes virtuelles et les
remplacer :
Par défaut, les méthodes ne sont pas virtuelles. Les classes parentes doivent libeller explicitement les
méthodes à remplacer en utilisant le mot-clé virtual . En revanche, toutes les méthodes dans Java sont des
méthodes virtuelles par défaut.
Pour empêcher une méthode d’être substituée en C#, vous laissez simplement le mot-clé virtual . Par
contraste, Java utilise le mot-clé final pour marquer une méthode avec l’instruction « le remplacement
n’est pas autorisé. »
Les classes dérivées C# doivent utiliser le mot clé override pour indiquer explicitement qu’une méthode de
classe de base virtuelle est substituée.
Pour plus d’informations sur la prise en charge du polymorphisme par C#, consultez la rubrique Polymorphisme.

Expressions lambda
C# permet de créer des fermetures: des méthodes anonymes intégrées qui peuvent accéder à l’état de la méthode
dans laquelle elles sont placées. Avec les expressions lambda, vous pouvez écrire moins de lignes de code pour
implémenter la même fonctionnalité que vous auriez implémentée dans Java avec nombreuses lignes de code
supplémentaires.
Les expressions lambda permettent d’ignorer les étapes supplémentaires impliquées dans la création d’une classe à
usage unique ou anonyme comme vous le feriez dans Java – au lieu de cela, vous pouvez écrire uniquement la
logique métier de votre code de méthode de façon intégrée. En outre, étant donné que les expressions lambda ont
accès aux variables dans la méthode environnante, il est inutile de créer une longue liste de paramètres pour passer
l’état au code de votre méthode.
En C#, les expressions lambda sont créées avec l’opérateur => , comme indiqué ici :

(arg1, arg2, ...) => {


// implementation code
};

Dans Xamarin.Android, les expressions lambda sont souvent utilisées pour définir des gestionnaires d’événements.
Par exemple :

button.Click += (sender, args) => {


clickCount += 1; // access variable in surrounding code
button.Text = string.Format ("Clicked {0} times.", clickCount);
};

Dans cet exemple, le code d’expression lambda (le code entre les accolades) incrémente un nombre de clics et met à
jour le texte button pour afficher le nombre de clics. Cette expression lambda est inscrite avec l’objet button
comme un gestionnaire d’événements à appeler lorsque l’utilisateur clique sur le bouton. (Les gestionnaires
d’événements sont expliqués plus en détail ci-dessous.) Dans cet exemple simple, les sender paramètres et ne
args sont pas utilisés par le code d’expression lambda, mais ils sont requis dans l’expression lambda pour
respecter les exigences de signature de méthode pour l’inscription des événements. Dans la pratique, le
compilateur C# convertit l’expression lambda en une méthode anonyme qui est appelée chaque fois que des
événements de clic de bouton se produisent.
Pour plus d’informations sur C# et les expressions lambda, consultez la rubrique Expressions lambda.

Gestion des événements


Un événement est le moyen pour un objet de notifier les abonnés inscrits lorsque quelque chose d’intéressant se
produit sur cet objet. Contrairement à Java, dans lequel un abonné implémente généralement une interface
Listener qui contient une méthode de rappel, C# fournit la prise en charge au niveau du langage pour la gestion
des événements via des délégués. Un délégué est similaire à un pointeur de fonction de type sécurisé et orienté
objet – il encapsule une référence d’objet et un jeton de méthode. Si un objet client veut s’abonner à un événement,
il crée un délégué et passe le délégué à l’objet de notification. Lorsque l’événement se produit, l’objet de notification
appelle la méthode représentée par l’objet délégué, informant ainsi l’objet de client abonnement de l’événement. En
C#, les gestionnaires d'événements sont surtout de simples méthodes appelées par le biais de délégués.
Pour plus d’informations sur les délégués, consultez la rubrique Délégués.
En C#, les événements sont multidiffusion ; Autrement dit, plusieurs écouteurs peuvent être avertis lorsqu’un
événement se produit. Cette différence est notable lorsque vous envisagez les différences syntaxiques entre les
inscriptions aux événements en Java et en C#. En Java, vous appelez SetXXXListener pour enregistrer les
notifications d’événements ; En C# vous utilisez l’opérateur += pour inscrire pour les notifications d’événement en
« ajoutant » votre délégué à la liste des écouteurs d’événements. En Java, vous appelez SetXXXListener pour
annuler l’inscription, tandis qu’en C# vous utilisez -= pour soustraire votre délégué de la liste des écouteurs.
Dans Xamarin.Android, les événements sont souvent utilisés pour informer les objets lorsqu’un utilisateur fait
quelque chose sur un contrôle d’interface utilisateur. En règle générale, un contrôle d’interface utilisateur aura des
membres qui sont définis à l’aide du mot-clé event . Vous attachez vos délégués à ces membres pour vous abonner
aux événements de contrôle d’interface utilisateur.
Pour vous abonner à un événement :
1. Créez un objet de délégué qui fait référence à la méthode à appeler lorsque l’événement se produit.
2. Utilisez l’opérateur += pour attacher votre délégué à l’événement auquel vous vous abonnez.

L’exemple suivant définit un délégué (avec l’utilisation explicite du mot-clé delegate ) pour vous abonner aux clics
de bouton. Ce gestionnaire de clics de bouton démarre une nouvelle activité :

startActivityButton.Click += delegate {
Intent intent = new Intent (this, typeof (MyActivity));
StartActivity (intent);
};

Toutefois, vous pouvez également utiliser une expression lambda pour enregistrer les événements, et ignorer le
mot-clé delegate entièrement. Par exemple :

startActivityButton.Click += (sender, e) => {


Intent intent = new Intent (this, typeof (MyActivity));
StartActivity (intent);
};

Dans cet exemple, l’objet startActivityButton dispose d’un événement qui attend un délégué avec une certaine
signature de méthode : une qui prend les arguments de l’expéditeur et de l’événement et retourne void. Toutefois,
étant donné que nous ne souhaitez pas vous embêter à définir explicitement un délégué de ce type ou sa méthode,
nous déclarons la signature de la méthode avec (sender, e) et utilisons une expression lambda pour implémenter
le corps du gestionnaire d’événements. Notez que nous devons déclarer cette liste de paramètres, même si nous
n’utilisons pas les paramètres sender et e .
Il est important de vous rappeler que vous pouvez vous désabonner à un délégué (via l’opérateur -= ), mais vous
ne pouvez pas vous désabonner d’une expression lambda – tenter de le faire peut provoquer des fuites de
mémoire. Utilisez la forme lambda de l’inscription d’événement uniquement lorsque votre gestionnaire n’annule
pas l’abonnement depuis l’événement.
En règle générale, les expressions lambda sont utilisées pour déclarer les gestionnaires d’événements dans le code
Xamarin.Android. Ce moyen plus rapide de déclarer les gestionnaires d’événements peut sembler difficile à
déchiffrer au départ, mais il vous fait gagner énormément de temps lors de l’écriture et de la lecture du code. Avec
le temps, vous vous habituerez à reconnaître ce modèle (qui revient fréquemment dans le code Xamarin.Android),
et vous consacrerez plus de temps à réfléchir à la logique métier de votre application et moins de temps à gérer
une syntaxe surchargée.

Programmation asynchrone
La Programmation asynchrone est un moyen d’améliorer la réactivité de votre application. Les fonctionnalités de
programmation asynchrone permettent au reste du code de votre application de continuer à s’exécuter pendant
que certaines parties de votre application sont bloquées par une opération de longue durée. L’accès web, le
traitement des images et la lecture/écriture de fichiers sont des exemples d’opérations qui peuvent provoquer le
blocage d’une application entière si elle n’est pas écrite de façon asynchrone.
C# inclut la prise en charge, au niveau du langage, de la programmation asynchrone via les mots-clés async et
await . Ces fonctionnalités de langage facilitent grandement l’écriture de code qui effectue des tâches longues sans
bloquer le thread principal de votre application. En résumé, vous utilisez le mot-clé async dans une méthode pour
indiquer que le code dans la méthode doit être exécuté de façon asynchrone et ne pas bloquer pas le thread de
l’appelant. Vous utilisez le mot-clé await lorsque vous appelez des méthodes qui sont marquées avec async . Le
compilateur interprète await comme le moment où l’exécution de votre méthode doit être déplacée vers un thread
d’arrière-plan (une tâche est retournée à l’appelant). Lorsque cette tâche est terminée, l’exécution du code se
poursuit sur le thread de l’appelant au niveau du point await dans votre code, en retournant les résultats de l’appel
async . Par convention, les méthodes qui s’exécutent de façon asynchrone ont le suffixe Async joint à leur nom.

Dans les applications Xamarin.Android, async et await sont généralement utilisés pour libérer le thread de
l’interface utilisateur afin qu’il puisse répondre aux entrées de l’utilisateur (par exemple s’il appuie sur un bouton
Annuler ) pendant une opération longue en arrière-plan.
Dans l’exemple suivant, un gestionnaire d’événements pour les clics de bouton provoque une opération asynchrone
pour télécharger une image à partir du web :

downloadButton.Click += downloadAsync;
...
async void downloadAsync(object sender, System.EventArgs e)
{
webClient = new WebClient ();
var url = new Uri ("http://photojournal.jpl.nasa.gov/jpeg/PIA15416.jpg");
byte[] bytes = null;

bytes = await webClient.DownloadDataTaskAsync(url);

// display the downloaded image ...

Dans cet exemple, lorsque l’utilisateur clique sur le contrôle downloadButton , le downloadAsync Gestionnaire
d’événements crée un objet WebClient et un objet Uri pour extraire une image à partir de l’URL spécifiée. Ensuite,
il appelle la méthode DownloadDataTaskAsync de l’objet WebClient avec cette URL pour extraire l’image.
Notez que la déclaration de méthode de downloadAsync est précédée du mot-clé async pour indiquer qu’elle sera
exécutée de façon asynchrone et retournera une tâche. Notez également que l’appel à DownloadDataTaskAsync est
précédé du mot-clé await . L’application déplace l’exécution du gestionnaire d’événements (en commençant par le
point où await apparaît) dans un thread d’arrière-plan jusqu'à ce que DownloadDataTaskAsync se termine et
retourne. Pendant ce temps, le thread d’interface utilisateur de l’application peut toujours répondre aux entrées de
l’utilisateur et déclencher des gestionnaires d’événements pour les autres contrôles. Lorsque
DownloadDataTaskAsync se termine (ce qui peut prendre plusieurs secondes), l’exécution reprend où la variable
bytes est définie sur le résultat de l’appel à DownloadDataTaskAsync , et le reste du code du gestionnaire
d’événements affiche l’image téléchargée sur le thread de l’appelant (interface utilisateur).
Pour une introduction à async / await en C#, consultez la rubrique Programmation asynchrone avec Async et
Await. Pour plus d’informations sur la prise en charge des fonctionnalités de programmation asynchrones dans
Xamarin, consultez Présentation de la prise en charge asynchrone.

Différences de mots clés


Plusieurs mots-clés de langage utilisés en Java sont également utilisés en C#. Il existe également des mots-clés Java
qui ont un équivalent différemment nommé en C#, comme indiqué dans ce tableau :

JAVA C# DESC RIP T IO N

boolean bool Utilisé pour déclarer les valeurs


booléennes true et false.

extends : Précède la classe et les interfaces


héritées.

implements : Précède la classe et les interfaces


héritées.
JAVA C# DESC RIP T IO N

import à Importe les types à partir d’un espace


de noms, également utilisé pour la
création d’un alias d’espace de noms.

final sealed Empêche la dérivation de classe ;


empêche les méthodes et propriétés
d’être substituées dans les classes
dérivées.

instanceof is Détermine si un objet est compatible


avec un type donné.

native extern Déclare une méthode qui est


implémentée en externe.

package namespace Déclare une portée pour un ensemble


d’objets liés.

T... paramètres T Spécifie un paramètre de méthode qui


accepte un nombre variable
d’arguments.

super base Sert à accéder aux membres de la classe


parent à partir d’une classe dérivée.

synchronized Lock Encapsule une section critique du code


avec acquisition et libération de verrou.

En outre, il existe de nombreux mots clés qui sont propres à C# et qui n’ont pas de contrepartie dans le Java utilisé
sur Android. Le code Xamarin.Android utilise souvent les mots-clés C# suivants (cette table est utile comme
référence lors de la lecture de l’exemple de code Xamarin.Android) :

C# DESC RIP T IO N

en tant que Effectue des conversions entre des types référence


compatibles ou des types nullable.

Suppr Spécifie qu’une méthode ou une expression lambda est


asynchrone.

await Suspend l’exécution d’une méthode jusqu'à ce qu’une tâche se


termine.

byte Type entier 8 bits non signé.

delegate Utilisé pour encapsuler une méthode ou une méthode


anonyme.

variables Déclare une énumération, un ensemble de constantes


nommées.

event Déclare un événement dans une classe d’éditeur.


C# DESC RIP T IO N

des Empêche une variable d’être réadressée.

get Définit une méthode d’accesseur qui récupère la valeur d’une


propriété.

in Permet à un paramètre d’accepter un type moins dérivé dans


une interface générique.

object Alias du type Object de .NET Framework.

à Déclaration de modificateur de paramètre ou de paramètre de


type générique.

override Étend ou modifie l’implémentation d’un membre hérité.

partielle Déclare une définition qui doit être fractionnée en plusieurs


fichiers ou fractionne une définition de méthode à partir de
son implémentation.

seulement Déclare qu’un membre de classe ne peut être assigné au


moment de la déclaration ou par le constructeur de classe.

ref Entraîne le passage d'un argument par référence, et non par


valeur.

set Définit une méthode d’accesseur qui définit la valeur d’une


propriété.

string Alias du type String de .NET Framework.

modélis Un type valeur qui encapsule un groupe de variables liées.

typeof Obtient le type d’un objet.

var Définit une variable locale implicitement typée.

value Fait référence à la valeur que le code client souhaite affecter à


une propriété.

virtual Autorise la substitution d'une méthode dans une classe


dérivée.

Interopérabilité avec le code Java existant


Si vous disposez de fonctionnalités Java existantes que vous ne souhaitez pas convertir en C#, vous pouvez
réutiliser vos bibliothèques Java existantes dans les applications Xamarin.Android via deux techniques :
Créer une bibliothèque de liaison Java – Pour cette approche, vous utilisez des outils Xamarin pour
générer des wrappers C# autour de types Java. Ces wrappers sont appelés liaisons. Par conséquent, votre
application Xamarin.Android peut utiliser votre fichier .jar en appelant ces wrappers.
Interface – Native Java L' interface JNI (Java Native Interface ) est une infrastructure qui permet aux
applications C# d’appeler ou d’être appelées par du code Java.
Pour plus d’informations sur ces techniques, consultez Présentation de l’intégration Java.

Informations supplémentaires
Le Guide de programmation C# de MSDN est un excellent moyen de commencer à apprendre le langage de
programmation C#, et vous pouvez utiliser la Référence c# pour rechercher des fonctionnalités spécifiques du
langage C#.
De la même façon que les connaissances de Java impliquent autant la familiarisation avec les bibliothèques de
classes Java que le fait de connaître le langage Java, une connaissance pratique de C# nécessite d’être familiarisé
avec le .NET framework. Le paquet d’apprentissage Passage à C# et .NET Framework pour les développeurs Java de
Microsoft est une bonne solution pour en savoir plus sur .NET Framework à partir d’une perspective Java (tout en
obtenant une meilleure compréhension du langage C#).
Lorsque vous êtes prêt à gérer votre premier projet Xamarin.Android en C#, notre série Hello, Android peut vous
aider à créer votre première application Xamarin.Android, et approfondir votre compréhension des principes
fondamentaux du développement d’applications Android avec Xamarin.

Résumé
Cet article propose une introduction à l’environnement de programmation C# Xamarin.Android du point de vue du
développeur Java. Il souligne les similitudes entre C# et Java tout en expliquant leurs différences pratiques. Il
présente les assemblys et les espaces de noms, explique comment importer les types externes et fournit une vue
d’ensemble des différences en matière de modificateurs d’accès, génériques, dérivation de classe, appels aux
méthodes de classe de base, substitutions de méthodes et gestion des événements. Il présente les fonctionnalités
C# qui ne sont pas disponibles dans Java, dont les propriétés, la programmation asynchrone async / await , les
expressions lambda, les délégués C# et le système de gestion des événements C#. Il comprend des tables des mots-
clés C# importants, explique comment interagir avec les bibliothèques Java existantes et fournit des liens vers la
documentation associée pour approfondir le sujet.

Liens connexes
Présentation de l’intégration Java
Guide de programmation C#
Référence C#
Passage à C# et .NET Framework pour les développeurs Java
Xamarin pour les développeurs Objective-C
05/10/2020 • 3 minutes to read • Edit Online

Xamarin offre aux développeurs s’intéressant à iOS un moyen de transformer leur code sans interface utilisateur en
code C# indépendant de l’application, afin de pouvoir l’utiliser chaque fois que C# est disponible, notamment sur
Android via Xamarin.Android et dans les différentes versions de Windows. Cependant, il ne suffit pas d’utiliser C#
avec Xamarin pour pouvoir tirer parti des compétences et du code Objective-C existants. En réalité, le fait de
connaître Objective-C fait de vous un meilleur développeur Xamarin.iOS, car Xamarin expose toutes les API de
plateformes iOS et OS X natives qui vous sont familières, entre autres UIkit, Core Animation, Core Foundation et
Core Graphics. Vous profitez en même temps de la puissance du langage C#, avec des fonctionnalités comme LINQ
et les génériques, ainsi que de bibliothèques de classes de base .NET enrichies utilisables dans les applications
natives.
Par ailleurs, Xamarin permet de tirer parti des ressources Objective-C existantes au moyen d’une technologie
appelée liaison. Il vous suffit de créer une bibliothèque statique dans Objective-C et de l’exposer à C# grâce à une
liaison, comme dans le diagramme suivant :

Cela ne se limite pas forcément au code sans interface utilisateur. Des liaisons peuvent également exposer du code
d’interface utilisateur développé en Objective-C.

Transition à partir d’Objective-C


Pour faciliter la transition à Xamarin, vous trouverez une multitude d’informations sur notre site de documentation,
qui vous montrera comment intégrer du code C# avec ce que vous connaissez déjà. Voici quelques liens importants
pour bien démarrer :
Premier manuel C# pour les développeurs Objective-C : un court manuel de démarrage pour les développeurs
Objective-C qui souhaitent passer à Xamarin et au langage C#.
Procédure pas à pas : lier une bibliothèque Objective-C : les étapes à suivre pour réutiliser du code Objective-C
existant dans une application Xamarin.iOS.

Liaison Objective-C
Lorsque vous aurez compris les différences entre C# et Objective-C et que vous aurez suivi la procédure de liaison
ci-dessus, vous serez en bonne voie pour la transition vers la plateforme de Xamarin. Pour la suite, des informations
plus détaillées sur les technologies de liaison Xamarin.iOS, avec une référence complète sur la liaison, sont
accessibles dans la section Liaison Objective-C.
Développement interplateforme
Enfin, après la transition vers Xamarin.iOS, vous pourrez consulter l’aide multiplateforme que nous proposons, qui
comporte des études de cas des applications de référence que nous avons développées, ainsi que les meilleures
pratiques pour la création de code multiplateforme et réutilisable, dans la section Développement d’applications
multiplateformes.