# Xamarin Forms : Comprendre le Dependency Service

> 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…

- Auteur: Jérôme Giacomini
- Langue: fr
- URL canonique: [Xamarin Forms : Comprendre le Dependency Service](https://jeromegiacomini.net/fr/articles/2018/04/09/xamarin-forms-comprendre-le-dependency-service)
- Publié le: 2018-04-09
- Dernière modification: 2026-09-05
- Thèmes: .NET, C#, Xamarin, Windows

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 :**

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


## Implémenter l’interface

**Implémentation Android :**

```csharp
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 :**

```csharp
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 :

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


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

```csharp
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&lt;TInstance&gt;** du type **DependencyService**

```csharp
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&lt;T&gt;** le **DependencyService** va initialiser sa liste d’implémentations en recherchant dans tous les assemblies les utilisations de l’attribut **DependencyAttribute**.

**Initialisation :**

```csharp
            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&#8217;assembly cette premi&egrave;re initialisation peut &ecirc;tre longue. **

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

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


## Pour aller plus loin :
- [Code source du DependencyService](https://github.com/xamarin/Xamarin.Forms/blob/master/Xamarin.Forms.Core/DependencyService.cs)
- [Développez vos applications multiplateformes pour iOS, Android et Windows](https://www.editions-eni.fr/supports-de-cours/livre/xamarin-developpez-vos-applications-multiplateformes-pour-ios-android-et-windows-9782409007477)