Name: Tremplin Numérique
Price range: $$$

comment-les-attributs-fonctionnent-ils-en-c-cloudsavvy-it-9797242

L’un des composants clés des langages orientés objet tels que Java et C # est la possibilité d’écrire des classes à l’aide d’interfaces, qui standardisent les définitions de méthodes et permettent un polymorphisme amélioré. Nous discuterons de ce qu’ils sont et comment les utiliser.

Sommaire

Polymorphisme formalisé

Les interfaces sont essentiellement des classes sans code. Le peut définir des propriétés et des méthodes (mais pas des champs directement) sans réellement stocker de données ou écrire une implémentation pour les fonctions.

Par exemple, l’interface IEnumerable de .NET est très courante. Tout ce qu’il faut, c’est une fonction qui renvoie un IEnumerator, qui peut être utilisé pour itérer sur une collection.

```
public interface IEnumerable
```
```
{
```
```
    IEnumerator GetEnumerator();
```
```
}
```

Chaque collection dans .NET met en oeuvre cette interface. En fait, la plupart des collections implémenteront de nombreuses interfaces, toutes normalisant les méthodes utilisées pour travailler avec elles.

L’avantage de le faire de cette façon est que toutes les méthodes sont standardisées dans l’interface, de sorte que chaque fois que vous voulez que quelque chose accepte de nombreux types de classes, vous pouvez le faire en accédant aux méthodes d’interface.

Par exemple, foreach boucles sous le capot vraiment juste utiliser .GetEnumerator(), ils prendront donc en charge tout type de collection qui implémente IEnumerable, comme Lists, Dictionaries et HashSets.

```
void Main()
```
```
{
```
```
    foreach(var item in  IEnumerable) 
```
```
    {
```
```
       // do something
```
```
    }
```
```
}
```

Vous pouvez considérer les interfaces comme un remplacement des classes de base. Les classes de base sont toujours très utiles, mais exiger que chaque classe hérite et remplace les méthodes peut être compliqué. De plus, vous ne pouvez avoir qu’une seule classe de base, mais vous pouvez implémenter n’importe quel nombre d’interfaces.

Les interfaces peuvent également être utilisées à la place des paramètres de type. Par exemple, vous pouvez avoir une collection personnalisée, CustomList<T>. Cela fonctionne pour n’importe quel type, mais si vous souhaitez appeler une méthode spécifique sur chaque élément, vous ne pouvez pas, car le compilateur n’a aucune idée si le type utilisé prend en charge cette méthode. Les seules options que vous obtiendrez seront des méthodes de base objects.

Cependant, si vous abandonnez à la place le paramètre de type générique et utilisez une interface, vous pouvez appeler une méthode sur les éléments. La collection prendra toujours en charge tout type de type, bien que maintenant chaque élément que vous envisagez d’y mettre devra implémenter l’interface.

En général, vous devez utiliser des interfaces lorsque vous réutilisez les mêmes méthodes pour de nombreuses classes qui n’héritent pas les unes des autres, et que vous aimeriez pouvoir écrire du code polymorphe qui ne se soucie pas de la classe sous-jacente spécifique.

Utilisation des interfaces

Les interfaces sont assez simples à utiliser. Ils utilisent la même syntaxe d’héritage que les classes de base, un deux-points après la définition de la classe. Notez que si vous souhaitez utiliser une interface avec une classe de base, la classe de base doit venir en premier, suivie d’une virgule et de toutes les interfaces qu’elle implémente.

Une fois que vous avez ajouté la définition d’interface, vous obtiendrez probablement une erreur. Visual Studio vous dira que vous n’implémentez pas réellement les propriétés et méthodes de l’interface. Cela peut en fait être très utile, car si vous apportez des modifications à l’interface, vous devrez mettre à jour toutes les classes qui l’implémentent.

Visual Studio est assez sophistiqué, et si vous cliquez sur «afficher les correctifs potentiels», vous obtiendrez une option permettant à VS d’ajouter automatiquement l’interface standard à votre classe. Vous devrez évidemment remplacer les NotImplementedExceptions.

Vous pouvez également implémenter des interfaces explicitement. Cela a le même effet, mais avec une syntaxe différente qui indique clairement de quelle interface provient la méthode ou la propriété. Cela semble assez étrange à première vue, mais peut être utile si vous implémentez beaucoup d’interfaces.

Écrire vos propres interfaces

Les définitions d’interface sont à peu près les mêmes que les définitions de classe, bien que chaque méthode n’aura pas de corps, et vous devrez évidemment utiliser «interface» au lieu de «class». Tout comme les classes, les interfaces peuvent également utiliser des paramètres de type générique, ce qui peut être utile pour les collections personnalisées.

Vous pouvez utiliser le { get; set; } syntaxe pour spécifier implicitement les propriétés, qui fonctionne également lors de leur implémentation dans la classe réelle:

Vous pouvez également faire hériter les interfaces entre elles. Par exemple, ce ICustomList l’interface pourrait être beaucoup plus utile si elle incluait simplement toutes les autres définitions List utilise, mais en ajoute quelques personnalisés. Désormais, lorsque vous utiliserez l’interface, vous devrez implémenter tous les membres de l’interface de chaque interface dont elle hérite.