Share
Depuis l'arrivée de Xamarin sur la scène, il y a plusieurs années, les développeurs C # se réjouissent de pouvoir créer des applications mobiles ciblant des plates-formes non Microsoft. C'est avec un peu d'enthousiasme que nous pouvons maintenant écrire des applications dans un langage qui nous est très familier et pouvoir les distribuer aux grands acteurs de l'espace mobile, iOS et Android..
Étant donné que ces applications peuvent être écrites dans une seule langue, il est logique de vouloir écrire une base de code unique qui serait compilée dans des applications séparées pour les différentes plates-formes et qui nous permettrait finalement d'atteindre le monde Écrire une fois, exécuter partout / n'importe où. Cela semble bien sur papier, mais ce n'était pas tout à fait le cas.
Le concept d'écrire une application une seule fois et de pouvoir l'exécuter sur plusieurs plates-formes n'est pas nouveau. Les développeurs tentent de le faire depuis de nombreuses années avec des applications de bureau et serveur écrites en Java ou en C / C ++ et compilées sur des plates-formes spécifiques. Pourquoi les applications mobiles devraient-elles être différentes? La réponse est simple: ils ne le sont pas. En tant que développeurs d’applications mobiles, nous rencontrons les mêmes problèmes multi-plateformes que d’autres, l’interface utilisateur..
Quand il s’agit d’écrire tout type de logiciel que vous voulez pouvoir exécuter sur différentes plates-formes, la facile une partie est la logique. Par facile, Je parle de la partie de l'application qui ne change pas, quelle que soit la plate-forme que vous ciblez. Quelle que soit la plate-forme que vous ciblez, vous aurez toujours besoin d'obtenir des données de services, de bases de données, de fichiers, etc. Il y a de fortes chances que cela change très rarement. La partie qui change est l'interface utilisateur. Cela est principalement dû aux différences inhérentes aux différentes plates-formes. Chaque plate-forme aura son propre SDK, définissant ses capacités, ses composants visuels et ses caractéristiques..
En regardant le paysage mobile actuel, vous constaterez rapidement qu'il y a trois grands joueurs, iOS, Android, et Téléphone Windows. Ces trois entreprises sont en concurrence constante pour tenter de renforcer les parts des autres pour gagner des parts de marché. Mais, dans un avenir prévisible, ce sont les plates-formes que vous souhaitez cibler. Le développement multiplate-forme sur mobile peut être difficile en raison des différences fondamentales en termes d'interface utilisateur. Un bouton n'est plus juste un bouton. Un bouton est un UIButton avec XML sur iOS, un Bouton avec AXML sur Android, et un Bouton avec XAML sur Windows Phone.
Comme avec la plupart des frameworks multi-plateformes, Xamarin a généralement adopté une stratégie similaire pour limiter le mal de tête causé par l'interface utilisateur, en séparant la logique de l'interface utilisateur..
Dans le monde de C #, cette stratégie vous laissera généralement au moins N + 1 projets au sein de votre solution. Vous aurez au moins un projet pour chacun des N plates-formes vous ciblez et vous devez également avoir au moins un projet qui contiendra tout le code partagé sur lequel l'application s'appuie. De cette manière, vous pouvez faire en sorte que les projets spécifiques à la plate-forme fassent simplement référence au projet de code partagé et n’ayez plus qu’à vous soucier de la façon de visualiser les données. Grâce aux nouvelles fonctionnalités des frameworks .NET et Mono, vous avez plusieurs options.
Les bibliothèques de classes portables ou PCL sont arrivés en premier. Il est plus facile de considérer les PCL comme des bibliothèques de classes normales, avec des fonctionnalités limitées. Il est plus facile de comprendre ce concept avec un exemple. Commencez par créer une nouvelle solution / projet et nommez-le PCLDemo et sélectionnez Bibliothèque de classe (portable) comme modèle de projet.
Quand vous cliquez D'accord dans Visual Studio, une autre fenêtre semblable à celle-ci s'affiche:
Selon les outils que vous avez installés, cela peut sembler légèrement différent. Dans cet écran, vous avez la possibilité de cibler autant de plateformes que vous le souhaitez. La règle de base est de ne choisir que les plates-formes que vous devez absolument cibler. La raison en est que plus vous souhaitez cibler de plateformes, moins le nombre de fonctionnalités incluses dans cette bibliothèque est élevé. Pour obtenir une liste à jour des fonctionnalités prises en charge par les différentes plates-formes, consultez la page Développement de plates-formes croisées avec la bibliothèque de classes portable sur MSDN..
Si vous ne sélectionnez pas les plates-formes appropriées dans cette boîte de dialogue, vous risquez de rencontrer ultérieurement des problèmes d'incompatibilité. Pour voir cela en action, décochez les trois options du bas:
Créez maintenant un nouveau projet de l’un des types pour lesquels vous avez supprimé la prise en charge dans PCL. À titre d'exemple, vous pouvez créer un nouveau projet Xamarin.Android à l'aide de l'un des modèles fournis. Une fois le projet créé, cliquez avec le bouton droit de la souris sur Références et sélectionnez Ajouter une référence. dans le Gestionnaire de référence dialogue, sélectionnez Solution> Projets du filtre à gauche et cochez la case à côté du PCLDemo projet.
Quand vous cliquez D'accord, vous verrez une erreur comme celle-ci:
Cette erreur vous permet de savoir que le projet dans lequel vous vous trouvez est incompatible avec les cibles disponibles dans la PCL sélectionnée. Vous pouvez contourner ce problème en accédant aux propriétés du projet PCL et en modifiant les cibles. Mais rappelez-vous que plus il y a de cibles, moins il y a de fonctionnalités prises en charge..
Même si vous devez faire attention à quelques points lorsque vous utilisez des PCL, il y a de très bons avantages.
Lorsque vous choisissez une nouvelle technologie ou plate-forme à utiliser, il est également utile de comprendre les inconvénients auxquels il faut remédier.
Si les PCL vous semblent trop restrictives en tant que choix pour le code partagé, il existe une autre option..
Dans la récente version de Visual Studio 2013 Update 2, Microsoft a ajouté la prise en charge des projets partagés. Les projets partagés constituent un autre moyen de partager du code entre différentes plates-formes, d'une manière similaire aux PCL et d'une manière radicalement différente. Commençons par créer un exemple simple.
Commencez par créer une autre solution / projet dans Visual Studio et donnez-lui le nom suivant: SharedDemo et en sélectionnant Projet partagé (vide) comme modèle.
Si vous ne voyez pas Projet partagé (vide) en option, assurez-vous de disposer de la dernière version de Visual Studio 2013 Update 2. Si vous utilisez la dernière version et ne la voyez toujours pas, vous devrez peut-être installer l'extension Shared Project Reference Manager..
Une fois que vous cliquez D'accord, Visual Studio créera un nouveau projet pour vous dans le Explorateur de solution, mais il aura l'air un peu différent de celui auquel vous êtes habitué.
Il semble un peu seul, hein? Il n'y a pas Propriétés dossier et non Références dossier. Que se passe-t-il? C'est la beauté et souvent la source de confusion pour la plupart des développeurs. Par défaut, un projet partagé ne contient pas d'accès à aucune fonctionnalité. Il y a de la magie dans les coulisses de Visual Studio / Xamarin Studio, mais vous le verrez bientôt..
Une autre caractéristique étrange d'un projet partagé est que vous ne pouvez pas le créer. Si vous deviez faire un clic droit la solution ou le projet, vous ne verrez aucune option pour la construction, l’exécution ou le débogage de ce projet. Pour comprendre pourquoi, il faut prendre un peu de recul.
Quel est le but de la construction d'un projet? Le but est de transformer votre code de texte en un fichier pouvant être utilisé par le système que vous exécutez ou par une autre application. C'est pourquoi vous ne pouvez pas réellement créer un projet partagé, aucun fichier de sortie n'est généré par celui-ci. Ce projet spécialisé a un but totalement différent.
Lorsque vous créez un projet partagé et y écrivez du code, vous pouvez ajouter autant de fois que vous le souhaitez des références à partir d'autres projets. Il n'y a pas de plateformes à cibler ni de règles à suivre. C'est le premier différenciateur des PCL. Continuons avec un exemple. Créer un nouveau Xamarin.Android et / ou Xamarin.iOS projetez dans votre solution et nommez-les de manière appropriée, SharedDemo.Android et / ou SharedDemo.iOS.
Maintenant que vous avez un nouveau projet, cliquez avec le bouton droit sur la souris. Références dossier et sélectionnez Ajouter une référence de projet partagée. Si vous ne voyez pas cela comme une option, vous devrez peut-être ajouter l'ajout de l'extension du gestionnaire de référence de projet partagé..
De là, cliquez D'accord et vous devriez voir quelque chose de semblable à ceci:
C'est là que la magie entre en jeu. Le code contenu dans un projet partagé sera compilé dans tous les projets qui en font référence. C'est pourquoi vous ne pouvez pas les construire directement, ils ont besoin de quelque chose pour les référencer avant de pouvoir les construire et les compiler. Le fait qu’ils puissent être ajoutés à tout projet en tant que référence explique en partie pourquoi ils sont de si bons candidats pour le développement multiplate-forme..
L'autre raison pour laquelle ils sont de bons candidats pour le développement multi-plateforme est leur prise en charge des directives du compilateur. Vous pouvez effectuer des contrôles pour des directives spéciales dans vos projets partagés afin que seules des plates-formes spécifiques obtiennent certaines fonctionnalités ou que les choses soient gérées différemment sur des plates-formes différentes. Les directives suivantes peuvent être trouvées dans les projets de plateforme:
Accentsconagua
__MOBILE__ Projets Xamarin.Android et Xamarin.iOS__IOS__ Projets Xamarin.iOS__ANDROID__ Projets Xamarin.Android__ANDROID_xx__ Projets Xamarin.Android où xx est remplacé par la version de l'API Android cibléeTÉLÉPHONE WINDOWS Projets Windows PhoneSILVERLIGHT Projets Windows PhoneVous pouvez utiliser ces directives à l'intérieur #ifdef des blocs pour vérifier la plate-forme sur laquelle vous travaillez et utilisez la compilation conditionnelle pour inclure uniquement ce qui est nécessaire dans chaque projet. Tout cela est fait pour vous par le compilateur. Voyons un exemple.
Dans ton SharedDemo projet, ajouter une nouvelle classe nommée Recette et remplacez l'implémentation par défaut par ce qui suit:
Classe publique Recipe chaîne publique ShortName get; ensemble; #if __iOS__ chaîne publique LongName get; ensemble; #endif liste publiqueIngrédients get; ensemble; liste publique Directions get; ensemble;
C'est un exemple un peu artificiel, mais il sert à illustrer un point simple. Puisque je fais référence à ce code depuis un projet Xamarin.Android, la classe Recipe ne contiendra que 3 propriétés., Nom court, Ingrédients, et instructions. Si ce code était référencé par un projet Xamarin.iOS, il contiendrait également le Nom long propriété.
Vous êtes plus susceptible d'utiliser ces directives dans des situations où vous rencontrez des divergences de plate-forme. Les zones de divergence communes sur ces plates-formes mobiles concernent l'accès au matériel, au système de fichiers, etc. Vous pouvez maintenant placer le code de la plate-forme dans le projet partagé, divisé par les directives. Visual Studio gérera la compilation spécifique à la plate-forme pour les projets appropriés. Très agréable.
Les projets partagés contiennent quelques fonctionnalités très utiles qui aident à la création de projets multi-plateformes.
Bien que les projets partagés aient des fonctionnalités intéressantes, il existe quelques caractéristiques peu souhaitables.
Vous êtes maintenant au courant des stratégies de base pour partager la logique de votre application. Il est temps de commencer à regarder l'interface utilisateur de votre application. Dans la version la plus récente de la version 3 de Xamarin, l’une des fonctionnalités les plus intéressantes est l’introduction de Xamarin.Forms. Xamarin.Forms est une bibliothèque qui contient des abstractions de contrôles d'interface utilisateur typiques comprenant l'interface utilisateur de votre application. Lorsque ces contrôles sont utilisés sur des plates-formes spécifiques, ils sont mappés pour rendre les contrôles d'interface utilisateur natifs afin que vous obteniez l'aspect et la convivialité des composants natifs..
La structure de base de votre application multiplate-forme ne change pas. Vous suivrez toujours la règle N + 1 en ce qui concerne les projets, mais vous allez maintenant déplacer votre code d'interface utilisateur spécifique à la plate-forme des projets spécifiques à la plate-forme vers les projets partagés. Avant de prendre une longueur d'avance sur nous-mêmes, nous devons comprendre les besoins et les exigences non seulement de l'exécution, mais également du développement d'applications Xamarin.Forms..
Si vous souhaitez tirer pleinement parti de Xamarin.Forms, il existe quelques exigences. Pour utiliser Xamarin.Forms, votre application doit cibler les plates-formes suivantes:
Cela signifie que si vous envisagez de cibler certaines des versions les plus anciennes de ces plates-formes, vous ne pourrez pas utiliser Xamarin.Forms. Outre les restrictions de plate-forme cible, il existe également quelques exigences relatives au système de développement..
Une fois que tout est téléchargé et configuré, vous êtes prêt à commencer..
L'idée de base de Xamarin.Forms est simple: vous vous référez aux contrôles d'interface utilisateur courants de la même manière, quelles que soient les plates-formes que vous ciblez. Un bouton est un bouton est un bouton. Vous allez créer ces contrôles et leur donner des caractéristiques visuelles et des fonctionnalités. Vous utiliserez ensuite un Disposition pour positionner les commandes sur l’écran et tout afficher sur un Page. Si vous utilisez déjà une terminologie spécifique à la plate-forme pour décrire les composants d'interface utilisateur de vos applications, vous familiariser avec les nouveaux termes peut prendre un certain temps. Heureusement, il n'y a que quelques concepts à comprendre.
Dans Xamarin.Forms, les pages représentent les écrans réels de votre application. En ce qui concerne les autres plates-formes, un Page est un Activité sur Android, un UIViewController sur iOS, et un Page sur Windows Phone. le Page est l’objet principal que vous traiterez lorsque vous travaillerez sur les transitions et la navigation. Aussi un Page ne contient qu'un seul enfant, ce qui dans la plupart des situations correspond à un type de Disposition.
Les mises en forme sont des contrôles utilisés pour organiser les composants d'interface utilisateur sur votre Page de manière logique. Dans un Disposition, vous pouvez définir les caractéristiques des contrôles de l'interface utilisateur, telles que la position et la taille. Vous pouvez ajouter un nombre quelconque de composants d’interface utilisateur à un modèle, y compris des contrôles et d’autres éléments. Disposition objets.
Dans Xamarin.Forms, les vues sont ce que vous appelleriez couramment des contrôles. Commun Vue les objets dans Xamarin.Forms sont Bouton, Étiquette, et ListView, pour en nommer quelques uns. le Disposition la classe hérite effectivement de la Vue classe, ce qui signifie qu'ils peuvent être traités de la même manière et ajoutés à Disposition objets.
Les cellules sont des composants d'interface utilisateur spécialisés utilisés pour personnaliser ce que l'on appelle généralement des lignes dans ListView et UITableView objets. Il y a pré-construit Cellule types pour ajouter un certain nombre de personnalisations différentes à votre Vue objets.
Pour créer une application Xamarin.Forms de base, ouvrez Visual Studio, sélectionnez Fichier> Nouveau projet, sélectionnez le Application mobile catégorie et choisissez le modèle approprié. J'ai choisi le Application vierge (Xamarin.Forms Shared) modèle. Cela créera une application Xamarin.Forms en utilisant le Projet partagé modèle.
Après avoir cliqué D'accord, votre solution sera créée avec quatre projets. Comme indiqué précédemment, vous aurez trois projets spécifiques à une plate-forme et un projet partagé. Le projet partagé contient la logique de l'application ainsi que tout le code Xamarin.Forms chargé de créer les écrans (Page objets) de votre application.
Si vous ouvrez le SampleFormsApp projet, vous verrez une seule classe nommée App.cs. Ceci est le fichier principal du projet qui contient le Page définitions qui apparaîtront en fin de compte sur les plates-formes cibles. C'est une classe simple qui ne contient que ce qui suit:
Classe publique App page statique publique GetMainPage () retourne new ContentPage Content = nouvelle Label Text = "Hello, Forms!", VerticalOptions = LayoutOptions.CenterAndExpand, HorizontalOptions = LayoutOptions.CenterAndExpand,,;
La classe App est assez simple en ce sens qu’il ne contient qu’une seule méthode statique qui renvoie un Contenu de la page objet. UNE Contenu de la page objet est le plus fondamental, sans fioritures Page que vous pouvez créer. Il est plus facile de penser à un Contenu de la page comme une toile vierge que vous pouvez faire tout ce que vous voulez avec. Il y a très peu de fonctionnalités intégrées.
Vous trouverez généralement que la plupart Page les objets ont un Contenu propriété qui vous permet d'attribuer Vue objecter à cela. Dans ce cas, c'est un simple Étiquette vue qui imprime "Bonjour, Formulaires!" à l'écran tout en lui donnant un formatage de base pour le centrer.
Pour obtenir ceci Contenu de la page pour charger sur chaque plate-forme que nous ciblons, il existe un code personnalisé spécifique à la plate-forme qui doit être inclus dans chacun des projets de plate-forme. Regardons d'abord le projet iOS. Ouvrez le SampleFormsApp.iOS projet et jeter un oeil à la AppDelegate.cs fichier. C'est le fichier qui contient le câblage dans le monde Xamarin.Forms.
remplacement public bool FinishedLaunching (application UIApplication, options NSDictionary) Forms.Init (); window = new UIWindow (UIScreen.MainScreen.Bounds); window.RootViewController = App.GetMainPage (). CreateViewController (); window.MakeKeyAndVisible (); retourne vrai;
Tout d’abord, nous initialisons la bibliothèque Xamarin.Forms avec en invoquant Forms.Init (). Après cela, le seul code personnalisé définit le paramètre window.RootViewController propriété au résultat de la App.GetMainPage (). CreateViewController () appel. Cette ligne se lancera dans le monde Xamarin.Forms et tout, à partir de ce moment, continuera à utiliser Xamarin.Forms..
Le processus d’initialisation de Xamarin.Forms sous Android et Windows Phone est très similaire. Tu appelleras le Init méthode et définir l'initiale Page être le résultat de la App.GetMainPage () méthode. Voici à quoi ça ressemble dans le SampleFormsApp.Android projet dans le MainActivity.OnCreate méthode.
protection annulée void OnCreate (Bundle Bundle) base.OnCreate (Bundle); Xamarin.Forms.Forms.Init (this, bundle); SetPage (App.GetMainPage ());
Et dans le SampleFormsApp.WinPhone projet dans le Page d'accueil constructeur de la classe partielle Page d'accueil:
public MainPage () InitializeComponent (); Forms.Init (); Content = SampleFormsApp.App.GetMainPage (). ConvertPageToUIElement (this);
Vous devriez maintenant avoir une compréhension de base de Xamarin.Forms ainsi que de ce que vous pouvez accomplir en les utilisant. Le voyage dans cette technologie incroyable ne s'arrête pas là. Vous aurez un autre choix devant vous lorsque vous utiliserez Xamarin.Forms, qui concerne la mise en page. Et c'est précisément ce qui sera couvert dans le prochain tutoriel.
Si vous souhaitez en savoir plus sur Xamarin, consultez notre cours Création d'applications multi-plateformes avec C # dans Xamarin.
Dans ce cours, vous apprendrez à créer une application multiplate-forme à partir d'une base de code unique qui s'exécutera sur trois plates-formes distinctes: iOS, Android et Windows Phone 8. Vous pensez que cela ne peut être fait? Dans peu de temps, vous le ferez vous-même. Mettons-nous au travail.
Vous pouvez prendre le tout de suite avec un complètement libre Essai de 14 jours d'un abonnement Tuts +. Jetez un coup d'œil à nos options d'abonnement pour commencer ou, si ce cours vous intéresse, vous pouvez l'acheter à l'unité pour 15 $! Voici un aperçu pour vous aider à démarrer:
