Une introduction à Xamarin.Forms et à la messagerie

Depuis l’introduction de Xamarin 3, 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 seule base de code est incroyable. 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 didacticiel.

1. Qu’est-ce que la messagerie?

Si vous avez de l’expérience dans l’écriture de logiciels dans des environnements d’entreprise, vous pouvez également avoir de l’expérience – ou au moins avoir entendu parler – de la messagerie dans vos applications. La messagerie est un terme utilisé pour décrire les applications qui tirent parti des publier / s’abonner (pub / sous) modèle de conception. L’architecture de publication / abonnement est composée de trois acteurs principaux:

• messages
• éditeurs
• les abonnés

Le point central de ce processus est autour des 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é à une sorte de processus métier et contient les informations requises par les systèmes qui utiliseront finalement ces données pour effectuer une autre opération.

Les deux autres acteurs, éditeurs et abonnés, sont les pourvoyeurs de ces messages. Comme leur nom l’indique, les éditeurs sont les expéditeurs des messages et les abonnés sont les récepteurs des messages.

Comment fonctionne la messagerie?

Le processus de base de la messagerie est assez simple. Dans un système, un certain événement se produit. Cet événement peut être quelque chose de simple, comme un utilisateur cliquant sur un bouton, ou aussi complexe qu’une règle métier déclenchant dans l’application de trading d’une grande entreprise 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 produit.

Lorsqu’un événement se produit, un éditeur prendra les informations sur cet événement et les regroupera dans un message. Ce message aura une sorte de type y est lié 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. Il existe certains types d’éditeurs qui doivent obtenir une réponse, mais ce n’est pas très important dans notre cas.

À l’autre extrémité de l’équation se trouvent les abonnés. Les abonnés sont l’exact opposé des éditeurs. Ils attendent que les 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 prendra ce message et toutes ses données, et en fera quelque chose. Une fois ce processus terminé, l’abonné recommence à attendre d’autres messages.

Pourquoi devriez-vous utiliser la messagerie?

Avec cette architecture à l’esprit, vous vous demandez peut-être pourquoi ou quand vous devriez l’utiliser. En règle générale, les développeurs choisissent d’utiliser ce type d’architecture pour deux raisons, le couplage lâche et l’évolutivité.

Couplage lâche

En termes de développement logiciel, le couplage lâche est le concept de garder les différents composants de votre application aussi séparés que possible au point qu’ils en savent le moins possible les uns sur les autres. Cette séparation permet aux développeurs de se concentrer davantage sur la fonctionnalité d’un système et moins sur l’interaction des différents composants ou éléments du système. Cela permet de modifier plus facilement les fonctionnalités et de tester différents composants.

Évolutivité

L’évolutivité est liée à la façon dont un système peut évoluer sans avoir à constamment retravailler et restructurer 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 d’avoir à ouvrir un morceau de code existant et à apporter des modifications.

Voyons maintenant comment nous pouvons mettre cette architecture extrêmement puissante à profit dans nos applications mobiles en utilisant Xamarin.

2. Utilisation de la messagerie dans Xamarin.Forms

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’y a qu’une seule classe dont nous devons vraiment nous préoccuper et c’est MessagingCenter. le MessagingCenter La classe fait partie de Xamarin.Forms et dispose de méthodes pour nous aider à la fois à publier et à vous abonner aux messages. Jetons un coup d’œil à chacun.

Publier

La première méthode que nous allons examiner dans le MessagingCenter la classe est Send. Bien que le concept dans un contexte de messagerie soit publié, l’implémentation Xamarin.Forms utilise Send. Il existe deux versions du Send méthode qui peut être utilisée pour publier des données.

• MessagingCenter.Send<TSender>(TSender sender, string message)
• MessagingCenter.Send<TSender, TArgs>(TSender sender, string message, TArgs args)

Ces deux options sont génériques. Le premier permet de spécifier l’expéditeur de ce message et le second permet également un argument secondaire, le type de charge utile.

Il est important de souligner que le TArgs Le paramètre générique peut être de n’importe quel type. Cela peut être quelque chose de simple comme un string ou aussi complexe qu’un type personnalisé.

Souscrire

Maintenant que nous savons comment publier, ou Send, messages dans le système, il est temps pour quelque chose de s’y abonner. Pour ce faire, nous utiliserons le Subscribe méthode sur le MessagingCenter classe.

Similaire aux deux versions du Send méthode, la Subscribe La méthode a également deux surcharges.

• MessagingCenter.Subscribe<TSender>(object subscriber, string message, Action<TSender> callback, TSender sender = null)
• MessagingCenter.Subscribe<TSender, TArgs>(object subscriber, string message, Action<TSender, TArgs> callback, TSender sender = null)

Pour le Subscribe méthodes, nous spécifions qui est l’abonné. En général, nous spécifierons this pour le premier paramètre. Le deuxième paramètre contiendra le même nom de message que celui spécifié dans le Send 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, selon la version de la méthode utilisée. Le délégué est un rappel qui est exécuté lorsqu’un message de ce type est publié. Enfin, un paramètre Nullable spécifiant quel TSender ce message doit être abonné. Il peut être laissé comme null pour accepter ce type de message de n’importe quel expéditeur.

Super, maintenant nous nous abonnons aux messages, mais que faire si nous ne nous soucions plus de certains messages? Bonne question. Il y a une autre méthode à prendre en considération.

Se désabonner

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, ce n’est peut-être pas aussi important. En revanche, lorsque vous travaillez dans un environnement plus petit, comme un téléphone, cela devient plus important.

Même si l’utilisation de l’architecture de messagerie permet plus de flexibilité et d’évolutivité, elle nécessite toujours des ressources système. Pour cette raison, nous ne pouvons pas continuer d’augmenter le nombre d’abonnés dans un système à l’infini. Cela étant, nous devons être respectueux des ressources du mieux que nous pouvons. Dans Xamarin.Forms, la façon dont nous procédons consiste à appeler le Unsubscribe méthode. Cette méthode nous permet de dire que nous ne nous soucions plus de la publication d’un message particulier sur le système.

le Unsubscribe La méthode a également deux surcharges.

• MessagingCenter.Unsubscribe<TSender>(object subscriber, string message)
• MessagingCenter.Unsubscribe<TSender, TArgs>(object subscriber, string message)

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 de pourquoi exactement, mais je pense que c’est probablement plus une formalité. Quoi qu’il en soit, je choisis d’être cohérent dans tous mes appels à Send, Subscribe, et Unsubscribe, et utilisez 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.

3. Créer un exemple

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 assez insignifiante, mais elle fournira une illustration utile de la façon d’utiliser ces concepts dans vos applications à l’avenir.

Étape 1: créer une application Xamarin.Forms

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 boîte de dialogue, sélectionnez le Application mobile famille de modèles et choisissez l’un des modèles. Je sélectionnerai le PCL version, mais vous pouvez utiliser la Projet partagé version si vous aimez.

Étape 2: ajoutez du code

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 morceaux plus logiques, mais cette application est suffisamment simple pour que je ne pense pas qu’elle était nécessaire.

Remplacez le contenu du MainPage.cs fichier avec ce qui suit:

using System;
using Xamarin.Forms;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace MessagingSample
{
    public class MainPage : ContentPage
	{
		private List<string> _eventTimes;
		private bool _isSubscribed = false;
		private ListView _eventList;

		public MainPage ()
		{
			_eventTimes = new List<string> ();

			var clearButton = new Button {
				Text = "Clear"
			};

			clearButton.Clicked += (sender, e) => {
				_eventTimes.Clear();
				UpdateList();
			};

			var publishButton = new Button {
				Text = "Publish"
			};

			publishButton.Clicked += (sender, e) => {
				MessagingCenter.Send<MainPage, DateTime>(this, "boom", DateTime.Now);
			};

			var subUnsubButton = new Button {
				Text = "Subscribe"
			};

			subUnsubButton.Clicked += (sender, e) => {
				_isSubscribed = !_isSubscribed;

				if(_isSubscribed) {
					subUnsubButton.Text = "Unsubscribe";
					MessagingCenter.Subscribe<MainPage, DateTime>(this, "boom", (page, time) => {
						_eventTimes.Add(time.ToString());
						UpdateList();
					});
				}else {
					subUnsubButton.Text = "Subscribe";
					MessagingCenter.Unsubscribe<MainPage, DateTime>(this, "boom");
				}
			};

			var buttonStack = new StackLayout {
				Spacing = 20,
				Padding = 20,
				Orientation = StackOrientation.Horizontal,
				Children = { publishButton, subUnsubButton, clearButton },
				HorizontalOptions = LayoutOptions.CenterAndExpand
			};

			_eventList = new ListView {
				ItemsSource = new ObservableCollection<string>(_eventTimes)
			};

			var mainStackLayout = new StackLayout {
				Children = { buttonStack, _eventList },
				HorizontalOptions = LayoutOptions.FillAndExpand,
				VerticalOptions = LayoutOptions.FillAndExpand
			};

			Content = mainStackLayout;
		}

		private void UpdateList() {
			_eventList.ItemsSource = new ObservableCollection<string> (_eventTimes);
		}
	}
}

Cela peut sembler un peu écrasant au départ, mais je vous assure que c’est assez simple. Il y a trois boutons:

• Publier: utilise le Send méthode pour publier un message avec un nom de boom
• S’inscrire Se désinscrire: empêche la page d’être abonnée / désabonnée de boom
• Clair: efface le contenu de ListView

Le principe de base de cette application est qu’elle démarre dans un état désabonné. Dans cet état, si vous appuyez sur le Publier bouton, rien ne semble se produire. Nous savons que le boom message est en cours de publication, mais comme il n’y a pas d’abonnés, rien ne se passe.

Une fois que vous appuyez sur le Souscrire , l’application passe dans un état d’abonnement dans lequel elle écoute maintenant le boom message. Lorsqu’il reçoit ce message, il place un nouveau DateTime valeur dans le _eventTimes collection, qui est mise à jour dans le _eventList ListView via un ObservableCollection.

Le reste du code n’est qu’un formatage et un espacement de base.

Étape 3: Construire et exécuter

L’exécution de l’application dans le simulateur iOS devrait ressembler à ceci:

De même, l’état initial de l’émulateur Android devrait ressembler à ceci:

Après avoir appuyé sur le Souscrire et en publiant quelques messages, vous devriez commencer à voir l’interface utilisateur en cours de mise à jour en obtenant DateTime valeurs dans le ListView.

Conclusion

Voilà. Vous avez réussi à créer une application Xamarin.Forms qui tire parti d’une architecture généralement réservée aux grandes entreprises. Vous devriez vous sentir plutôt excité à ce stade car vous avez maintenant un nouvel outil dans votre ceinture d’outils qui vous permettra de créer des applications très évolutives et flexibles – pour ne pas dire testables – qui peuvent s’exécuter entre les mains de l’utilisateur final. Et cela peut ouvrir la porte à de nombreuses autres possibilités.