C# Academy · Leçon

Interfaces génériques

Abstraisez les types.

Interfaces génériques est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce qu'une interface générique ?

Une interface générique déclare des paramètres de type entre chevrons après son nom. Les implémentations choisissent les types concrets et le contrat de l'interface s'adapte en conséquence.

La bibliothèque .NET les utilise partout, par exemple IEnumerable<T> et IComparable<T>.

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

Implémenter une interface générique

Une classe peut implémenter une interface générique en fournissant un argument de type concret. Les signatures de méthode utilisent alors ce type réel.

Vous obtenez ainsi un contrat réutilisable et sûr du point de vue du typage, sans conversions explicites.

using System.Collections.Generic;

class IntStore : IRepository<int>
{
    private readonly List<int> data = new();
    public void Add(int item) => data.Add(item);
    public int Get(int id) => data[id];
}

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

Rester générique dans l'implémentation

Une classe peut implémenter une interface générique tout en restant elle-même générique, en transmettant son propre paramètre de type à l'interface.

L'implémentation reste ainsi réutilisable pour tout type d'élément.

using System.Collections.Generic;

class Store<T> : IRepository<T>
{
    private readonly List<T> data = new();
    public void Add(T item) => data.Add(item);
    public T Get(int id) => data[id];
}

interface IRepository<T> { void Add(T item); T Get(int id); }

IComparable<T> en action

IComparable<T> est une interface générique intégrée. Son implémentation permet à votre type de définir l'ordre de ses instances et d'activer le tri.

La méthode CompareTo renvoie une valeur négative, zéro ou une valeur positive.

class Money : IComparable<Money>
{
    public int Cents;
    public int CompareTo(Money? other)
        => Cents.CompareTo(other?.Cents ?? 0);
}

Implémenter IEnumerable<T>

IEnumerable<T> est au cœur de LINQ et de foreach. Un type qui l'implémente peut être parcouru. Souvent, vous déléguez l'itération à l'itérateur d'une collection interne.

Les méthodes d'itération utilisant yield return facilitent cette tâche.

using System.Collections;
using System.Collections.Generic;

class Bag<T> : IEnumerable<T>
{
    private readonly List<T> items = new();
    public void Add(T x) => items.Add(x);
    public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

Une interface générique exécutable

Ce programme complet définit IPrinter<T>, une interface générique, et l'implémente pour les chaînes, puis l'utilise.

L'interface garantit l'existence d'une méthode Print, quel que soit le type concret.

using System;

interface IPrinter<T> { void Print(T value); }

class ConsolePrinter<T> : IPrinter<T>
{
    public void Print(T value) => Console.WriteLine(value);
}

class Program
{
    static void Main()
    {
        IPrinter<string> p = new ConsolePrinter<string>();
        p.Print("hello generics");
    }
}

Covariance avec out

Un paramètre d'interface générique marqué out est covariant : il apparaît uniquement dans des positions de sortie. Cela permet d'utiliser IEnumerable<Cat> là où IEnumerable<Animal> est attendu.

La covariance préserve la compatibilité d'affectation le long d'une chaîne d'héritage.

interface IProducer<out T>
{
    T Produce();
}

Contravariance avec in

Un paramètre marqué in est contravariant : il apparaît uniquement dans des positions d'entrée. Cela permet d'utiliser IComparer<Animal> là où IComparer<Cat> est nécessaire.

La contravariance inverse le sens de l'affectabilité pour les consommateurs.

interface IConsumer<in T>
{
    void Consume(T item);
}

Plusieurs paramètres de type

Les interfaces génériques peuvent accepter plusieurs paramètres. IDictionary<TKey, TValue> en est un exemple courant, avec des types distincts pour la clé et la valeur.

Chaque paramètre peut indépendamment être invariant, covariant ou contravariant.

interface IMapper<TIn, TOut>
{
    TOut Map(TIn input);
}

Programmer avec l’interface

S’appuyer sur une interface générique plutôt que sur une classe concrète rend le code flexible. Vous pouvez remplacer les implémentations sans modifier le code appelant.

Les paramètres de méthode typés comme IEnumerable<T> acceptent aussi bien des listes, des tableaux que des résultats de requête.

using System.Collections.Generic;
using System.Linq;

int Total(IEnumerable<int> values) => values.Sum();

Contraintes avec des interfaces génériques

Les interfaces génériques apparaissent souvent comme contraintes. where T : IComparable<T> permet à une méthode de trier ou de comparer ses entrées.

Cela associe deux fonctionnalités des génériques pour créer des algorithmes sûrs et réutilisables.

T Min<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) <= 0 ? a : b;

Vérification rapide

Vérifiez votre compréhension des interfaces génériques.

Récapitulatif

Les interfaces génériques déclarent des paramètres de type et permettent aux implémentations de les fixer ou de les transmettre. Parmi les exemples intégrés figurent IEnumerable<T>, IComparable<T> et IDictionary<TKey, TValue>.

Les annotations de variance out et in permettent la covariance et la contravariance, et les interfaces génériques s’associent naturellement aux contraintes where.

Questions Fréquemment Posées

La leçon « Interfaces génériques » est-elle gratuite ?

Oui — le texte complet de « Interfaces génériques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Interfaces génériques » ?

Abstraisez les types. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Interfaces génériques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy