C# Academy · Leçon

Concept et cas d’usage ; générateurs incrémentiels (vue d’ensemble)

Découvrez le rôle des générateurs, leurs cas d’usage courants, le principe des générateurs incrémentiels et une émulation compatible avec C# 6 à l’aide d’attributs et de classes partielles.

Leçon 1 sur 28 étapes

Concept et cas d’usage ; générateurs incrémentiels (vue d’ensemble) est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 2. 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 2 leçons au total.

Qu’est-ce qu’un générateur ?

Objectif : découvrir ce que sont les générateurs de code source et comprendre leur utilité.

  • Ils analysent votre code et génèrent de nouveaux fichiers C#
  • Très utiles pour le code répétitif (convertisseurs, notifications, DTO)
  • Idée incrémentielle : ne réagir qu’aux entrées modifiées
  • Nous simulons ici ce fonctionnement avec des attributs et des classes partielles (C# 6)

Principe des classes partielles

Les classes partial permettent de répartir un type entre plusieurs fichiers ; les générateurs produisent généralement la partie partial supplémentaire.

using System;

// Partial lets code live in multiple files; generators often emit a second part.
public partial class Person
{
  // "User" code (hand-written)
  public string FirstName;
  public string LastName;
}

// Imagine another file is generated with helpers.
public partial class Person
{
  // This region simulates "generated" members.
  public string FullName()
  {
    // simple boilerplate a generator could write
    return (FirstName ?? """") + " " + (LastName ?? """");
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Person p = new Person();
    p.FirstName = "Ada";
    p.LastName = "Lovelace";
    Console.WriteLine(p.FullName());
  }
}

Marqueurs d’attributs

Les générateurs analysent les attributs pour décider quoi produire. Nous simulons la découverte via la réflexion (au moment de la compilation dans la pratique).

using System;
using System.Reflection;

// Marker attribute a generator would search for
[AttributeUsage(AttributeTargets.Class)]
public sealed class AutoNotifyAttribute : Attribute { }

// A class we want to augment (emulating generator input)
[AutoNotify]
public class Settings
{
  public string Theme; // we wish to auto-generate a property wrapper
}

// In real generators, Roslyn would find [AutoNotify] and emit code.
// Here we only "discover" the attribute at runtime (emulation).

public class Program
{
  public static void Main(string[] args)
  {
    Type t = typeof(Settings);
    object[] at = t.GetCustomAttributes(typeof(AutoNotifyAttribute), false);
    Console.WriteLine(at.Length > 0 ? "Marker found" : "No marker");
  }
}

Démonstration d’un modèle de code

Un générateur produirait du code dans un nouveau fichier. Nous nous contentons d’afficher un modèle simple pour rendre l’idée concrète.

using System;
using System.Text;

// Tiny template that prints C# code a generator could add.
public static class Template
{
  public static string EmitAutoProperty(string className, string fieldName)
  {
    // Very small example; real generators would use syntax trees.
    StringBuilder sb = new StringBuilder();
    sb.AppendLine("public partial class " + className);
    sb.AppendLine("{");
    sb.AppendLine("  public string " + Upper(fieldName) + "");
    sb.AppendLine("  {");
    sb.AppendLine("    get { return this." + fieldName + "; }");
    sb.AppendLine("    set { this." + fieldName + " = value; /* notify here */ }");
    sb.AppendLine("  }");
    sb.AppendLine("}");
    return sb.ToString();
  }

  private static string Upper(string name)
  {
    if (string.IsNullOrEmpty(name)) return name;
    if (name.Length == 1) return name.ToUpperInvariant();
    return char.ToUpperInvariant(name[0]) + name.Substring(1);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    // Show what the "generated" code could look like
    string code = Template.EmitAutoProperty("Settings", "theme");
    Console.WriteLine(code);
  }
}

Vue d’ensemble de l’incrémentalité

Les générateurs incrémentiels répartissent le travail en petites étapes.

  • Suivre les entrées (syntaxe, fichiers supplémentaires)
  • Ne recalculer que lorsqu’un élément a changé
  • Compilations plus rapides et moins d’allocations
  • Conseil de conception : conserver des étapes pures et déterministes

Leurs points forts

Cas d’utilisation :

  • Code répétitif : INotifyPropertyChanged, convertisseurs de DTO
  • Vérifications à la compilation : tables de routage, liaison de paramètres
  • Performances : éviter la réflexion dans les chemins critiques
  • Synchronisation de la documentation et du code : identifiants, constantes

Évitez-les pour la logique complexe à l’exécution ; gardez la production de code limitée et prévisible.

Rôle du générateur

Vérification rapide : que font les générateurs de code source C# au moment de la compilation ?

Récapitulatif

Récapitulatif : les générateurs inspectent votre code et génèrent du code source. Pensez en termes d’attributs et de parties partielles, gardez les sorties très petites et, de manière incrémentielle, ne recalculez que ce qui a changé.

Gratuit pour commencer

Apprends C# avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
93
Leçons
346

Questions Fréquemment Posées

La leçon « Concept et cas d’usage ; générateurs incrémentiels (vue d’ensemble) » est-elle gratuite ?

Oui — le texte complet de « Concept et cas d’usage ; générateurs incrémentiels (vue d’ensemble) » 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 2 leçons au total.

Qu'est-ce que j'apprendrai dans « Concept et cas d’usage ; générateurs incrémentiels (vue d’ensemble) » ?

Découvrez le rôle des générateurs, leurs cas d’usage courants, le principe des générateurs incrémentiels et une émulation compatible avec C# 6 à l’aide d’attributs et de classes partielles. 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 2.

Combien de temps prend la leçon « Concept et cas d’usage ; générateurs incrémentiels (vue d’ensemble) » ?

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

  1. Concept et cas d’usage ; générateurs incrémentiels (vue d’ensemble)
  2. Expérience développeur et limites
← Retour à C# Academy