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

using System;
Point p0 = new(),
      p1 = new(1,1);
Console.WriteLine("Distance({0},{1}) == {2}", p0, p1, Distance(p0, p1));
// Note : nous sommes (implicitement) dans la classe Program, donc
// Distance est en fait Program.Distance
static double Distance(Point p0, Point p1) =>
   Math.Sqrt(Math.Pow(p0.X - p1.X, 2) + Math.Pow(p0.Y - p1.Y, 2)); // Notez «Math.» trois fois... et pourquoi?
class Point
{
    public double X { get; init; }
    public double Y { get; init; }
    public Point() : this(0, 0) {}
    public Point(double x, double y)
    {
       X = x;
       Y = y;
    }
}

using System;
using static System.Math;
Point p0 = new(),
      p1 = new(1,1);
Console.WriteLine("Distance({0},{1}) == {2}", p0, p1, Distance(p0, p1));
// Note : nous sommes (implicitement) dans la classe Program, donc
// Distance est en fait Program.Distance
static double Distance(Point p0, Point p1) =>
   Sqrt(Pow(p0.X - p1.X, 2) + Pow(p0.Y - p1.Y, 2)); // On va à l'essentiel!
class Point
{
    public double X { get; init; }
    public double Y { get; init; }
    public Point() : this(0, 0) {}
    public Point(double x, double y)
    {
       X = x;
       Y = y;
    }
}

using Arsenal;
FabriqueArmes fab = new ();
IArme p = fab.CréerArme(Arsenal.Gravité.violent);
p.Frapper();
p = fab.CréerArme(Arsenal.Gravité.délicat);
p.Frapper();

namespace Arsenal
{
   public interface IArme
   {
      void Frapper(); // rappel : les membres d'une interface sont implicitement publics
   }
   class Masse : IArme // note : par défaut, les membres d'un namespace sont internal
   {
      public void Frapper()
      {
         Console.WriteLine("POURRRRH");
      }
   }
   class Chainsaw : IArme
   {
      public void Frapper()
      {
         Console.WriteLine("FVRRRRRRRR!");
      }
   }
   public enum Gravité { violent, délicat }
   public class FabriqueArmes
   {
      public IArme CréerArme(Gravité grav) =>
         grav == Gravité.délicat ? new Masse() : new Chainsaw();
   }
}

// ... code de test (note : le namespace se nomme Consommateur)
using GénérateurId;
using static Consommateur.Tests;

var fab = new FabriqueGénérateurs();
Test(fab, "Séquentiel", "ID", TypeGénérateur.Séquentiel);
Test(fab, "Recycleur", "ID", TypeGénérateur.Recycleur);
Test(fab, "Aléatoire", "ID", TypeGénérateur.Aléatoire, 3);
Test(fab, "Partagé", "ID", TypeGénérateur.Partagé, 3);
Test(fab, "Recycleur", "ID", TypeGénérateur.Recycleur);
Test(fab, "Partagé", "ID", TypeGénérateur.Partagé);
foreach (var (clé, valeur) in fab.ObtenirStatistiques())
   Console.WriteLine($"{clé} a été instancié {valeur} fois");

// ... placer ce qui suit dans une classe «static» nommée Tests
public static void Test(FabriqueGénérateurs fab, string nom, string préfixe, TypeGénérateur type)
{
   IGénérateurId p = fab.Créer(type, préfixe);
   var lst = new List<Identifiant>();
   Console.Write($"{nom}, pige initiale :\n\t");
   for (int i = 0; i != 10; ++i)
   {
      lst.Add(p.Prendre());
      Console.Write($"{lst[lst.Count - 1]} ");
   }
   Console.WriteLine();
   foreach (var n in lst)
      p.Rendre(n);
   Console.Write($"{nom}, pige post-remise :\n\t");
   for (int i = 0; i != 10; ++i)
      Console.Write($"{p.Prendre()} ");
   Console.WriteLine();
}

public static void Test(FabriqueGénérateurs fab, string nom, string préfixe, TypeGénérateur type, int germe)
{
   IGénérateurId p = fab.Créer(type, préfixe, germe);
   var lst = new List<Identifiant>();
   Console.Write($"{nom}, pige initiale :\n\t");
   for (int i = 0; i != 10; ++i)
   {
      lst.Add(p.Prendre());
      Console.Write($"{lst[lst.Count - 1]} ");
   }
   Console.WriteLine();
   foreach (var n in lst)
      p.Rendre(n);
   Console.Write($"{nom}, pige post-remise :\n\t");
   for (int i = 0; i != 10; ++i)
      Console.Write($"{p.Prendre()} ");
   Console.WriteLine();
}
// ...

using System;
Carré c = new(3); // 3x3

class CôtéInvalideException : Exception;
class Carré
{
   public static int LongueurMax => 1 // note : pas « = »
   // on aurait aussi pu écrire :
   // public static int LongueurMax { get => 1; }
   // ... ou encore :
   // public static int LongueurMax { get; } = 1;
   public Carré(int côté, ConsoleColor couleur)
   {
      Côté = côté;
      Couleur = couleur;
   }
   public ConsoleColor Couleur // propriété de premier ordre sans validation
   {
      get; private init;
   }
   int côté;
   public int Côté // propriété de premier ordre avec validation
   {
      get => côté;
      private init
      {
         côté = value > 0 ? value : throw new CôtéInvalideException();
      }
   }
   public int Aire { get => Côté * Côté; } // propriété calculée, version « longue »
   public int Surface => 4 * Côté; // propriété calculée, version « courte »
}

// ...
IGénérateurId p = new FabriqueGénérateurs().Créer(TypeGénérateur.Séquentiel);
ushort val = p.Prendre().Valeur;
Console.WriteLine($"Premier identifiant pris : {val}"); // devrait être 0
try
{
   for(;;) // boucle infinie (« for ever »)
      val = p.Prendre().Valeur;
}
catch(BanqueVideException)
{
}
Console.WriteLine($"Dernier identifiant pris : {val}"); // devrait être 65535

// ...
IGénérateurId p = new FabriqueGénérateurs().Créer(TypeGénérateur.Aléatoire);
int n = 0;
ushort val = p.Prendre().Valeur;
++n;
try
{
   for(;; ++n) // boucle infinie (« for ever »)
      val = p.Prendre().Valeur;
}
catch(BanqueVideException)
{
}
Console.WriteLine($"Nombre d'identifiants pris : {n}"); // devrait être 65536

using TP01_Wallyd;
using TP01a_Wallyd_Affichage;

Console.ReadKey(true);

ConfigInfo config = Config.LireConfig("../../../config_tp1.json");

char symboleDéchet = config.CatégorieDéchet.Symbole;

// associer les couleurs connues au catalogue de couleurs
CatalogueCouleurs.Get.Associer(config.Robot.Symbole, config.Robot.Couleur);

// préparer la surface d'affichage
Surface surf = FabriqueSurface.Créer(config);

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

// positionner Wallyd
Robot wallyd = FabriqueSurface.CréerRobot(config.Robot, surf);

// tant qu'il reste des déchets à ramasser
while (surf.TrouverSi(c => c == symboleDéchet).Count > 0)
{
   bool trouvé = false;
   // Trouver et ramasser le déchet
   do
   {
      PipelineAffichage pipeline = new();
      // Ajouter une fonction de transformation au pipeLine
      pipeline.Ajouter(pipeline.Appliquer(surf.Cadre));

      // Appliquer le pipeline de transformation au mutable
      // (la surface avec son halo) l'afficher à la position pos(0,0)
      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]}"
            );
            wallyd.DéplacerVers(pts[0], surf);
         }
      }
      else
      {
         wallyd.AugmenterPuissance();
         messagerie.Effacer();
      }
      Thread.Sleep(25);
   }
   while (!trouvé);
   wallyd.RéinitialiserPuissance();
}
//
// dernier affichage une fois les déchets collectés
//
{
   PipelineAffichage pipeline = new();
   pipeline.Ajouter(pipeline.Appliquer(surf.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;
}

using System;
using System.Collections.Generic;

List<int> lst = new(){};
Inverser(lst);
Afficher(lst);
lst = new(){ 1 };
Inverser(lst);
Afficher(lst);
lst = new(){ 1,2,3 };
Inverser(lst);
Afficher(lst);
lst = new(){ 1,2,3,4 };
Inverser(lst);
Afficher(lst);

static void Inverser<T>(List<T> lst)
{
   int mid = lst.Count / 2;
   for(int i = 0; i < mid; ++i)
      (lst[i], lst[lst.Count - i - 1]) = (lst[lst.Count - i - 1], lst[i]);
}
static void Afficher<T>(List<T> lst)
{
   foreach(T e in lst) Console.Write($"{e} ");
   Console.WriteLine();
}

static void Inverser<T>(List<T> lst)
{
   for(int gauche = 0, droite = lst.Count - 1; gauche < droite; ++gauche, --droite)
      (lst[gauche], lst[droite]) = (lst[droite], lst[gauche]);
}

static bool EstPalindrome<T>(List<T> lst) where T : IEquatable<T>
{
   int mid = lst.Count / 2;
   for(int i = 0; i < mid; ++i)
      if(!lst[i].Equals(lst[lst.Count - i - 1]))
         return false;
   return true;
}

static bool EstPalindrome<T>(List<T> lst) where T : IEquatable<T>
{
   for(int gauche = 0, droite = lst.Count - 1; gauche < droite; ++gauche, --droite)
      if(!lst[gauche].Equals(lst[droite]))
         return false;
   return true;
}

static bool SontTous<T>(List<T> lst, Func<T, bool> pred)
{
   foreach(T e in lst)
      if(!pred(e))
         return false;
   return true;
}

static bool AuMoinsUn<T>(List<T> lst, Func<T, bool> pred)
{
   foreach(T e in lst)
      if(pred(e))
         return true;
   return false;
}

static bool AuMoinsUn<T>(List<T> lst, Func<T, bool> pred) => !SontTous(lst, e => !pred(e));

static bool Aucun<T>(List<T> lst, Func<T, bool> pred)
{
   foreach(T e in lst)
      if(pred(e))
         return true;
   return false;
}

static bool Aucun<T>(List<T> lst, Func<T, bool> pred) => !AuMoinsUn(lst, pred);

static bool EstTrié<T>(List<T> lst) where T : IComparable<T>
{
   if(lst.Count == 0) return true;
   for(int i = 1; i < lst.Count; ++i)
      if(lst[i - 1].CompareTo(lst[i]) > 0)
         return false;
   return true;
}

static bool EstTrié<T>(List<T> lst, Func<T,T,int> comp)
{
   if(lst.Count == 0) return true;
   for(int i = 1; i < lst.Count; ++i)
      if(comp(lst[i - 1], lst[i]) > 0)
         return false;
   return true;
}

static List<T> UnionEnsembliste<T>(List<T> a, List<T> b) where T : IComparable<T>
{
   List<T> dest = new();
   int ia = 0, ib = 0;
   while(ia != a.Count && ib != b.Count)
   {
      if(a[ia].CompareTo(b[ib]) < 0)
      {
         if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(a[ia]) != 0)
            dest.Add(a[ia]);
         ++ia;
      }
      else
      {
        if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(b[ib]) != 0)
           dest.Add(b[ib]);
        ++ib;
      }
   }
   // on a épuisé l'une des deux List
   if(ia == a.Count) // reste b
   {
      for(; ib != b.Count; ++ib)
         if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(b[ib]) != 0)
            dest.Add(b[ib]);
   }
   else // reste a
   {
      for(; ia != a.Count; ++ia)
         if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(a[ia]) != 0)
            dest.Add(a[ia]);
   }
   return dest;
}

static List<T> UnionEnsembliste<T>(List<T> a, List<T> b) where T : IComparable<T>
{
   static void AjouterProchain(ref int i, List<T> src, List<T> dest) // oui, fonction locale :)
   {
      if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(src[i]) != 0)
         dest.Add(src[i]);
      ++i;
   }
   List<T> dest = new();
   int ia = 0, ib = 0;
   while(ia != a.Count && ib != b.Count)
      if(a[ia].CompareTo(b[ib]) < 0)
         AjouterProchain(ref ia, a, dest);
      else
         AjouterProchain(ref ib, b, dest);
   // on a épuisé l'une des deux List
   var(i, src) = ia == a.Count? (ib, b) : (ia, a);
   for(; i != src.Count; ++i)
      if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(src[i]) != 0)
         dest.Add(src[i]);
   return dest;
}

static List<T> UnionEnsembliste<T>(List<T> a, List<T> b) where T : IComparable<T>
{
   static void AjouterProchain(ref int i, List<T> src, List<T> dest) // oui, fonction locale :)
   {
      if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(src[i]) != 0)
         dest.Add(src[i]);
      ++i;
   }
   List<T> dest = new();
   int ia = 0, ib = 0;
   while(ia != a.Count && ib != b.Count)
      if(a[ia].CompareTo(b[ib]) < 0)
         AjouterProchain(ref ia, a, dest);
      else
         AjouterProchain(ref ib, b, dest);
   // on a épuisé l'une des deux List
   var(i, src) = ia == a.Count? (ib, b) : (ia, a);
   while(i != src.Count)
      AjouterProchain(ref i, src, dest);
   return dest;
}

static List<T> UnionEnsembliste<T>(List<T> a, List<T> b) where T : IComparable<T>
{
   static void AjouterProchain(ref int i, List src, List dest) // oui, fonction locale :)
   {
      dest.Add(src[i]);
      ++i;
   }
   List<T> dest = new();
   int ia = 0, ib = 0;
   while(ia != a.Count && ib != b.Count)
      if(a[ia].CompareTo(b[ib]) < 0)
         AjouterProchain(ref ia, a, dest);
      else
         AjouterProchain(ref ib, b, dest);
   // on a épuisé l'une des deux List
   var(i, src) = ia == a.Count? (ib, b) : (ia, a);
   while(i != src.Count)
      AjouterProchain(ref i, src, dest);
   return SupprimerDoublons(dest);
}

static List<T> IntersectionEnsembliste<T>(List<T> a, List<T> b) where T : IComparable<T>
{
   List dest = new();
   int ia = 0, ib = 0;
   while(ia != a.Count && ib != b.Count)
   {
      if(a[ia].CompareTo(b[ib]) < 0)
         ++ia;
      else if(b[ib].CompareTo(a[ia]) < 0)
         ++ib;
      else // équivalents
      {
         dest.Add(a[ia]); // ou b[ib], au choix
         ++ia;
         ++ib;
      }
   }
   return dest;
}

// ...
   class ListeVideException : Exception;
   internal 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 int Count { get; private set; } = 0;
      public bool EstVide => Tête == null;
      // Complexité : O(1) (constante)
      public void AjouterDébut(T val)
      {
         Noeud p = new(val);
         if (EstVide)
            Queue = p;
         p.Succ = Tête;
         Tête = p;
         ++Count;
      }
      // Complexité : O(1) constante
      public void AjouterFin(T val)
      {
         if (EstVide)
            AjouterDébut(val);
         else
         {
            Noeud p = Queue;
            p.Succ = new(val);
            Queue = Queue.Succ;
            ++Count;
         }
      }
      // Complexité : O(1) (constante)
      public void SupprimerDébut()
      {
         if (EstVide)
            throw new ListeVideException();
         Tête = Tête.Succ;
         --Count;
         if (EstVide)
            Queue = null;
      }
      public T Premier => !EstVide ?
         Tête.Valeur : throw new ListeVideException();
      public T Dernier => !EstVide ?
         Queue.Valeur : throw new ListeVideException();
      // Complexité : O(n) (linéaire... Ouf!)
      public ListeSimple<T> Dupliquer()
      {
         ListeSimple<T> autre = new();
         for (Noeud p = Tête; p != null; p = p.Succ)
            autre.AjouterFin(p.Valeur);
         return autre;
      }

      public IEnumerator<T> GetEnumerator() =>
         new Énumérateur(this);
      IEnumerator IEnumerable.GetEnumerator() =>
         new Énumérateur(this);
      class Énumérateur : IEnumerator<T>
      {
         Noeud Cur { get; set; }
         public Énumérateur(ListeSimple<T> source)
         {
            Cur = new(default);
            Cur.Succ = source.Tête;
         }
         public bool MoveNext()
         {
            if (Cur.Succ == null)
               return false;
            Cur = Cur.Succ;
            return true;
         }
         public void Reset() { }
         public void Dispose() { }
         public T Current => Cur.Valeur;
         object IEnumerator.Current => Cur.Valeur;
      }
   }
// ...

// ...
   // List<T> « des pauvres »
   internal class Tableau<T> : IEnumerable<T>
   {
      T[] Vals { get; set; }
      public int Count { get; private set; } = 0;
      public int Capacity { get; private set; } = 0;
      public bool EstVide => Count == 0;
      public bool EstPlein => Count == Capacity;
      public Tableau()
      {
         Vals = new T[0];
      }
      public void Add(T val)
      {
         if (EstPlein)
            Croître();
         Vals[Count] = val;
         ++Count;
      }
      // rôle : accroître la capacité du Tableau
      private void Croître()
      {
         int nouvelleCapacité = Capacity != 0 ?
            Capacity * 2 : 8; // arbitraire
         T[] nouveauTab = new T[nouvelleCapacité];
         for(int i = 0; i != Count; ++i)
            nouveauTab[i] = Vals[i];
         Vals = nouveauTab;
         Capacity = nouvelleCapacité;
      }
      public IEnumerator<T> GetEnumerator() =>
         new Énumérateur(this);
      IEnumerator IEnumerable.GetEnumerator() =>
         new Énumérateur(this);
      class Énumérateur : IEnumerator<T>
      {
         public Énumérateur(Tableau<T> source)
         {
            Source = source;
         }
         Tableau<T> Source { get; init; }
         int Indice { get; set; } = -1;
         public bool MoveNext()
         {
            if (Indice == Source.Count - 1)
               return false;
            ++Indice;
            return true;
         }
         public void Reset() { }
         public void Dispose() { }
         public T Current => Source[Indice];
         object IEnumerator.Current => Source[Indice];
      }
      public T this[int indice]
      {
         get => Vals[indice];
         set => Vals[indice] = value;
      }
   }
`// ...

Dictionary<string, int> d0 = null,
                        d1 = null;
Thread[] fils = new Thread[]
{
   new(() => d0 = CompterOccurrencesPar(args, 0, args.Length / 2)),
   new(() => d1 = CompterOccurrencesPar(args, args.Length / 2, args.Length))
};
foreach (Thread fil in fils) fil.Start();
foreach (Thread fil in fils) fil.Join();
var occurrences = Fusionner(d0, d1);

var tab = occurrences.ToArray();
Console.WriteLine("ORDRE LEXICOGRAPHIQUE");
Array.Sort(tab, (p0, p1) => p0.Key.CompareTo(p1.Key));
foreach (var (mot, nb) in tab)
   Console.WriteLine($"{mot} apparaît {nb} fois");
Console.WriteLine(new string('-', 70));
Console.WriteLine("ORDRE DÉCROISSANT DE NB D'OCCURRENCES");
Array.Sort(tab, (p0, p1) => p1.Value.CompareTo(p0.Value));
foreach (var (mot, nb) in tab)
   Console.WriteLine($"{mot} apparaît {nb} fois");

Console.ReadLine();


static Dictionary<string, int>
   CompterOccurrencesPar(string[] fich, int début, int fin)
{
   DictionaryDictionary<string, int> occurrences = new();
   for (; début != fin; ++début)
   {
      string texte = LireFichier(fich[début]);
      var mots = Décomposer(texte);
      Dictionary<string, int> occ = CompterOccurrences(mots);
      occurrences = Fusionner(occurrences, occ);
   }
   return occurrences;
}

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

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

static string LireFichier(string nom)
{
   using (StreamReader sr = new(nom))
      return sr.ReadToEnd();
}

static List<string> Décomposer(string s)
{
   List<string> mots = new();
   string mot = "";
   bool dansMot = false;
   for (int i = 0; i != s.Length; ++i)
   {
      if (!dansMot)
      {
         if (!char.IsWhiteSpace(s[i]))
         {
            dansMot = true;
            mot += s[i];
         }
      }
      else
      {
         if (char.IsWhiteSpace(s[i]))
         {
            dansMot = false;
            mots.Add(mot);
            mot = "";
         }
         else
            mot += s[i];
      }
   }
   if (mot.Length != 0) // cas résiduel
      mots.Add(mot);
   return mots;
}

const int N = 1_000_000;
var (r0, dt0) = Test(SansSynchro);
var (r1, dt1) = Test(AvecSynchro);
var (r2, dt2) = Test(AvecSynchroMieux);
var (r3, dt3) = Test(AvecSynchroAllégé);
Console.WriteLine($"Sans synchro          : {r0} en {dt0} tics");
Console.WriteLine($"Avec synchro          : {r1} en {dt1} tics");
Console.WriteLine($"Avec synchro (mieux)  : {r2} en {dt2} tics");
Console.WriteLine($"Avec synchro (allégé) : {r3} en {dt3} tics");
static int SansSynchro()
{
   int n = 0;
   Thread th0 = new(() =>
   {
      for (int i = 0; i != N; ++i)
         ++n;
   });
   Thread th1 = new(() =>
   {
      for (int i = 0; i != N; ++i)
         ++n;
   });
   th0.Start(); th1.Start();
   th1.Join(); th0.Join();
   return n;
}
static int AvecSynchro()
{
   int n = 0;
   object mutex = new();
   Thread th0 = new(() =>
   {
      for (int i = 0; i != N; ++i)
         lock (mutex)
            ++n;
   });
   Thread th1 = new(() =>
   {
      for (int i = 0; i != N; ++i)
         lock (mutex)
            ++n;
   });
   th0.Start(); th1.Start();
   th1.Join(); th0.Join();
   return n;
}
static int AvecSynchroAllégé()
{
   int n = 0;
   object mutex = new();
   Thread th0 = new(() =>
   {
      for (int i = 0; i != N; ++i)
         Interlocked.Increment(ref n);
      //lock (mutex)
      //   ++n;
   });
   Thread th1 = new(() =>
   {
      for (int i = 0; i != N; ++i)
         Interlocked.Increment(ref n);
      //lock (mutex)
      //   ++n;
   });
   th0.Start(); th1.Start();
   th1.Join(); th0.Join();
   return n;
}
static int AvecSynchroMieux()
{
   int n = 0;
   object mutex = new();
   Thread th0 = new(() =>
   {
      int m = 0;
      for (int i = 0; i != N; ++i)
         ++m;
      lock (mutex)
         n += m;
   });
   Thread th1 = new(() =>
   {
      int m = 0;
      for (int i = 0; i != N; ++i)
         ++m;
      lock (mutex)
         n += m;
   });
   th0.Start(); th1.Start();
   th1.Join(); th0.Join();
   return n;
}
static (T, long) Test<T>(Func<T> f)
{
   System.Diagnostics.Stopwatch sw = new();
   sw.Start();
   T res = f();
   sw.Stop();
   return (res, sw.ElapsedTicks);
}

CancellationTokenSource source = new();
CancellationToken jeton = source.Token;
Thread lireTouche = new(() =>
{
   Console.ReadKey(true);
   source.Cancel(); // demande l'arrêt des travaux
});
lireTouche.Start();
while(!jeton.IsCancellationRequested) // constater demande d'arrêt
{
   Console.Write('.');
   Thread.Sleep(1000);
}
lireTouche.Join();

class Monitor<T>
{
   T Obj { get; init; }
   public Monitor(T obj)
   {
      Obj = obj;
   }
   public U Utiliser<U>(Func<T, U> f)
   {
      lock (this) return f(Obj);
   }
   public void Utiliser(Action<T> f)
   {
      lock (this) f(Obj);
   }
}

class ColorSwitcher
{
   public void Execute(Action f, ConsoleColor coul)
   {
      lock(this)
      {
         ConsoleColor avant = Console.ForegroundColor;
         Console.ForegroundColor = coul;
         f();
         Console.ForegroundColor = avant;
      }
   }
}

class RegroupementFils
{
   Thread[] Workers { get; init; }
   int fini = 0;
   Queue<Action> Tâches { get; } = new();
   CancellationTokenSource Src { get; } = new();
   bool Fini
   {
      get => Src.Token.IsCancellationRequested;
    }
   bool Prendre(out Action act)
   {
      lock(Tâches)
         if(Tâches.Count > 0)
         {
            act = Tâches.Dequeue();
            return true;
         }
      act = null;
      return false;
   }
   void Travailleur()
   {
      while (!Fini)
      {
         if (Prendre(out Action tâche))
            tâche();
      }
   }
   public void Ajouter(Action act)
   {
      lock(Tâches)
         Tâches.Enqueue(act);
   }
   public RegroupementFils(int n)
   {
      Workers = new Thread[n];
      for (int i = 0; i != n; ++i)
         Workers[i] = new(Travailleur);
      foreach (Thread th in Workers)
         th.Start();
   }
   public void Terminer()
   {
      Src.Cancel(); // Fini = true;
      foreach(Thread th in Workers)
         th.Join();
      // tâches résiduelles
      while (Prendre(out Action tâche))
         tâche();
   }
}

List<int> lst = new() { 2, 3, 5, 7, 11 };

//
// Certains algorithmes sont limités à des types primitifs
// dû aux limites de C# (p.ex.: Sum, Average)
//
// D'autres sont plus généraux
//

// équivalent de Algos.Cumuler(lst, (x,y) => x + y, 0);
Console.WriteLine(lst.Sum()); // 28
// équivalent de Algos.Cumuler(lst, (x,y) => x * y, 1);
Console.WriteLine(lst.Aggregate(1, (x, y) => x * y)); // 2310
// équivalent de Algos.CompterSi(lst, n => n % 2 == 0) == lst.Count;
Console.WriteLine(lst.All(n => n % 2 == 0) ? "Oui" : "Non"); // Non
// équivalent de Algos.TrouverSi(lst, n => n % 2 == 0) != -1;
Console.WriteLine(lst.Any(n => n % 2 == 0) ? "Oui" : "Non"); // Oui
// équivalent à (double) lst.Sum() / lst.Count
Console.WriteLine(lst.Average()); // 5,6
try
{
   Console.WriteLine(new List<int>().Average());
}
catch(InvalidOperationException) // illégal sur une séquence vide
{
   Console.WriteLine("Ouf"); // <-- ICI
}
// grouper les éléments en blocs de 3 éléments ou moins
foreach (var chunk in lst.Chunk(3))
{
   foreach (var e in chunk)
      Console.Write($"{e} ");
   Console.WriteLine();
}
// équivalent à Concaténer(lst, new int[]{ 1,2,3 });
lst = lst.Concat(new int[] { 1, 2, 3 }).ToList();
foreach (int n in lst)
   Console.Write($"{n} "); // 2 3 5 7 11 1 2 3
Console.WriteLine();
// nous n'avons pas codé celle-ci, mais elle est intéressante
// (note : ce qui suit est une preuve que le code est inefficace;
// on s'en reparle?)
lst = lst.Distinct().ToList();
foreach (int n in lst)
   Console.Write($"{n} "); // 2 3 5 7 11 1
Console.WriteLine();
// équivalent à Algos.FiltrerSi(lst, e => !new int[]{ 1,3 }.Contains(e));
foreach(int n in lst.Except(new int[] { 1, 3 }))
   Console.Write($"{n} "); // 2 5 7 11
Console.WriteLine();
// équivalent à Algos.Accumuler(lst, Math.Max, lst[0]);
Console.WriteLine(lst.Max()); // 11
// équivalent à Algos.Accumuler(lst, Math.Min, lst[0]);
Console.WriteLine(lst.Min()); // 1
// 
lst = lst.Order().ToList(); // trier en ordre croissant
foreach (int n in lst)
   Console.Write($"{n} "); // 1 2 3 5 7 11
Console.WriteLine();
// etc. (il y en a beaucoup, et on peut en ajouter!)