C# Academy · Leçon

Constructeurs de collections

Prenez en charge les expressions de collection dans des types personnalisés.

Constructeurs de collections 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.

Types personnalisés dans les expressions de collection

Les expressions de collection ne se limitent pas aux types intégrés. Avec l’attribut [CollectionBuilder], votre propre type peut être créé à l’aide de la syntaxe [...].

L’attribut CollectionBuilder

Vous appliquez [CollectionBuilder(typeof(Factory), "Create")] à votre type de collection. Il désigne une méthode fabrique statique que le compilateur appelle pour construire les instances.

Signature de la méthode du générateur

La méthode du générateur doit être static et accepter un seul paramètre ReadOnlySpan<T>, en retournant votre type de collection. Le compilateur transmet les éléments sous forme de span.

Une collection personnalisée minimale

Voici une petite collection immuable qui active la création par expression de collection au moyen d’un générateur.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

[CollectionBuilder(typeof(IntBagBuilder), "Create")]
class IntBag : IEnumerable<int> {
    private readonly int[] items;
    public IntBag(ReadOnlySpan<int> data) => items = data.ToArray();
    public IEnumerator<int> GetEnumerator() => ((IEnumerable<int>)items).GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => items.GetEnumerator();
}

static class IntBagBuilder {
    public static IntBag Create(ReadOnlySpan<int> data) => new IntBag(data);
}

IntBag bag = [1, 2, 3];
foreach (int n in bag) Console.Write(n + " "); // 1 2 3
Console.WriteLine();

Pourquoi utiliser ReadOnlySpan ?

Le paramètre span permet au compilateur de transmettre les éléments sans allocation intermédiaire. Votre générateur les copie dans le stockage dont il a besoin.

Il doit implémenter IEnumerable

Le type de collection doit implémenter IEnumerable<T> (en faisant correspondre le type des éléments du span) afin que le compilateur connaisse le type des éléments et puisse valider l’utilisation.

Générateurs génériques

Les générateurs peuvent être génériques et prendre en charge MyCollection<T>. La méthode du générateur accepte ReadOnlySpan<T> et retourne MyCollection<T>.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

[CollectionBuilder(typeof(BoxBuilder), "Create")]
class Box<T> : IEnumerable<T> {
    private readonly T[] items;
    public Box(ReadOnlySpan<T> d) => items = d.ToArray();
    public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>)items).GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => items.GetEnumerator();
}

static class BoxBuilder {
    public static Box<T> Create<T>(ReadOnlySpan<T> d) => new Box<T>(d);
}

Box<string> b = ["x", "y"];
foreach (var s in b) Console.Write(s + " "); // x y
Console.WriteLine();

Avantage pour les collections immuables

Les générateurs permettent aux collections immuables de .NET, comme ImmutableArray<T>, de prendre en charge les expressions de collection. Le générateur construit l’instance figée à partir du span.

using System;
using System.Collections.Immutable;

ImmutableArray<int> nums = [1, 2, 3];
Console.WriteLine(nums.Length); // 3

Les expansions fonctionnent aussi

Une fois qu’un type possède un générateur, les expansions fonctionnent automatiquement dans ses expressions de collection, car le compilateur produit toujours un span unique d’éléments.

using System;
using System.Collections.Immutable;

ImmutableArray<int> a = [1, 2];
ImmutableArray<int> all = [..a, 3, 4];
Console.WriteLine(all.Length); // 4

Quand ajouter un générateur

Ajoutez un [CollectionBuilder] lorsque vous distribuez une collection personnalisée et souhaitez permettre aux appelants de profiter de la syntaxe concise [...], en particulier pour les conteneurs immuables ou spécialisés.

Tout assembler

Un générateur se résume à trois éléments : l’attribut, un type IEnumerable<T> et une méthode Create(ReadOnlySpan<T>) statique. Avec ces éléments, votre type devient une cible à part entière pour les expressions de collection.

Vérification rapide

Confirmez les exigences d’un générateur de collection.

Récapitulatif

Vous avez appris comment les types personnalisés prennent en charge les expressions de collection.

Appliquez [CollectionBuilder(typeof(Factory), "Create")] au type.
La fabrique est une méthode static acceptant ReadOnlySpan<T>.
Le type doit implémenter IEnumerable<T>.
C’est ainsi que ImmutableArray<T> accepte [...].

Questions Fréquemment Posées

La leçon « Constructeurs de collections » est-elle gratuite ?

Oui — le texte complet de « Constructeurs de collections » 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 « Constructeurs de collections » ?

Prenez en charge les expressions de collection dans des types personnalisés. 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 « Constructeurs de collections » ?

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

Syntaxe des expressions de collection
L’élément de déploiement
Déduction du type cible pour les collections
Constructeurs de collections

← Retour à C# Academy