Queue<T> (FIFO) et Stack<T> (LIFO)

Queue<T> traite les éléments dans l'ordre d'arrivée (FIFO), idéale pour des files de jobs. Stack<T> traite en dernier entré, premier sorti (LIFO), pratique pour l'historique et l'annulation.

Cas d’usage

Queue<T> — file d’attente FIFO

Utilisez Enqueue, Dequeue et Peek pour gérer une file d’attente. Parfaite pour planifier des traitements séquentiels.

// FIFO processing with Queue<T>
using System;
using System.Collections.Generic;

var jobs = new Queue<string>();
jobs.Enqueue("First");
jobs.Enqueue("Second");
jobs.Enqueue("Third");

Console.WriteLine(jobs.Peek());

while (jobs.Count > 0)
{
  var job = jobs.Dequeue();
  Console.WriteLine($"Running: {job}");
}

// Sample output:
// Running: First
// Running: Second
// Running: Third

ConcurrentQueue<T> — thread-safe en async

Utilisez ConcurrentQueue<T> avec TryDequeue et des primitives (SemaphoreSlim, Channel) pour gérer des producteurs/consommateurs sans busy-wait.

Stack<T> — pile LIFO

Utilisez Push, Pop et Peek pour gérer une pile. Idéale pour la navigation arrière, l’undo/redo, l’évaluation d’expressions.

// LIFO processing with Stack<T>
using System;
using System.Collections.Generic;


var history = new Stack<string>();
history.Push("First");
history.Push("Second");
history.Push("Third");

Console.WriteLine(history.Peek());

while (history.Count > 0)
{
  var page = history.Pop();
  Console.WriteLine($"Back to: {page}");
}

// Sample output:
// Back to: Third
// Back to: Second
// Back to: First

ConcurrentStack<T> — thread-safe en parallèle

Utilisez ConcurrentStack<T> avec TryPop et Parallel.For pour consommer une pile en parallèle en toute sécurité.

Résumé

Choisissez Queue<T> pour des flux FIFO, Stack<T> pour des scénarios LIFO. Ces structures sont simples, rapides (O(1) amorti) et sûres pour un usage monothread.

Avantages

• API minimale et explicite (Enqueue/Dequeue, Push/Pop)
• Opérations O(1) amorties, bonnes perfs mémoire
• Idéales pour la modélisation de flux simples

Inconvénients

• Pas d’accès aléatoire ni d’indexation
• Non thread-safe par défaut (voir ConcurrentQueue/Stack)
• Fonctionnalités limitées vs List<T>

Bonnes pratiques

• Exposez IEnumerable<T> en lecture, gardez Queue/Stack internes
• Utilisez TryDequeue/TryPeek (ConcurrentQueue) en multi‑thread
• Appelez TrimExcess après des suppressions massives
• Évitez Contains dans les boucles serrées (O(n))