Le DependencyService est un résolveur de dépendances qui permet aux applications d’appeler des fonctionnalités spécifiques à chaque plateforme à partir du code partagé.

Cette fonctionnalité permet donc aux applications Xamarin.Forms de faire tout ce qu’une application native peut faire.

En pratique, une interface est définie et le DependencyService instancie l’implémentation correcte de cette interface à partir des différents projets de plateforme.

Comment l’utilise-t-on ?

1. Déclarer une interface qui sera commune à toutes les plateformes.
2. Implémenter l’interface sur chaque plateforme
3. Enregistrer l’implémentation de l’interface
4. Récupérer l’instance implémentant l’interface 

Déclarer l’interface

La première étape consiste à déclarer une interface pour la fonctionnalité que l’on veut utiliser sur nos OS.
Pour notre exemple nous allons partager la fonctionnalité de partage d’URL sur iOS et Android.

Déclaration de l’interface commune entre les OS :

public class IShareService
{
      void Share( string url);
}

Implémenter l’interface

Implémentation Android :

public class DroidShareService : IShareService
{
   public void Share(string url)
   {
   var intent = new Intent(Intent.ActionView);

   intent.SetData(Android.Net.Uri.Parse(url));
   intent.SetFlags(ActivityFlags.ClearTop);
   intent.SetFlags(ActivityFlags.NewTask);

   Application.Context.StartActivity(intent);
   }
}

Implémentation iOS :

public class iOSShareService : IShareService
{
   public void Share(string url)
   {
        UIApplication.SharedApplication.OpenUrl(new NSUrl(url));
   }
}

Enregistrement

Puis pour chaque plateforme il faudra enregistrer les services.

La première façon est de façon est d’utiliser l’attribut DependencyAttribute de la façon suivante :

[assembly: Xamarin.Forms.Dependency (typeof (DroidShareService))]

La seconde façon est d’appeler la méthode Register de DependencyService :

Xamarin.Forms.DependencyService.Register<DroidShareService>();

Note : Lorsque vous ciblez UWP il est préférable d’utiliser la seconde méthode car lorsque vous compilez en .Net Native celui-ci risque de « supprimer » votre type. Lors de l’étape de compilation, .Net Native analyse votre application et détecte tout le code qui peut être supprimé, or il n’arrive pas à détecter que le type est utilisé lors de l’utilisation de celui-ci via l’attribut DependencyAttribute.

Récupérer l’instance implémentant l’interface

Pour récupérer l’instance implémentant l’interface rien de plus simple, il suffit d’appeler la méthode statique Get<TInstance> du type DependencyService

var shareService = Xamarin.Forms.DependencyService.Get<IShareService>();

shareService.Share("https://www.https://blogs.infinitesquare.com/");

 Comment ça fonctionne ?

Au premier appel de la méthode Get<T> le DependencyService va initialiser sa liste d’implémentations en recherchant dans tous les assemblies les utilisations de l’attribut DependencyAttribute.

Initialisation :

            Type targetAttrType = typeof(DependencyAttribute);

            // Don't use LINQ for performance reasons
            // Naive implementation can easily take over a second to run
            foreach (Assembly assembly in assemblies)
            {
                Attribute[] attributes = assembly.GetCustomAttributes(targetAttrType).ToArray();
                if (attributes.Length == 0)
                    continue;

                foreach (DependencyAttribute attribute in attributes)
                {
                    if (!DependencyTypes.Contains(attribute.Implementor))
                    {
                        DependencyTypes.Add(attribute.Implementor);
                    }
                }
            }

Attention : si vous avez un grand nombre d’assembly cette première initialisation peut être longue.

Puis une fois les listes de DependencyTypes initialisées celui crée dynamiquement l’instance du service grâce à la classe Activator.

(T)Activator.CreateInstance(dependencyImplementation.ImplementorType);

Pour aller plus loin :

• Code source du DependencyService
• Développez vos applications multiplateformes pour iOS, Android et Windows