C# Academy · Leçon

Méthodes génériques

Paramètres de type sur les méthodes.

Méthodes génériques est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Que sont les méthodes génériques ?

Une méthode générique déclare un ou plusieurs paramètres de type qui lui sont propres, écrits entre chevrons après le nom de la méthode. Le même corps de méthode fonctionne alors avec de nombreux types, sans transtypage ni duplication.

Les paramètres de type sont des espaces réservés comme T. Le compilateur remplace l'espace réservé par le type réel au point d'appel, tout en conservant un typage fort.

void Print<T>(T value)
{
    Console.WriteLine(value);
}

Déclarer un paramètre de type

La liste des paramètres de type <T> se place entre le nom de la méthode et la liste des paramètres. Vous pouvez utiliser T comme type de paramètre, type de retour ou type d'une variable locale dans le corps de la méthode.

Par convention, les paramètres de type uniques sont nommés T ; des noms descriptifs comme TKey sont également courants.

T Echo<T>(T input)
{
    return input;
}

Appel avec inférence de type

En général, vous ne précisez pas explicitement l'argument de type. Le compilateur déduit T à partir des arguments que vous transmettez.

Ici, Echo(42) déduit T = int, et Echo("hi") déduit T = string. L'inférence de type rend les appels génériques clairs et lisibles.

using System;

class Program
{
    static T Echo<T>(T input) => input;

    static void Main()
    {
        Console.WriteLine(Echo(42));
        Console.WriteLine(Echo("hi"));
    }
}

Arguments de type explicites

Lorsque l'inférence ne permet pas de déterminer le type, ou lorsque vous souhaitez être explicite, fournissez l'argument de type entre chevrons au niveau de l'appel.

C'est nécessaire lorsqu'aucun argument ne porte le type, par exemple pour une méthode dont T apparaît uniquement dans le type de retour.

T Create<T>() where T : new() => new T();

// call:
var list = Create<int>();

Plusieurs paramètres de type

Une méthode générique peut déclarer plusieurs paramètres de type séparés par des virgules. Chacun est déduit ou fourni indépendamment.

Un exemple classique est une opération d'échange ou un constructeur de paires qui combine deux types distincts.

(TSecond, TFirst) Flip<TFirst, TSecond>(TFirst a, TSecond b)
{
    return (b, a);
}

Un échange générique

Les méthodes génériques sont particulièrement utiles pour les utilitaires qui ignorent le type concret. Une opération d'échange réordonne deux valeurs de n'importe quel type compatible.

Le mot-clé ref permet à la méthode de modifier directement les variables de l'appelant.

using System;

class Program
{
    static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    static void Main()
    {
        int x = 1, y = 2;
        Swap(ref x, ref y);
        Console.WriteLine($"{x} {y}");
    }
}

Contraintes sur les paramètres de méthode

Une méthode générique peut restreindre ses paramètres de type avec une clause where. Les contraintes indiquent au compilateur quelles opérations sont autorisées sur T.

Ci-dessous, where T : IComparable<T> permet au corps de la méthode d'appeler CompareTo en toute sécurité.

T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) >= 0 ? a : b;
}

Méthodes génériques dans des classes non génériques

Une classe n'a pas besoin d'être générique pour contenir des méthodes génériques. Les classes utilitaires statiques en regroupent souvent.

Cela permet de rassembler les outils polyvalents sans imposer à toute la classe de porter un paramètre de type.

static class Util
{
    public static T First<T>(T[] items) => items[0];
}

Inférence à partir de tableaux

L'inférence de type fonctionne également avec les arguments de type tableau et collection. Le passage d'un int[] déduit automatiquement T = int.

Les algorithmes génériques ressemblent ainsi à des fonctionnalités intégrées au langage.

using System;

class Program
{
    static T First<T>(T[] items) => items[0];

    static void Main()
    {
        int[] nums = { 10, 20, 30 };
        Console.WriteLine(First(nums));
    }
}

Pourquoi ne pas utiliser simplement object ?

Avant les génériques, le code utilisait object et des conversions explicites. Cela fait perdre la sécurité de typage et effectue une mise en boîte des types valeur, ce qui dégrade les performances.

Les méthodes génériques évitent la mise en boîte des types valeur et détectent les erreurs de type à la compilation au lieu de les provoquer à l'exécution.

// Unsafe: needs a cast and can fail at runtime
object Echo(object o) => o;
int n = (int)Echo(5);

Retourner des types différents

Le type de retour peut lui-même être générique, ce qui permet à une même méthode d'adapter son résultat à l'appelant. default(T) fournit la valeur zéro pour les types valeur ou null pour les types référence.

C'est pratique pour prévoir une solution de repli sûre lorsqu'aucune valeur n'est disponible.

T OrDefault<T>(bool ok, T value)
{
    return ok ? value : default(T);
}

Vérification rapide

Vérifiez votre compréhension des méthodes génériques.

Récapitulatif

Les méthodes génériques déclarent leurs propres paramètres de type entre chevrons après leur nom. Le compilateur déduit généralement le type à partir des arguments, mais vous pouvez le fournir explicitement.

Elles préservent la sécurité de typage, évitent la mise en boîte et peuvent comporter des contraintes where. Vous pouvez les placer dans n'importe quelle classe, générique ou non.

Questions Fréquemment Posées

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

Oui — le texte complet de « Méthodes 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 « Méthodes génériques » ?

Paramètres de type sur les méthodes. 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 1 sur 4.

Combien de temps prend la leçon « Méthodes 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