420-KBB-LG – Programmation orientée objet avancée

const int N = 10_000_000;
const int NB_FACES = 6;
Random dé = new();
int[] lancers = new int[12]; // 0 .. 11, et la 0 sera à 0
for (int i = 0; i != N; ++i)
{
   int a = dé.Next(1, NB_FACES + 1),
       b = dé.Next(1, NB_FACES + 1);
   // Console.WriteLine($"{a} + {b} == {a+b}");
   lancers[(a + b) - 1]++;
}
Console.WriteLine($"Après {N} lancers de deux dés à {NB_FACES} faces...");
for (int i = 1; i != lancers.Length; ++i)
   Console.WriteLine($"{i + 1} : {lancers[i]}");

string texte = "..."; // utilisez le texte de votre choix

Dictionary<string, int> fréquence = new();
foreach(string s in texte.Split(new char[] { ' ' }))
   if(fréquence.ContainsKey(s))
      fréquence[s]++;
   else
      fréquence.Add(s, 1);

foreach (var (mot, n) in fréquence)
   Console.WriteLine($"Le mot {mot} apparaît {n} fois");

using Sytem.Collections.Generic;
class PileVideException : Exception {}
class Pile<T>
{
   List<T> Substrat{ get; } = new();
   public bool EstVide => Substrat.Count == 0;
   public void Empiler(T val)
   {
      Substrat.Add(val);
   }
   public T Dépiler()
   {
      T val = Examiner();
      Substrat.RemoveAt(Substrat.Count - 1);
      return val;
   }
   public T Examiner()
   {
      if (EstVide)
         throw new PileVideException();
      return Substrat[Substrat.Count - 1];
   }
}

using Sytem.Collections.Generic;
class PileVideException : Exception {}
class Pile<T>
{
   class Noeud
   {
      public T Valeur{ get; init; }
      public Noeud Prédécesseur{ get; set; } = null;
      public Noeud(T val)
      {
         Valeur = val;
      }
   }
   Noeud Tête { get; set; } = null;
   public bool EstVide => Tête == null;
   public void Empiler(T val)
   {
      Noeud p = new(val);
      p.Précédesseur = Tête;
      Tête = p;
   }
   public T Dépiler()
   {
      T val = Examiner();
      Tête = Tête.Précédesseur;
      return val;
   }
   public T Examiner()
   {
      if (EstVide)
         throw new PileVideException();
      return Tête.Valeur`;
   }
}

class ListVideException : Exception { }
class ListeSimple<T> : IEnumerable<T>
{
   class Noeud
   {
      public T Valeur { get; init; }
      public Noeud Succ { get; set; } = null;
      public Noeud(T val)
      {
         Valeur = val;
      }
   }
   Noeud Tête { get; set; } = null;
   Noeud Queue { get; set; } = null;
   public bool EstVide => Tête == null;
   public int Count { get; private set; } = 0;
   public void AjouterDébut(T val)
   {
      Noeud p = new(val);
      if (EstVide)
         Queue = p;
      p.Succ = Tête;
      Tête = p;
      ++Count;
   }
   public void AjouterFin(T val)
   {
      Noeud p = new(val);
      if (EstVide)
         Tête = p;
      else
         Queue.Succ = p;
      Queue = p;
      ++Count;
   }
   public void SupprimerDébut()
   {
      if (EstVide)
         throw new ListVideException();
      Tête = Tête.Succ;
      if (EstVide)
         Queue = null;
      --Count;
   }
   class Énumérateur : IEnumerator<T>
   {
      Noeud Cur { get; set; }
      public Énumérateur(ListeSimple<T> src)
      {
         Cur = new(default);
         Cur.Succ = src.Tête;
      }
      public T Current => Cur.Valeur;
      object IEnumerator.Current => Cur.Valeur;
      public void Dispose() { }
      public bool MoveNext()
      {
         if (Cur.Succ == null)
            return false;
         Cur = Cur.Succ;
         return true;
      }
      public void Reset() { }
   }
   public IEnumerator<T> GetEnumerator() =>
      new Énumérateur(this);
   IEnumerator IEnumerable.GetEnumerator() =>
      new Énumérateur(this);
   // SupprimerFin ... ark ark ark je refuse
   public T First =>
      !EstVide ? Tête.Valeur : throw new ListVideException();
   public T Last =>
      !EstVide ? Queue.Valeur : throw new ListVideException();
}

// on va utiliser args pour les fichiers, parce que
// faire un tableau de noms de fichiers, c'est plate

int moitié = args.Length / 2;

Dictionary<string, int> resGauche = new();
Dictionary<string, int> resDroite = new();

Thread gauche = new(() =>
{
   List<Dictionary<string, int>> dicos = new();
   for (int i = 0; i != moitié; ++i)
   {
      string texte = LireFichier(args[i]);
      List<string> mots = Tokeniser(texte);
      Dictionary<string, int> dico = CompterOccurrences(mots);
      dicos.Add(dico);
      // dicos.Add(
      //    CompterOccurrences(
      //       Tokeniser(
      //          LireFichier(args[i])
      //       )
      //    )
      // );
   } 
   foreach (var d in dicos)
      resGauche = Fusionner(resGauche, d);
});
Thread droite = new(() =>
{
   List<Dictionary<string, int>> dicos = new();
   for (int i = moitié; i != args.Length; ++i)
   {
      string texte = LireFichier(args[i]);
      List<string> mots = Tokeniser(texte);
      Dictionary<string, int> dico = CompterOccurrences(mots);
      dicos.Add(dico);
   }
   foreach (var d in dicos)
      resDroite = Fusionner(resDroite, d);
});
gauche.Start(); droite.Start();
droite.Join(); gauche.Join();


var occurrences = Fusionner(resGauche, resDroite);
var lexi = occurrences.ToArray();
Array.Sort(lexi, (m0, m1) => m0.Key.CompareTo(m1.Key));
foreach (var (mot, n) in lexi)
   Console.WriteLine($"{mot} : {n}");
Console.WriteLine();
Console.WriteLine(new string('-', 70));
var decr = occurrences.ToArray();
Array.Sort(decr, (m0, m1) => m1.Value.CompareTo(m0.Value));
foreach (var (mot, n) in decr)
   Console.WriteLine($"{mot} : {n}");
Console.ReadLine();

static Dictionary<string, int>
   Fusionner(Dictionary<string, int> d0, Dictionary<string, int> d1)
{
   Dictionary<string, int> res = new();
   foreach(var (mot, n) in d0)
      res.Add(mot, n);
   foreach (var (mot, n) in d1)
      if(res.ContainsKey(mot))
         res[mot] += n;
      else
         res.Add(mot, n);
   return res;
}


//string texte = LireFichier("../../../test.txt");
// Console.WriteLine($"Texte complet :\n\"\"\"\n{texte}\n\"\"\"\n");
//List<string> mots = Tokeniser(texte);
//foreach(string mot in mots)
//   Console.WriteLine($"\"{mot}\"");
//Console.WriteLine();

//var dico = CompterOccurrences(mots);

//var lexi = dico.ToArray();
//Array.Sort(lexi, (m0, m1) => m0.Key.CompareTo(m1.Key));
//foreach (var (mot, n) in lexi)
//   Console.WriteLine($"{mot} : {n}");
//Console.WriteLine();

//var decr = dico.ToArray();
//Array.Sort(decr, (m0, m1) => m1.Value.CompareTo(m0.Value));
//foreach (var (mot, n) in decr)
//   Console.WriteLine($"{mot} : {n}");

static Dictionary<string, int> CompterOccurrences(List<string> mots)
{
   Dictionary<string, int> dico = new();
   foreach (string mot in mots)
      if (dico.ContainsKey(mot))
         dico[mot]++;
      else
         dico.Add(mot, 1);
   return dico;
}

static bool PeutDébuterMot(char c) => // !char.IsWhiteSpace(c);
   char.IsAsciiLetter(c) || c == '_';
static bool PeutPoursuivreMot(char c) => // !char.IsWhiteSpace(c);
   char.IsAsciiLetter(c) || char.IsDigit(c) || c == '_';
static int TrouverDébutMot(string s, int pos)
{
   for (; pos != s.Length && !PeutDébuterMot(s[pos]); ++pos)
      ;
   return pos != s.Length ? pos : -1;
}
// précondition : on est dans un mot
static int TrouverFinMot(string s, int pos)
{
   for (; pos != s.Length && PeutPoursuivreMot(s[pos]); ++pos)
      ;
   return pos != s.Length ? pos : -1;
}

// au sens de «transformer text en jetons qu'on appellera «mots»
static List<string> Tokeniser(string text)
{
   List<string> jetons = new();
   int pos = TrouverDébutMot(text, 0);
   while(pos != -1)
   {
      int fin = TrouverFinMot(text, pos);
      if (fin != -1)
      {
         jetons.Add(text.Substring(pos, fin - pos));
         pos = TrouverDébutMot(text, fin);
      }
      else
      {
         jetons.Add(text.Substring(pos));
         pos = -1;
      }
   }
   return jetons;
}
static string LireFichier(string nom)
{
   using (StreamReader sr = new(nom))
      return sr.ReadToEnd();
}

using System;
using System.Threading;

var bb = new Ardoise();
bb.Abonner(new Caméra());
var noms = new[] { "Bill", "Bob", "Frieda", "Wanda" };
var pub = new int[noms.Length];
for(int i = 0; i != noms.Length; ++i)
   pub[i] = bb.AjouterPublieur(noms[i]);
int fini = 0;
var th = new Thread[pub.Length];
for(int i = 0; i != th.Length; ++i)
{
   int indice = i;
   th[i] = new (() =>
   {
      var dé = new Random();
      for (int n = 0; fini == 0; )
      {
         if (dé.Next(0, pub.Length) == indice)
            bb.Publier(pub[indice], $" : \" message {n++} de {noms[indice]}\"");
         Thread.Sleep(dé.Next(400, 500));
      }
   });
}
foreach (var thr in th) thr.Start();
Console.ReadKey(true);
Interlocked.Exchange(ref fini, 1);
foreach (var thr in th) thr.Join();

class Caméra : IObservateurArdoise
{
   public void Nouveauté(string qui, string quoi)
   {
      Console.WriteLine($"{qui} a dit {quoi}");
   }
}

static void StressTestA(int n)
{
   var bb = new Ardoise();
   var noms = new[] { "Bill", "Bob" };
   var pub = new int[noms.Length];
   var th = new Thread[pub.Length];
   for(int i = 0; i != th.Length; ++i)
   {
      int indice = i;
      th[i] = new (() =>
      {
         for(int j = 0; j != n; ++j)
         {
            int id = bb.AjouterPublieur(noms[indice]);
            bb.Publier(id, $"Coucou #{j}");
            bb.RetirerPublieur(id);
         }
      });
   }
   foreach (var thr in th) thr.Start();
   foreach (var thr in th) thr.Join();
}

static void StressTestB(int n)
{
   Compteur compteur = new();
   var bb = new Ardoise();
   bb.Abonner(compteur);
   var noms = new[] { "Bill", "Bob" };
   var pub = new int[noms.Length];
   var th = new Thread[pub.Length];
   for (int i = 0; i != th.Length; ++i)
   {
      int indice = i;
      th[i] = new (() =>
      {
         for (int j = 0; j != n; ++j)
         {
            int id = bb.AjouterPublieur(noms[indice]);
            bb.Publier(id, $"Coucou #{j}");
            bb.RetirerPublieur(id);
         }
      });
   }
   foreach (var thr in th) thr.Start();
   foreach (var thr in th) thr.Join();
   compteur.Rapport();
}

class Compteur : IObservateurArdoise
{
   Dictionary<string, int> Compte { get; } = new();
   public void Nouveauté(string qui, string quoi)
   {
      lock(this)
      {
         if (Compte.ContainsKey(qui))
            Compte[qui]++;
         else
            Compte.Add(qui, 1);
         }
      }
      public void Rapport()
      {
         foreach (var (k, v) in Compte)
            Console.WriteLine($"{k} a publié {v} fois");
      }
   }

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

var bb = new Ardoise();
Messagerie msg = new(10);
bb.Abonner(msg);
var noms = new[] { "Bill", "Bob", "Frieda" };
var pub = new int[noms.Length];
for(int i = 0; i != noms.Length; ++i)
   pub[i] = bb.AjouterPublieur(noms[i]);
int fini = 0; // <--
var th = new Thread[pub.Length];
for(int i = 0; i != th.Length; ++i)
{
   int indice = i;
   th[i] = new Thread(() =>
   {
      var dé = new Random();
      for (int n = 0; fini == 0;) // <--
      {
         if (dé.Next() % pub.Length == indice)
            bb.Publier(pub[indice], $"message {n++} de {noms[indice]}");
         Thread.Sleep(dé.Next(400, 500));
      }
   });
}
foreach (var thr in th) thr.Start();
Thread affichage = new(() =>
{
   while(fini == 0)
   {
      msg.Afficher();
      Thread.Sleep(500);
   }
});
affichage.Start();
Console.ReadKey(true);
Interlocked.Exchange(ref fini, 1); // <--
foreach (var thr in th) thr.Join();
affichage.Join();

// ...
// remplir le catalogue
const char SYMBOLE_MÉTAL = '%';
Catalogue.Get.Associer(SYMBOLE_MÉTAL, Catégorie.Métal);
// préparer la surface d'affichage
const int HAUTEUR = 10,
          LARGEUR = 20;
Surface surf = new(HAUTEUR, LARGEUR);
// préparer le cadre de la surface
Cadre cadre = new(HAUTEUR, LARGEUR, ConsoleColor.Cyan);

// préparer la zone de messagerie
Messagerie messagerie = new(new(0, HAUTEUR));

// positionner Wallyd
Point2D centre = new(3, 3);
Robot wallyd = new("Wallyd", centre);
wallyd.Équiper(new DétecteurMétal(wallyd, 1.0f));
surf.Ajouter(wallyd);

// placer les déchets sur la surface
const int NB_DÉCHETS = 3;
Random dé = new();
List<Déchet> déchets = new();
var libres = surf.TrouverSi
(
   cadre.Exclure,
   c => c == default || c == ' '
);
if (libres.Count < NB_DÉCHETS)
   throw new SurfacePleineException();
for (int i = 0; i != NB_DÉCHETS; ++i)
{
   int n = dé.Next(libres.Count);
   déchets.Add(new(SYMBOLE_MÉTAL, Catégorie.Métal, libres[n]));
   libres.RemoveAt(n);
}
surf.Ajouter(déchets.ToArray());

while (surf.TrouverSi(c => c == SYMBOLE_MÉTAL).Count > 0)
{
   bool trouvé = false;
   do
   {
      PipelineAffichage pipeline = new();
      pipeline.Ajouter(Appliquer(cadre));
      pipeline.Appliquer
      (
         GénérerHalo(wallyd.Zone, surf.Dupliquer())
      );
      var pts = wallyd.Détecter(surf, Catégorie.Métal);
      if (pts.Count > 0)
      {
         trouvé = true;
         if (pts[0] == wallyd.Pos)
         {
            messagerie.Effacer();
            messagerie.Afficher
            (
               $"Déchet collecté à la position {pts[0]}"
            );
         }
         else
         {
            messagerie.Afficher
            (
               $"Trouvé {pts.Count} déchet(s)",
               $"Déplacement vers {pts[0]}"
            );
            surf.Retirer(wallyd);
            wallyd.DéplacerVers(pts[0]);
            surf.Ajouter(wallyd);
            wallyd.RéinitialiserPuissance();
         }
      }
      else
      {
         wallyd.AugmenterPuissance();
         messagerie.Effacer();
      }
      Thread.Sleep(500);
   }
   while (!trouvé);
   wallyd.RéinitialiserPuissance();
}
{
   PipelineAffichage pipeline = new();
   pipeline.Ajouter(Appliquer(cadre));
   pipeline.Appliquer
   (
      GénérerHalo(wallyd.Zone, surf.Dupliquer())
   );
}

static Mutable GénérerHalo(Cercle c, Mutable p)
{
   Mutable res = p.Dupliquer();
   for (int ligne = 0; ligne != res.Hauteur; ++ligne)
      for (int col = 0; col != res.Largeur; ++col)
      {
         Point2D pt = new(col, ligne);
         if (c.Centre.Distance(pt) <= c.Rayon)
            res[pt] = new(res[pt].Symbole, res[pt].Avant, ConsoleColor.Green);
      }
   return res;
}

static Func<Mutable, Mutable> Appliquer(Cadre p)
{
   return m =>
   {
      Mutable res = m.Dupliquer();
      for (int i = 0; i != p.Hauteur; ++i)
         for (int j = 0; j != p.Largeur; ++j)
         {
            var c = p[i, j];
            if (c.Symbole != default)
               res[i, j] = c;
         }
      return res;
   };
}
static Func<Mutable, Mutable> AppliquerSurface(Surface surf)
{
   return m =>
   {
      Mutable res = m.Dupliquer();
      for (int i = 0; i != surf.Hauteur; ++i)
         for (int j = 0; j != surf.Largeur; ++j)
         {
            var c = surf[i, j];
            if (c.Symbole != default)
               res[i, j] = c;
         }
      return res;
   };
}

class SurfacePleineException : Exception { }

// ...
      public List<Point2D> TrouverSi
      (
         Func<Point2D, bool> exclure,
         Func<char, bool> pred
      )
      {
         List<Point2D> pts = new();
         for (int ligne = 0; ligne != Hauteur; ++ligne)
            for (int col = 0; col != Largeur; ++col)
            {
               Point2D pt = new(col, ligne);
               if (!exclure(pt) && pred(this[pt].Symbole))
                  pts.Add(pt);
            }
         return pts;
      }
      public List<Point2D> TrouverSi(Func<char, bool> pred) =>
         TrouverSi(pt => false, pred);
// ...

// ...
   internal class PipelineAffichage
   {
      List<Func<Mutable, Mutable>> Transfos = new();
      public void Ajouter(Func<Mutable, Mutable> transfo) =>
         Transfos.Add(transfo);
      public IProjetable Appliquer(Point2D pos, Mutable p)
      {
         foreach (var transfo in Transfos)
            p = transfo(p);
         return Afficher(pos, p);
      }
      public IProjetable Appliquer(Mutable p) =>
         Appliquer(new(), p);
// ...

// ...
RobotInfo[] robotsInfo =
{
   new(null, 0, "Wallyd", ConsoleColor.Magenta, Catégorie.Métal),
   new(null, 1, "Bart", ConsoleColor.Blue, Catégorie.Plastique),
   new(null, 2, "Charles", ConsoleColor.Yellow, Catégorie.Organique),
   new(null, 3, "Lisa", ConsoleColor.Green, Catégorie.Nucléaire)
};

(char sym, Catégorie cat)[] symCatégorie =
{
    ('%', Catégorie.Métal),
    ('*', Catégorie.Plastique),
    ('&', Catégorie.Plastique),
    ('/', Catégorie.Organique),
    ('?', Catégorie.Nucléaire),
};
foreach (var symCat in symCatégorie)
    Catalogue.Get.Associer(symCat.sym, symCat.cat);

// préparer la surface d'affichage
const int HAUTEUR = 20,
          LARGEUR = 40;
Surface surf = new(HAUTEUR, LARGEUR);
// préparer le cadre de la surface
Cadre cadre = new(HAUTEUR, LARGEUR, ConsoleColor.Cyan);

// préparer la zone de messagerie
Messagerie messagerie = new(new(LARGEUR, 0), HAUTEUR);
// préparer la zone d'informations
Messagerie information = new(new(0, HAUTEUR), 2);


Random dé = new();
List<(Robot r, Catégorie c)> robots =
   CréerRobots(robotsInfo, dé, surf, cadre.Exclure);

// placer les déchets sur la surface
const int NB_DÉCHETS = 3;
List<Déchet> déchets =
   CréerPollution(symCatégorie, dé, NB_DÉCHETS, surf, cadre.Exclure);
surf.Ajouter(déchets.ToArray());

CanalComm canal = new(robotsInfo.Length);

PipelineAffichage pipe = new (surf, cadre, canal, messagerie, information);

pipe.Démarrer();

CancellationTokenSource src = new();
Thread[] cueilleurs =
   CréerCueilleurs
   (
      robotsInfo, surf, canal, messagerie, information, src.Token
   );
Thread lireTouche = new(() =>
{
   Console.ReadKey(true);
   src.Cancel();
});
lireTouche.Start();
foreach (var c in cueilleurs) c.Start();
foreach (var c in cueilleurs) c.Join();
lireTouche.Join();
pipe.Arrêter();

static List<(Robot robot, Catégorie cat)>
   CréerRobots(RobotInfo [] robotsInfo, Random dé, Surface surf, Func<Point2D, bool> exclure)
{
   List<(Robot r, Catégorie c)> robots = new();
   // Trouver les cases libres
   var libres = surf.TrouverSi(exclure,c => c == default || c == ' ');
   for (int r = 0; r < robotsInfo.Length; r++)
   {
      RobotInfo info = robotsInfo[r];
      int n = dé.Next(libres.Count);
      Robot robot =
         CréerRobot(info.nom, libres[n], info.couleur, info.catégorie);
      info.robot = robot;
      libres.RemoveAt(n);
   }
   return robots;
}
static Robot
   CréerRobot(string nom, Point2D pos, ConsoleColor couleur, Catégorie cat)
{
   Robot robot = new(nom, pos, couleur);
   robot.Équiper(new Détecteur(robot, 1, cat));
   return robot;
}

static List<Déchet>
   CréerPollution((char sym, Catégorie cat)[] symCatégorie, Random dé,
                  int nbDéchets,
                  Surface surf, Func<Point2D, bool> exclure)
{
   List<Déchet> déchets = new();
   var libres = surf.TrouverSi(exclure, c => c == default || c == ' ');
   if (libres.Count < nbDéchets * symCatégorie.Length)
      throw new SurfacePleineException();
   foreach (var symCat in symCatégorie)
   {
      for (int d = 0; d != nbDéchets; ++d)
      {
         int n = dé.Next(libres.Count);
         déchets.Add(new(symCat.sym, symCat.cat, libres[n]));
         libres.RemoveAt(n);
      }
   }
   return déchets;
}

static Thread[] CréerCueilleurs
   (RobotInfo[] robotsInfo, Surface surf, CanalComm canal,
    Messagerie messagerie, Messagerie information, CancellationToken jeton)
{
   Dictionary<char, int> collectés = new();
   var cueilleurs = new Thread[robotsInfo.Length];
   for (int r = 0; r < robotsInfo.Length; r++)
   {
      var (robot, noPort, _, _, cat) = robotsInfo[r];
      var catalogue = Catalogue.Get;
      cueilleurs[r] = new (() =>
      {
         // tant qu'il reste des déchets à ramasser
         while (!jeton.IsCancellationRequested &&
                surf.TrouverSi(c => catalogue.Est(c, cat)).Count > 0)
         {
            bool trouvé = false;
            // Trouver et ramasser le déchet
            do
            {
               canal.PublierSur(noPort, new(robot.Zone, robot.Couleur, robot.Symbole));
               var pts = robot.Détecter(surf, cat);
               if (pts.Count > 0)
               {
                  trouvé = true;
                  if (pts[0] == robot.Position)
                  {
                     char c = surf[pts[0]].Symbole;
                     lock (collectés)
                        if (collectés.ContainsKey(c))
                           collectés[c]++;
                        else
                           collectés.Add(c, 1);
                     var pos = robot.Position;
                     messagerie.Ajouter
                     (
                        robot.Couleur,
                        $"Déchet collecté à la position {pos}"
                     );
                     surf.Retirer(pos);
                  }
                  else
                  {
                     messagerie.Ajouter
                     (
                        robot.Couleur,
                        $"Trouvé {pts.Count} déchet(s)",
                        $"Déplacement vers {pts[0]}"
                     );
                     robot.DéplacerVers(pts[0]);
                     robot.RéinitialiserPuissance();
                  }
                  string s = "Collectés : ";
                  lock (collectés)
                  {
                     foreach (var (sym, n) in collectés)
                        s += $"{sym} x {n}; ";
                     information.Ajouter(ConsoleColor.White, s, "Pressez une touche pour terminer");
                  }
               }
               else
               {
                  robot.AugmenterPuissance();
               }
               Thread.Sleep(500);
            }
            while (!trouvé);
            robot.RéinitialiserPuissance();
         }
      });
   }
   return cueilleurs;
}

class RobotInfo
{
   public Robot? robot;
   public int noPort;
   public string nom;
   public ConsoleColor couleur;
   public Catégorie catégorie;
   public RobotInfo(Robot? robot, int noPort, string nom,
                    ConsoleColor couleur, Catégorie catégorie)
   {
      this.robot = robot;
      this.noPort = noPort;
      this.nom = nom;
      this.couleur = couleur;
      this.catégorie = catégorie;
   }
   public void Deconstruct(out Robot? robot, out int noPort,
                           out string nom, out ConsoleColor couleur,
                           out Catégorie catégorie)
   {
      robot = this.robot;
      noPort = this.noPort;
      nom = this.nom;
      couleur = this.couleur;
      catégorie = this.catégorie;
   }
}

class SurfacePleineException : Exception;

// ...
RobotInfo[] robotsInfo =
{
   new(null, 0, "Wallyd", ConsoleColor.Magenta, Catégorie.Métal),
   new(null, 1, "Bart", ConsoleColor.Blue, Catégorie.Plastique),
   new(null, 2, "Charles", ConsoleColor.Yellow, Catégorie.Organique),
   new(null, 3, "Lisa", ConsoleColor.Green, Catégorie.Nucléaire)
};

(char sym, Catégorie cat)[] symCatégorie =
{
    ('%', Catégorie.Métal),
    ('*', Catégorie.Plastique),
    ('&', Catégorie.Plastique),
    ('/', Catégorie.Organique),
    ('?', Catégorie.Nucléaire),
    ('*', Catégorie.Recyclable),
};
foreach (var symCat in symCatégorie)
   Catalogue.Get.Associer(symCat.sym, symCat.cat);

// préparer la surface d'affichage
const int HAUTEUR = 20,
          LARGEUR = 40;
Surface surf = new(HAUTEUR, LARGEUR);
// préparer le cadre de la surface
Cadre cadre = new(HAUTEUR, LARGEUR, ConsoleColor.Cyan);
// préparer la zone de messagerie
Messagerie messagerie = new(new(LARGEUR, 0), HAUTEUR);
// préparer la zone d'informations
Messagerie information = new(new(0, HAUTEUR), 2);

Random dé = new();
List<(Robot r, Catégorie c)> robots =
   CréerRobots(robotsInfo, dé, surf, cadre.Exclure);

// placer les déchets sur la surface
const int NB_DÉCHETS = 10;
List<Déchet> déchets =
   CréerPollution(symCatégorie, dé, NB_DÉCHETS, surf, cadre.Exclure);
surf.Ajouter(déchets.ToArray());

CanalComm<InfoCanalComm> canal = new(robotsInfo.Length);
PipelineAffichage pipe = new(surf, cadre, canal);

CancellationTokenSource cts0 = new();
CancellationTokenSource cts1 = new();

Task collectes =  Task.WhenAny
(
   ExécuterCollecteAsync
   (
      robotsInfo, surf, canal, messagerie, information, cts0.Token, cts1
   ), ArrêterAsync(cts0)
);

while (!cts1.Token.IsCancellationRequested)
{
   pipe.Rafraichir();
   messagerie.Afficher();
   information.Afficher();
}
pipe.Rafraichir();
messagerie.Afficher();
information.Afficher();

// Ici la méthode ExécuterCollecteAsync

// Ici la méthode ArrêterAsync


static List<(Robot robot, Catégorie cat)>
   CréerRobots(RobotInfo[] robotsInfo, Random dé, Surface surf, Func<Point2D, bool> exclure)   
{
   List<(Robot r, Catégorie c)> robots = new();
   // Trouver les cases libres
   var libres = surf.TrouverSi(exclure, c => c == default || c == ' ');
   for (int r = 0; r < robotsInfo.Length; r++)
   {
      RobotInfo info = robotsInfo[r];
      int n = dé.Next(libres.Count);
      Robot robot =
         CréerRobot(info.nom, libres[n], info.couleur, info.catégorie); 
      info.robot = robot;
      libres.RemoveAt(n);
   }
   return robots;
}
static Robot
   CréerRobot(string nom, Point2D pos, ConsoleColor couleur, Catégorie cat)
{
   Robot robot = new(nom, pos, couleur);
   robot.Équiper(new Détecteur(robot, 1, cat));
   return robot;
}
static List<Déchet>
   CréerPollution((char sym, Catégorie cat)[] symCatégorie, Random dé,
                  int nbDéchets,
                  Surface surf, Func<Point2D, bool> exclure)
{
   List<Déchet> déchets = new();
   var libres = surf.TrouverSi(exclure, c => c == default || c == ' ');
   if (libres.Count < nbDéchets * symCatégorie.Length)
      throw new SurfacePleineException();
   foreach (var symCat in symCatégorie)
   {
      for (int d = 0; d != nbDéchets; ++d)
      {
         int n = dé.Next(libres.Count);
         déchets.Add(new(symCat.sym, symCat.cat, libres[n]));
         libres.RemoveAt(n);
      }
   }
   return déchets;
}
class RobotInfo
{
   public Robot? robot;
   public int noPort;
   public string nom;
   public ConsoleColor couleur;
   public Catégorie catégorie;
   public RobotInfo(Robot? robot, int noPort, string nom,
                    ConsoleColor couleur, Catégorie catégorie)
   {
      this.robot = robot;
      this.noPort = noPort;
      this.nom = nom;
      this.couleur = couleur;
      this.catégorie = catégorie;
   }
   public void Deconstruct(out Robot? robot, out int noPort,
                           out string nom, out ConsoleColor couleur,
                           out Catégorie catégorie)
   {
      robot = this.robot;
      noPort = this.noPort;
      nom = this.nom;
      couleur = this.couleur;
      catégorie = this.catégorie;
   }
}
class SurfacePleineException : Exception { }
// ...