Partager via

Xamarin.Forms Inscription et résolution de DependencyService

  • Article

Lorsque vous utilisez la Xamarin.FormsDependencyService fonctionnalité d’appel de plateforme native, les implémentations de plateforme doivent être inscrites auprès du DependencyServicecode partagé, puis résolues à partir du code partagé pour les appeler.

Inscrire des implémentations d’une plateforme

Les implémentations de plateforme doivent être inscrites auprès de celles-ci DependencyService pour pouvoir Xamarin.Forms les localiser au moment de l’exécution.

L’inscription peut être effectuée avec le DependencyAttributeou avec les méthodes et RegisterSingleton les Register méthodes.

Important

Les versions Release des projets UWP qui utilisent la compilation native de .NET doivent inscrire les implémentations de plateforme avec les méthodes Register.

Inscription par attribut

Vous pouvez utiliser DependencyAttribute pour inscrire une implémentation de plateforme auprès de DependencyService. L’attribut indique que le type spécifié fournit une implémentation concrète de l’interface.

L’exemple suivant utilise l’exemple DependencyAttribute suivant pour inscrire l’implémentation iOS de l’interface IDeviceOrientationService :

using Xamarin.Forms;

[assembly: Dependency(typeof(DeviceOrientationService))]
namespace DependencyServiceDemos.iOS
{
    public class DeviceOrientationService : IDeviceOrientationService
    {
        public DeviceOrientation GetOrientation()
        {
            ...
        }
    }
}

Dans cet exemple, DependencyAttribute inscrit DeviceOrientationService auprès de DependencyService. Ce qui aboutit à l’inscription du type concret auprès de l’interface qu’il implémente.

De même, les implémentations de l’interface IDeviceOrientationService sur d’autres plateformes doivent être inscrites avec DependencyAttribute.

Remarque

L’inscription avec DependencyAttribute est effectuée au niveau de l’espace de noms.

Inscription par méthode

Les DependencyService.Register méthodes, et la RegisterSingleton méthode, peuvent être utilisées pour inscrire une implémentation de plateforme avec le DependencyService.

L’exemple suivant utilise la Register méthode pour inscrire l’implémentation iOS de l’interface IDeviceOrientationService :

[Register("AppDelegate")]
public partial class AppDelegate : global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate
{
    public override bool FinishedLaunching(UIApplication app, NSDictionary options)
    {
        global::Xamarin.Forms.Forms.Init();
        LoadApplication(new App());
        DependencyService.Register<IDeviceOrientationService, DeviceOrientationService>();
        return base.FinishedLaunching(app, options);
    }
}

Dans cet exemple, la méthode Register inscrit le type concret DeviceOrientationService auprès de l’interface IDeviceOrientationService. Vous pouvez aussi utiliser une surcharge de la méthode Register pour inscrire une implémentation de plateforme auprès de DependencyService :

DependencyService.Register<DeviceOrientationService>();

Dans cet exemple, la méthode Register inscrit DeviceOrientationService auprès de DependencyService. Ce qui aboutit à l’inscription du type concret auprès de l’interface qu’il implémente.

Vous pouvez également inscrire une instance d’objet existante en tant que singleton avec la RegisterSingleton méthode :

var service = new DeviceOrientationService();
DependencyService.RegisterSingleton<IDeviceOrientationService>(service);

Dans cet exemple, la RegisterSingleton méthode inscrit l’instance DeviceOrientationService d’objet sur l’interface IDeviceOrientationService en tant que singleton.

De même, les implémentations de l’interface IDeviceOrientationService sur d’autres plateformes peuvent être inscrites avec les Register méthodes ou la RegisterSingleton méthode.

Important

L’inscription avec les méthodes et RegisterSingleton les Register projets de plateforme doit être effectuée avant que la fonctionnalité fournie par l’implémentation de la plateforme soit appelée à partir du code partagé.

Résoudre les implémentations d’une plateforme

Les implémentations d’une plateforme doivent être résolues avant d’être appelées. Cette opération est généralement effectuée dans du code partagé avec la méthode DependencyService.Get<T>. Cependant, cette opération peut aussi être effectuée avec la méthode DependencyService.Resolve<T>.

Par défaut, DependencyService résout uniquement les implémentations de plateforme qui ont des constructeurs sans paramètre. Toutefois, une méthode de résolution de dépendance peut être injectée dans Xamarin.Forms ce qui utilise un conteneur d’injection de dépendances ou des méthodes de fabrique pour résoudre les implémentations de plateforme. Cette approche permet de résoudre les implémentations de plateforme qui ont des constructeurs avec des paramètres. Pour plus d’informations, consultez la résolution des dépendances dans Xamarin.Forms.

Important

L’appel d’une implémentation de plateforme qui n’a pas été inscrite auprès de DependencyService entraîne la levée d’une NullReferenceException.

Résoudre avec la méthode Get<T>

La Get<T> méthode récupère l’implémentation de la plateforme de l’interface T au moment de l’exécution, et l’une ou l’autre :

  • Crée une instance de celui-ci en tant que singleton.
  • Retourne une instance existante en tant que singleton, qui a été inscrite auprès de la DependencyServiceRegisterSingleton méthode.

Dans les deux cas, l’instance vit pendant toute la durée de vie de l’application, et tous les appels suivants pour résoudre la même implémentation de plateforme récupèrent la même instance.

Le code suivant montre un exemple d’appel de la méthode Get<T> pour résoudre l’interface IDeviceOrientationService, puis d’un appel de sa méthode GetOrientation :

IDeviceOrientationService service = DependencyService.Get<IDeviceOrientationService>();
DeviceOrientation orientation = service.GetOrientation();

Vous pouvez aussi condenser ce code sur une seule ligne :

DeviceOrientation orientation = DependencyService.Get<IDeviceOrientationService>().GetOrientation();

Remarque

La Get<T> méthode retourne une instance de l’implémentation de plateforme de l’interface T en tant que singleton, par défaut. Vous pouvez toutefois modifier ce comportement. Pour plus d’informations, consultez Gérer la durée de vie des objets résolus.

Résoudre avec la méthode Resolve<T>

La Resolve<T> méthode récupère l’implémentation de la plateforme de l’interface T au moment de l’exécution, à l’aide d’une méthode de résolution de dépendance qui a été injectée dans Xamarin.Forms la DependencyResolver classe. Si aucune méthode de résolution de dépendance n’a été injectée Xamarin.Forms, la Resolve<T> méthode retombe sur l’appel de la Get<T> méthode pour récupérer l’implémentation de la plateforme. Pour plus d’informations sur l’injection d’une méthode Xamarin.Formsde résolution de dépendance dans , consultez Résolution de dépendance dans Xamarin.Forms.

Le code suivant montre un exemple d’appel de la méthode Resolve<T> pour résoudre l’interface IDeviceOrientationService, puis d’un appel de sa méthode GetOrientation :

IDeviceOrientationService service = DependencyService.Resolve<IDeviceOrientationService>();
DeviceOrientation orientation = service.GetOrientation();

Vous pouvez aussi condenser ce code sur une seule ligne :

DeviceOrientation orientation = DependencyService.Resolve<IDeviceOrientationService>().GetOrientation();

Remarque

Lorsque la Resolve<T> méthode revient à appeler la Get<T> méthode, elle retourne une instance de l’implémentation de la plateforme de l’interface T en tant que singleton, par défaut. Vous pouvez toutefois modifier ce comportement. Pour plus d’informations, consultez Gérer la durée de vie des objets résolus.

Gérer la durée de vie des objets résolus

Le comportement par défaut de la classe DependencyService est de résoudre les implémentations de plateforme en tant que singletons. Par conséquent, les implémentations de plateforme vont perdurer pendant toute la durée de vie d’une application.

Ce comportement est spécifié avec l’argument facultatif DependencyFetchTarget sur les méthodes Get<T> et Resolve<T>. L’énumération DependencyFetchTarget définit deux membres :

  • GlobalInstance, qui retourne l’implémentation de plateforme en tant que singleton.
  • NewInstance, qui retourne une nouvelle instance de l’implémentation de la plateforme. L’application est alors responsable de la gestion de la durée de vie de l’instance de l’implémentation de la plateforme.

Les méthodes Get<T> et Resolve<T> définissent leurs arguments facultatifs sur DependencyFetchTarget.GlobalInstance, et les implémentations de plateforme sont donc toujours résolues en tant que singletons. Vous pouvez changer ce comportement de façon à créer les nouvelles instances des implémentations de plateforme en spécifiant DependencyFetchTarget.NewInstance comme arguments des méthodes Get<T> et Resolve<T> :

ITextToSpeechService service = DependencyService.Get<ITextToSpeechService>(DependencyFetchTarget.NewInstance);

Dans cet exemple, DependencyService crée une nouvelle instance de l’implémentation de la plateforme pour l’interface ITextToSpeechService. Tous les appels suivants pour résoudre ITextToSpeechService vont également créer de nouvelles instances.

La conséquence de la création systématique d’une nouvelle instance d’une implémentation de plateforme est que l’application devient responsable de la gestion de la durée de vie des instances. Cela signifie que si vous vous abonnez à un événement défini dans une implémentation de plateforme, vous devez vous désabonner de l’événement quand l’implémentation de plateforme n’est plus nécessaire. Cela signifie aussi que les implémentations de plateforme devront éventuellement implémenter IDisposable et nettoyer leurs ressources dans les Dispose. L’exemple d’application illustre ce scénario dans ses implémentations de plateforme TextToSpeechService.

Quand une application a fini d’utiliser une implémentation de plateforme qui implémente IDisposable, elle doit appeler l’implémentation Dispose de l’objet. Ceci peut être effectué avec une instruction using :

ITextToSpeechService service = DependencyService.Get<ITextToSpeechService>(DependencyFetchTarget.NewInstance);
using (service as IDisposable)
{
    await service.SpeakAsync("Hello world");
}

Dans cet exemple, après l’appel de la méthode SpeakAsync, l’instruction using supprime automatiquement l’objet d’implémentation de plateforme. Le résultat est que la méthode Dispose de l’objet est appelée, qui effectue le nettoyage nécessaire.

Pour plus d’informations sur l’appel de la méthode Dispose d’un objet, consultez Utilisation d’objets qui implémentent IDisposable.