Share
Depuis que Xamarin 3 a été introduit, il y a eu beaucoup de buzz autour de lui. L'idée de pouvoir créer une application mobile, y compris l'interface utilisateur, en utilisant une base de code unique est étonnante. Mais Xamarin.Forms est bien plus que cela. L'une des fonctionnalités souvent négligées incluses dans Xamarin.Forms est le concept de messagerie et c'est le sujet de ce tutoriel..
Si vous avez déjà écrit des logiciels dans des environnements d'entreprise, vous pouvez également avoir une expérience ou au moins entendu parler de la messagerie dans vos applications. La messagerie est un terme utilisé pour décrire les applications qui tirent parti de la publier / souscrire (pub / sub) modèle de conception. L'architecture de publication / abonnement est composée de trois acteurs principaux:
Ce processus est centré sur les messages. Les messages sont simplement un moyen de transmettre des informations sur un certain un événement cela s'est produit. Cet événement est généralement lié à un type de processus métier et contient des informations requises par les systèmes qui utiliseront ces données pour effectuer d'autres opérations..
Les deux autres joueurs, les éditeurs et les abonnés, sont les fournisseurs de ces messages. Comme les noms l'indiquent, les éditeurs sont les expéditeurs des messages et les abonnés sont les récepteurs des messages.
Le processus de base de la messagerie est plutôt simple. Dans un système, un certain événement se produit. Cet événement peut être simple, comme un utilisateur qui clique sur un bouton, ou aussi complexe qu'une règle métier déclenchée dans l'application de négociation d'une grande société financière. Dans le monde de la messagerie, il y a peu de différence entre ces deux choses. Tout ce que vous devez savoir, c'est que quelque chose s'est passé.
Lorsqu'un événement se produit, un éditeur prend les informations sur cet événement et les intègre dans un message. Ce message aura une sorte de type lié à celui-ci ainsi que des données supplémentaires décrivant l'événement. Le type est très important plus tard dans le processus. Une fois ce message créé, l'éditeur l'enverra dans un système. À partir de ce moment, l'éditeur ne se soucie plus de cet événement ou de ce message. Certains types d'éditeurs ont besoin d'une réponse, mais ce n'est pas très important dans notre cas..
À l'autre bout de l'équation se trouvent les abonnés. Les abonnés sont l'exact opposé des éditeurs. Ils attendent que des messages d'un certain type soient publiés. C'est de là que vient leur nom, ils sont abonnés à certains types d'événements. Lorsqu'un abonné voit qu'un événement auquel il est abonné s'est produit, il prend ce message et toutes ses données et fait quelque chose avec ce message. Une fois ce processus terminé, l’abonné revient à attendre d’autres messages..
Avec cette architecture en tête, vous vous demandez peut-être pourquoi et quand vous devriez l’utiliser. En général, les développeurs choisissent d’utiliser ce type d’architecture pour deux raisons: couplage faible et évolutivité..
En termes de développement logiciel, le couplage faible est le concept qui permet de garder les composants de votre application aussi séparés que possible de manière à ce qu'ils se connaissent le moins possible. Cette séparation permet aux développeurs de se concentrer davantage sur les fonctionnalités d'un système et moins sur l'interaction de différents composants ou éléments du système. Cela permet de modifier plus facilement les fonctionnalités et de tester différents composants.
L'évolutivité dépend de la façon dont un système peut évoluer sans avoir à constamment retravailler et ré-architecturer l'ensemble de la solution. En ce qui concerne la messagerie, si vous devez effectuer une sorte de traitement supplémentaire lorsqu'un message particulier est détecté, un nouvel abonné est créé pour gérer cette fonctionnalité au lieu de devoir ouvrir un morceau de code existant et apporter des modifications..
Voyons maintenant comment utiliser cette architecture extrêmement puissante dans nos applications mobiles utilisant Xamarin..
Entrer dans le monde de la messagerie dans Xamarin.Forms est en fait assez simple, maintenant que nous comprenons les concepts de base de la messagerie. Tout ce dont nous avons besoin maintenant, c'est d'une construction pour y accéder. Heureusement pour nous, il n’ya qu’une seule classe qui nous préoccupe vraiment, c’est MessagingCenter. le MessagingCenter class fait partie de Xamarin.Forms et propose des méthodes pour nous aider à publier et à vous abonner aux messages. Jetons un coup d'oeil à chacun.
La première méthode que nous allons examiner dans le MessagingCenter la classe est Envoyer. Bien que le concept dans un contexte de messagerie soit publié, l’implémentation Xamarin.Forms utilise Envoyer. Il existe deux versions du Envoyer méthode pouvant être utilisée pour publier des données.
Accentsconagua
MessagingCenter.Send(Expéditeur TSender, message de chaîne) MessagingCenter.Send(Expéditeur de TSender, message de chaîne, arguments de TArgs) Ces deux options sont génériques. Le premier vous permet de spécifier l'expéditeur de ce message et le second autorise également un argument secondaire, le type de charge utile..
Il est important de souligner que le Pains paramètre générique peut être n'importe quel type. Cela peut être simple comme un chaîne ou aussi complexe qu'un type personnalisé.
Maintenant que nous comprenons comment publier, ou Envoyer, messages dans le système, il est temps que quelque chose s'y abonne. Pour ce faire, nous utiliserons le Souscrire méthode sur le MessagingCenter classe.
Similaire aux deux versions du Envoyer méthode, la Souscrire méthode a également deux surcharges.
MessagingCenter.Subscribe(abonné d'objet, message de chaîne, Action rappel, expéditeur TSender = null) MessagingCenter.Subscribe(abonné d'objet, message de chaîne, Action rappel, expéditeur TSender = null) Pour le Souscrire méthodes, nous spécifions qui est l'abonné. En règle générale, nous spécifierons ce pour le premier paramètre. Le second paramètre contiendra le même nom de message que celui spécifié dans Envoyer méthode afin que nous puissions être avertis lorsque ce message particulier a été envoyé. Le troisième paramètre est un délégué générique qui accepte l'expéditeur et éventuellement des arguments, en fonction de la version de la méthode utilisée. Le délégué est un rappel exécuté lors de la publication d'un message de ce type. Enfin, un paramètre nullable spécifiant lequel TSender ce message doit être souscrit. Il peut être laissé comme nul accepter ce type de message de tout expéditeur.
Génial, nous abonnons maintenant aux messages, mais que se passe-t-il si nous ne nous soucions plus de certains messages? Bonne question. Il y a une autre méthode à prendre en considération.
Un processus souvent négligé dans le monde de la messagerie est la désinscription. Lorsque vous travaillez dans une très grande infrastructure de classe entreprise, cela n’est peut-être pas aussi important. En revanche, lorsque vous travaillez dans un environnement plus petit, tel qu'un téléphone, cela devient plus important..
Même si l’utilisation de l’architecture de messagerie offre davantage de flexibilité et d’évolutivité, elle nécessite toujours des ressources système. De ce fait, nous ne pouvons pas continuer à augmenter le nombre d'abonnés dans un système à l'infini. Cela étant, nous devons respecter les ressources du mieux que nous pouvons. Dans Xamarin.Forms, nous procédons ainsi en appelant le Se désabonner méthode. Cette méthode nous permet de dire que nous ne nous intéressons plus à un message particulier publié sur le système..
le Se désabonner méthode a également deux surcharges.
MessagingCenter.Usubscribe(abonné d'objet, message de chaîne) MessagingCenter.Usubscribe(abonné d'objet, message de chaîne) Vous remarquerez peut-être que les arguments génériques ne se manifestent pas dans la liste des paramètres. Seuls les développeurs ont une bonne idée du pourquoi exact, mais j’estime que c’est probablement plus une formalité. Quoi qu’il en soit, je choisis d’être cohérent dans tous mes appels vers Envoyer, Souscrire, et Se désabonner, et utiliser les mêmes signatures et arguments pour éliminer toute sorte de confusion.
Maintenant que nous comprenons les concepts de base de la messagerie, il est temps de créer un exemple simple utilisant ces idées..
Dans cet exemple, nous allons créer une application Xamarin.Forms simple qui utilisera les trois méthodes du MessagingCenter classe mentionnée précédemment dans cet article. L’application elle-même peut sembler peu importante, mais elle fournira une illustration utile de la façon dont ces concepts seront utilisés dans vos applications..
Nous allons commencer par créer une nouvelle application Xamarin.Forms. Pour ce faire, ouvrez simplement Xamarin Studio (ou Visual Studio) et sélectionnez Fichier> Nouvelle solution. dans le Nouvelle solution dialogue, sélectionnez le Application mobile famille de modèles et choisissez l’un des modèles. Je choisirai le PCL version, mais vous pouvez utiliser le Projet partagé version si vous aimez.
Une fois la solution créée, ajoutons du code. Dans le projet partagé, créez une nouvelle classe et nommez-la. Page d'accueil. Ce sera l'écran de l'application qui contiendra l'interface utilisateur ainsi que la logique. Cela peut évidemment être divisé en plusieurs parties logiques, mais cette application est assez simple pour que je ne pense pas que c'était nécessaire.
Remplacer le contenu de la MainPage.cs fichier avec les éléments suivants:
