Share
Lorsqu'il s'agit d'écrire des applications mobiles, il est important d'intégrer les fonctionnalités spécifiques à la plate-forme disponibles lorsque cela vous semble judicieux. Par exemple, si vous écriviez une application de navigation, il serait logique que vous utilisiez les fonctionnalités de géolocalisation de l'appareil et de la plate-forme. Si vous créiez une application pour aider les personnes ayant une déficience visuelle, vous voudriez intégrer toutes les fonctionnalités de synthèse vocale disponibles..
Ce sont les développeurs qui tirent parti de ces fonctionnalités qui les distinguent, eux et leurs applications, des autres. Ces choses simples prennent juste une application ordinaire et le rendent génial. Mais que se passe-t-il lorsque vous souhaitez tirer parti de ces fonctionnalités, mais que vous avez décidé d'adopter Xamarin.Forms comme mécanisme de choix multiplate-forme? Devez-vous perdre espoir sur ces fonctionnalités simplement parce que vous avez décidé que votre application doit être multi-plateforme et que vous souhaitez pouvoir partager autant de logique et de code d'interface utilisateur que possible? Absolument pas.
Ces types de questions posent inévitablement des problèmes aux développeurs qui adoptent des technologies plus récentes, telles que Xamarin.Forms. Avant la publication de Xamarin.Forms, lorsque vous travailliez directement avec les modèles de projet Xamarin.iOS, Xamarin.Android et Windows Phone, l'accès à ces types de fonctionnalités était relativement simple. Du point de vue de Xamarin, si vous pouviez trouver un exemple de C # (ou même une langue maternelle et une documentation SDK) pour une fonctionnalité particulière, vous pourriez simplement associer votre code aux concepts natifs, car Xamarin a fait un travail si spectaculaire en traduisant les mêmes concepts natifs sur ces plates-formes dans les constructions de langage C #. Les fonctionnalités de Windows Phone étaient encore plus simples car aucune traduction n'était nécessaire. Il suffisait de lire la documentation.
Heureusement pour nous, développeurs, Xamarin a consacré beaucoup de temps et d’efforts à la conception d’un mécanisme lui permettant d’accéder à ces mêmes fonctionnalités, même si nous choisissons d’utiliser sa couche d’abstraction Xamarin.Forms. Ce mécanisme est connu sous le nom de DependencyService.
Accentsconagua
DependencyService Vue d'ensembleÀ première vue, un nom comme DependencyService peut sembler un peu intimidant. Cela ressemble à une terminologie de programmation sophistiquée que seuls quelques élites comprennent. Si vous avez déjà travaillé avec Injection de dépendance (DI) ou Inversion du contrôleur (IoC), vous devriez vous sentir comme à la maison avec le DependencyService. Si vous ne l'avez pas déjà fait, je vous assure que le concept est très simple à comprendre une fois décomposé en composants..
DependencyService?Au plus basique, DependencyService est une classe. C'est une classe dont le seul but de l'existence est de vous permettre de registre un nombre quelconque de classes dans votre application. Par registre, je veux dire, prenez n'importe quel cours que vous avez et faites-le savoir au service. Une fois la DependencyService connaît une classe, il peut aller récupérer une instance de cette classe chaque fois que cela est nécessaire. C’est l’autre but de la DependencyService. Si, à un moment quelconque de votre application, vous décidez que vous avez besoin d’une instance d’une classe qui a été enregistrée dans le répertoire. DependencyService, vous pouvez demander ou obtenir une instance de celui-ci.
Quand vous entrez vraiment dans les rouages de la DependencyService, c'est une généralisation très large. Mais du point de vue du développeur, c'est presque tout ce que vous devez savoir. Cependant, il existe un autre concept que vous devez connaître lorsque vous travaillez avec le DependencyService, interfaces. En ce qui concerne le DependencyService et tout cela en enregistrant et en récupérant, vous le faites généralement en ce qui concerne les interfaces. Cela signifie que lorsque vous enregistrez une classe, vous l'enregistrez en tant que mise en œuvre d'une interface particulière. Et quand vous récupérez une classe, vous demandez en fait au DependencyService pour une mise en œuvre de cette interface. À ce stade, vous ne vous souciez pas vraiment de l'implémentation, vous voulez juste une classe qui implémente cette interface.
DependencyService Travail?Maintenant que vous avez une compréhension de base au niveau conceptuel de ce que le DependencyService est, creusons un peu plus profondément et voyons comment cela fonctionne réellement.
Pour utiliser le DependencyService, vous avez besoin de trois choses:
DependencyService savoir qu'une classe particulière souhaite être enregistrée et pouvoir être retrouvée plus tard.DependencyService, et demander des fonctionnalités, une classe, sans avoir à instancier directement une nouvelle instance.Explorons chacun de ces concepts avec un peu plus de détail.
Les interfaces sont très courantes dans la plupart des langages de programmation orientée objet (OOP) de nos jours. L'utilisation d'une interface vous permet de définir un contrat contenant une série de propriétés, méthodes, événements, etc., qui doivent être implémentés par toute classe qui accepte ce contrat..
Voici un exemple très simple d'interface et de classe implémentant cette interface.
interface publique IFileGrabber string GetFileContents (string fileUri); public SimpleGrabber: IFileGrabber chaîne publique GetFileContents (chaîne fileUri) return GetFileFromFileSystem (fileUri);
Cela semble être un exemple très simple, mais cela convient très bien. le IFileGrabber interface définit une seule méthode, GetFileContents. le SimpleGrabber classe accepte ou met en œuvre la IFileGrabber interface, ce qui signifie qu’elle doit contenir une implémentation pour la seule méthode.
Maintenant, au lieu de devoir implémenter un autre code dans votre application directement sur une classe concrète, SimpleGrabber, vous pouvez commencer à référencer le IFileGrabber interface à la place. Imaginez que vous ayez une autre classe dans votre application qui ressemble à ceci:
Classe publique DataRetriever private IFileGrabber _fileGrabber; public DataRetriever (IFileGrabber fileGrabber) _fileGrabber = fileGrabber chaîne publique GetFileContents (chaîne fileUri) return _fileGrabber.GetFileContents (fileUri);
En utilisant le IFileGrabber l’interface au lieu d’une classe concrète, vous avez la possibilité de créer d’autres mécanismes pour extraire des fichiers de différents endroits et DataRetriever la classe s'en foutrait. Supposons que nous ayons une autre classe qui ressemble à ceci:
Classe publique NetworkGrabber: IFileGrabber chaîne publique GetFileContents (chaîne fileUri) return GetFileFromNetwork (fileUri);
Vous vous souciez moins de savoir comment la classe ou la GetFileContents Une fois la méthode implémentée, vous savez simplement qu’au moins les membres définis dans l’interface sont présents, ce qui signifie que vous pouvez continuer à coder en utilisant uniquement cette interface comme référence. C’est un concept extrêmement important en ce qui concerne la DependencyService.
Dans le cadre de la DependencyService, Xamarin a simplifié le processus d’enregistrement d’une classe. Puisque vous avez déjà défini votre interface et au moins une classe qui l’implémente, vous pouvez l’inscrire dans DependencyService en utilisant un attribut d'assemblage très simple.
Continuons à utiliser l'exemple ci-dessus et enregistrons le SimpleGrabber classe. La définition de classe ressemblerait maintenant à quelque chose comme ceci:
[assembly: Xamarin.Forms.Dependency (typeof (SimpleFileGrabber))]] // Toute déclaration d'espace de noms pouvant exister public SimpleGrabber: IFileGrabber chaîne publique GetFileContents (chaîne fileUri) return GetFileFromFileSystem (fichierUri);
Tout ce que vous avez à faire est d'ajouter la référence d'assembly au-dessus de votre définition de classe et en dehors de toute définition d'espace de noms pouvant également être contenue dans ce fichier. En effectuant cette tâche simple, vous aurez enregistré avec succès le SimpleGrabber classe comme une mise en œuvre de la IFileGrabber interface.
Lors de l’inscription d’une classe, cette classe doit contenir un constructeur sans paramètre pour que DependencyService l'instancier. Dans l'exemple ci-dessus, je n'ai pas défini de constructeur. Le compilateur créera donc par défaut un constructeur sans paramètre..
La dernière pièce du puzzle consiste à obtenir une instance d'une classe enregistrée. C'est en fait la partie la plus facile de tout le processus. Pour récupérer une instance d'une classe enregistrée, vous utilisez simplement le DependencyService classe et c'est générique Obtenir <> () méthode. Voici un exemple simple:
Classe publique FileHelper chaîne publique GetFileContents (chaîne fileUri) return DependencyService.Get() .GetFileContents (fileUri);
Dans ce cas, au moment de l'exécution, vous ne vous souciez pas de savoir où DependencyService devient la classe concrète qui implémente la IFileGrabber interface. Tout ce qui vous importe, c’est que la classe implémente le IFileGrabber interface.
DependencyService Maintenant que vous avez une compréhension conceptuelle de ce que le DependencyService est et comment l'utiliser, créons une application simple à utiliser.
Pour cet exemple, j'utiliserai Xamarin Studio 5, mais n'hésitez pas à utiliser Visual Studio 2013 si vous le souhaitez. Commencez par créer une nouvelle solution. dans le Nouvelle solution boîte de dialogue, sous le C # catégorie à gauche, sélectionnez la Application mobile famille de projet. Sur le côté droit, sélectionnez soit le Application vierge (Xamarin.Forms Portable) ou la Application vierge (Xamarin.Forms Shared) modèle de projet. Le code et l'application résultante seront les mêmes quel que soit le modèle choisi.
Dans cet exemple, je vais utiliser le Bibliothèque de classe portable (PCL) version du modèle. Donnez un nom au projet. Je nommerai la solution et le premier projet DependencyServiceSample. Puis cliquez sur le D'accord bouton.
Ce processus créera trois projets distincts:
Xamarin Studio ne prend pas en charge la création de projets Windows Phone. Si vous utilisez Visual Studio, ce processus créera quatre projets. Il créera les trois projets ci-dessus ainsi qu’un projet Windows Phone nommé DependencyServiceSample.WinPhone.
Dans la bibliothèque partagée (DependencyServiceSample), créez un nouveau fichier d'interface et nommez-le ISampleInterface et lui donner la mise en œuvre suivante:
namespace DependencyServiceSample interface publique ISampleInterface string GetData ();
Le est un fichier d’interface standard qui définit une méthode simple nommée GetData qui retournera un chaîne. Une fois encore, le point important à comprendre est que, du point de vue du fichier de code partagé, l’importance de la mise en œuvre de cette interface n’importe pas. La seule chose qui compte, c’est que quelle que soit l’implémentation fournie pour cette interface, celle-ci a une méthode nommée GetData qui retournera un chaîne.
Ensuite, nous modifions le App.cs fichier à utiliser le DependencyService pour obtenir une instance du ISampleInterface utiliser dans votre application Xamarin.Forms. Modifier le GetMainPage méthode pour ressembler à ce qui suit:
page statique publique GetMainPage () retourne new ContentPage Content = new Label Text = DependencyService.Get() .GetData (), VerticalOptions = LayoutOptions.CenterAndExpand, HorizontalOptions = LayoutOptions.CenterAndExpand,,;
Notez que la seule différence est que le Texte propriété du Étiquette a été changé à la ligne suivante:
DependencyService.Get() .GetData ()
De cette façon, vous utilisez le DependencyService classe et le générique Obtenir <> () méthode pour récupérer quelle que soit la mise en œuvre de la ISampleInterface est implémenté dans le projet spécifique à la plate-forme en cours d'exécution. Une fois cette instance récupérée, vous appelez le GetData méthode pour récupérer une chaîne et définir la Texte propriété du Étiquette.
La dernière étape comporte deux parties (trois si vous utilisez Visual Studio). À ce stade, vous devrez mettre en œuvre le ISampleInterface interface dans tous les projets spécifiques à la plate-forme de votre solution.
Commençons dans le DependencyServiceSample.Android application. Tout ce que vous avez à faire est de créer un nouveau fichier de classe dans le projet et de lui donner le nom de votre choix. J'ai nommé le mien Sample_Android. Remplacez l'implémentation par défaut par ce qui suit:
en utilisant le système; using DependencyServiceSample.Android; [assembly: Xamarin.Forms.Dependency (typeof (Sample_Android))] espace de noms DependencyServiceSample.Android classe publique Sample_Android: ISampleInterface #region ISampleInterface implémentation chaîne publique GetData () return "Je viens du projet Android!"; #endregion
Ceci est une classe simple qui implémente le ISampleInterface l'interface et sa mise en œuvre est simplement de retourner un chaîne indiquant que cela vient du projet Android. La seule différence est l'utilisation du Assemblée attribuer en haut du fichier registres cette classe avec le DependencyService afin qu'il puisse être récupéré plus tard.
Créons maintenant une autre implémentation de cette interface dans le projet iOS. Créez une nouvelle classe dans le projet iOS, nommez-la Sample_iOS, et remplacez l'implémentation par défaut par ce qui suit:
en utilisant le système; using DependencyServiceSample.iOS; [assembly: Xamarin.Forms.Dependency (typeof (Sample_iOS))] espace de noms DependencyServiceSample.iOS classe publique Sample_iOS: ISampleInterface #region ISampleInterface implémentation chaîne publique GetData () return "Je viens du projet iOS!"; #endregion
L'implémentation est exactement la même que la version Android, à la différence qu'elle renvoie une chaîne différente indiquant qu'elle provient du projet iOS cette fois-ci. La dernière étape consiste à exécuter l’application et à voir si vous obtenez le résultat escompté..
Voici le résultat de l'application iOS en cours d'exécution.
Voici le résultat de l'application Android en cours d'exécution.
Comme vous pouvez le constater, les deux applications s'exécutent avec succès. Non seulement ils s'exécutent, mais ils s'exécutent avec succès à partir d'un projet partagé Xamarin.Forms qui contrôle l'interface utilisateur. À partir de ce code d'interface utilisateur dans Xamarin.Forms, vous pouvez maintenant accéder directement aux projets spécifiques à la plate-forme pour accéder au code natif..
Maintenant que vous avez les compétences nécessaires pour utiliser le DependencyService pour accéder aux fonctionnalités natives de Xamarin.Forms, le ciel est la limite. Vous pouvez continuer à écrire des implémentations simples comme vous l'avez fait dans ce tutoriel ou vous pouvez commencer à exploiter des fonctionnalités plus intéressantes des plateformes..
L’une des ressources les plus intéressantes à explorer pour l’intégration dans votre DependencyService est la section Recettes du site Web Xamarin. Vous trouverez ici des implémentations spécifiques à la plate-forme permettant d'accéder à un certain nombre de fonctionnalités, notamment:
Toutes ces fonctionnalités sont à votre disposition pour les applications Xamarin.Forms. Avec le DependencyService, ces caractéristiques peuvent être convoquées à tout moment.
Maintenant que vous connaissez et comprenez le DependencyService, vous n'avez plus à vous sentir intimidé lorsque vous devez accéder à des fonctionnalités spécifiques à une plate-forme à partir d'une application Xamarin.Forms. Vous possédez maintenant les outils vous permettant d'exploiter ces étonnantes fonctionnalités natives des appareils qui vous permettront en fin de compte de différencier vos applications du reste des magasins d'applications..
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:
