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

List<Orque> orques = new List<Orque>();
try
{
   for (string s = Console.ReadLine(); "" != s; s = Console.ReadLine())
   {
      orques.Add(new Orque(s));
      Console.WriteLine($"Orque créé : {orques[orques.Count - 1].Nom}");
   }
}
catch (NomInvalideException ex)
{
   Console.WriteLine(ex.Message);
}
if (Trier(ref orques, out int nbPermutations))
{
   Console.WriteLine("Les orques ont été entrés en ordre alphabétique");
}
else
{
   Console.WriteLine($"Trier les orques a nécessité {nbPermutations} permutations");
}
Console.Write("La tribu d'orques est :");
foreach (Orque orque in orques)
   Console.Write($" {orque.Nom}");

Console.WriteLine();

Soldat[] soldats = new Soldat[]
{
   new Orque("Bill"), new Troll("Grr"), new Kobold("Piarkkk")
};
foreach (Soldat s in soldats)
   s.Saluer(); // chaque Soldat s se présente à sa façon

////////////////////////

static void Permuter(ref Orque a, ref Orque b)
{
   Orque temp = a;
   a = b;
   b = temp;
}

static bool Trier(ref List<Orque> orques, out int nbPermutations)
{
   nbPermutations = 0;
   Orque[] tab = orques.ToArray();
   for (int i = 0; i < tab.Length - 1; ++i)
      for (int j = i + 1; j < tab.Length; ++j)
         if (tab[i].Nom.CompareTo(tab[j].Nom) > 0)
         {
            Permuter(ref tab[i], ref tab[j]);
            ++nbPermutations;
         }
   orques = tab.ToList();
   return nbPermutations == 0;
}

static class OutilsTexte
{
   static readonly char[] voyelles = new[] { 'a', 'e', 'i', 'o', 'u', 'y' };
   // static char[] Voyelles => new[] { 'a', 'e', 'i', 'o', 'u', 'y' };
   public static bool EstVoyelle(char c) =>
      voyelles.Contains(char.ToLower(c));

   public static int CompterVoyelles(string s)
   {
      int n = 0;
      foreach (char c in s)
         if (EstVoyelle(c))
            ++n;
      return n;
   }
}

class NomInvalideException : Exception { }

static class Algos
{
   public static bool EstEntreInclusif(int val, int min, int max) =>
      min <= val && val <= max;
}

class Soldat
{
   public virtual void Saluer()
   {
      Console.WriteLine("Je suis un soldat");
   }
}

class Orque : Soldat
{
   const int LG_NOM_MIN = 1,
             LG_NOM_MAX = 4;
   const int NB_VOYELLES_MAX = 1;
   static bool EstLongueurNomValide(string nom) =>
      Algos.EstEntreInclusif(nom.Length, LG_NOM_MIN, LG_NOM_MAX);
   static bool EstNomValide(string nom) =>
      EstLongueurNomValide(nom) &&
      OutilsTexte.CompterVoyelles(nom) <= NB_VOYELLES_MAX;

   string nom;
   public string Nom
   {
      get => nom;
      private init
      {
         nom = EstNomValide(value) ? value : throw new NomInvalideException();
         //if (!EstNomValide(value))
         //   throw new NomInvalideException();
         //nom = value;
      }
   }
   public Orque(string nom)
   {
      Nom = nom;
   }
   //public override void Saluer()
   //{
   //   Console.WriteLine($"MOI ORQUE {Nom}");
   //}
}

class Troll : Soldat
{
   public Troll(string nom)
   {
      // ...
   }
   public override void Saluer()
   {
      Console.WriteLine($"Moi TROLLLLL");
   }
}

class Kobold : Soldat
{
   public Kobold(string nom)
   {
      // ...
   }
   public override void Saluer()
   {
      Console.WriteLine($"Kobold, moi Kobold!");
   }
}

Image[] images = new Image[]
{
   new Jpeg(ConsoleColor.Red),
   new Png(ConsoleColor.Green),
   new Bmp(ConsoleColor.Blue)
};
// non, pas le droit!
//foreach (Image img in images)
//{
//   img.Dessiner();
//   img = ModifierPeutÊtre(img); // <-- ceci serait illégal
//   img.Dessiner();
//}

for (int i = 0; i != images.Length; ++i)
{
   images[i].Dessiner();
   images[i] = ModifierPeutÊtre(images[i]);
   images[i].Dessiner();
}


////////////////////////

static Image ModifierPeutÊtre(Image img)
{
   // 0 : créer un backup
   Image backup = img.Cloner();

   // 1 : modifier img
   img.Teinte = ConsoleColor.Cyan;

   // 2 : demander si on veut conserver les modifs
   Console.WriteLine("Conserver les modifs? ");
   // 2a : si oui, on retourne img
   // 2b : sinon, on retourne le backup
   if (Console.ReadKey(true).Key == ConsoleKey.O)
      return img;
   return backup;
}


// il existe une interface ICloneable, qui expose une méthode Clone
// ... mais ne l'utilisez pas :)
abstract class Image
{
   public ConsoleColor Teinte { get; set; }
   public Image(ConsoleColor teinte)
   {
      Teinte = teinte;
   }
   // Idiome NVI : non-virtual interface
   public void Dessiner()
   {
      ConsoleColor pre = Console.ForegroundColor;
      Console.ForegroundColor = Teinte;
      DessinerImpl(); // varie selon les enfants
      Console.ForegroundColor = pre;
   }
   protected abstract void DessinerImpl();
   public abstract Image Cloner();
}
class Jpeg : Image
{
   public Jpeg(ConsoleColor teinte) : base(teinte)
   {
   }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Jpeg {Teinte}");
   }
   protected Jpeg(Jpeg autre) : base(autre.Teinte)
   {
   }
   // spécialisation covariante
   public override Jpeg Cloner() => new Jpeg(this);
}
class Bmp : Image
{
   public Bmp(ConsoleColor teinte) : base(teinte)
   {
   }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Bmp {Teinte}");
   }
   protected Bmp(Bmp autre) : base(autre.Teinte)
   {
   }
   public override Bmp Cloner() => new Bmp(this);
}
class Png : Image
{
   public Png(ConsoleColor teinte) : base(teinte)
   {
   }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Png {Teinte}");
   }
   protected Png(Png autre) : base(autre.Teinte)
   {
   }
   public override Png Cloner() => new Png(this);
}

var ges = GesClavier.GetInstance();
var croc = new CroqueMort();
ges.Abonner(new Terminateur(croc));
ges.Abonner(new ÀDroite(ConsoleKey.D));
ges.Abonner(new EnHaut(ConsoleKey.W));
ges.Abonner(new ÀGauche(ConsoleKey.A));
ges.Abonner(new EnBas(ConsoleKey.S));
// ges.Abonner(new Afficheur());
while (!croc.Terminé())
   ges.Exécuter();

//
// Deux schémas de conception (Design Patterns)
// ce matin : Singleton, Observateur
//
interface IRéactionClavier
{
   void Réagir(ConsoleKeyInfo clé);
}
class Afficheur : IRéactionClavier
{
   public void Réagir(ConsoleKeyInfo clé)
   {
      Console.Write(clé.KeyChar);
   }
}
interface ISignalFin
{
   void Signaler();
   bool Terminé();
}
class CroqueMort : ISignalFin
{
   bool Fin { get; set; } = false;
   public void Signaler() => Fin = true;
   public bool Terminé() => Fin;
}
class Terminateur : IRéactionClavier
{
   ISignalFin Signaleur { get; init; }
   public Terminateur(ISignalFin p)
   {
      Signaleur = p;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == ConsoleKey.Q /*ConsoleKey.Escape*/)
         Signaleur.Signaler();
   }
}
class GesClavier
{
   static GesClavier singleton = null;
   List<IRéactionClavier> Abonnés { get; } = new();
   public void Abonner(IRéactionClavier p)
   {
      Abonnés.Add(p);
   }
   GesClavier()
   {
   }
   public static GesClavier GetInstance()
   {
      //
      // note : dangereux si multithreading
      //
      if (singleton == null)
         singleton = new GesClavier();
      return singleton;
   }
   public void Exécuter()
   {
      var clé = Console.ReadKey(true);
      foreach (var p in Abonnés)
         p.Réagir(clé);
   }
}
//
// diantre, beaucoup de répétition de code n'est-ce
// pas? mais on va dormir là-dessus pour le moment :)
//
class ÀDroite : IRéactionClavier
{
   ConsoleKey Touche { get; init; }
   public ÀDroite(ConsoleKey clé)
   {
      Touche = clé;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == Touche)
         Console.WriteLine("Est");
   }
}
class EnHaut : IRéactionClavier
{
   ConsoleKey Touche { get; init; }
   public EnHaut(ConsoleKey clé)
   {
      Touche = clé;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == Touche)
         Console.WriteLine("Nord");
   }
}
class ÀGauche : IRéactionClavier
{
   ConsoleKey Touche { get; init; }
   public ÀGauche(ConsoleKey clé)
   {
      Touche = clé;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == Touche)
         Console.WriteLine("Ouest");
   }
}
class EnBas : IRéactionClavier
{
   ConsoleKey Touche { get; init; }
   public EnBas(ConsoleKey clé)
   {
      Touche = clé;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == Touche)
         Console.WriteLine("Sud");
   }
}

var ges = GesClavier.GetInstance();
var croc = new CroqueMort();
// ges.Abonner(new Afficheur().Afficher);
ges.Abonner(new Terminateur(croc).Réagir);
ges.Abonner(new ÀDroite(ConsoleKey.D).Réagir);
ges.Abonner(new EnHaut(ConsoleKey.W).Réagir);
ges.Abonner(new ÀGauche(ConsoleKey.A).Réagir);
ges.Abonner(new EnBas(ConsoleKey.S).Réagir);
// ges.Abonner(new Afficheur());
while (!croc.Terminé())
   ges.Exécuter();


// Deux schémas de conception (Design Patterns)
// ce matin : Singleton, Observateur
//interface IRéactionClavier
//{
//   void Réagir(ConsoleKeyInfo clé);
//}
delegate void RéactionClavier(ConsoleKeyInfo clé);
class Afficheur // : IRéactionClavier
{
   public void Afficher(ConsoleKeyInfo clé) // note: nom :)
   {
      Console.Write(clé.KeyChar);
   }
}
interface ISignalFin
{
   void Signaler();
   bool Terminé();
}
class CroqueMort : ISignalFin
{
   bool Fin { get; set; } = false;
   public void Signaler() => Fin = true;
   public bool Terminé() => Fin;
}
class Terminateur // : IRéactionClavier
{
   ISignalFin Signaleur { get; init; }
   public Terminateur(ISignalFin p)
   {
      Signaleur = p;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == ConsoleKey.Q /*ConsoleKey.Escape*/)
         Signaleur.Signaler();
   }
}
class GesClavier
{
   static GesClavier singleton = null;
   List<RéactionClavier> Abonnés { get; } = new();
   public void Abonner(RéactionClavier p)
   {
      Abonnés.Add(p);
   }
   GesClavier()
   {
   }
   public static GesClavier GetInstance()
   {
      // note : dangereux si multithreading
      if (singleton == null)
         singleton = new GesClavier();
      return singleton;
   }
   public void Exécuter()
   {
      var clé = Console.ReadKey(true);
      foreach (var réac in Abonnés)
         réac(clé);
   }
}
// diantre, beaucoup de répétition de code n'est-ce
// pas? mais on va dormir là-dessus pour le moment :)
class ÀDroite // : IRéactionClavier
{
   ConsoleKey Touche { get; init; }
   public ÀDroite(ConsoleKey clé)
   {
      Touche = clé;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == Touche)
         Console.WriteLine("Est");
   }
}
class EnHaut // : IRéactionClavier
{
   ConsoleKey Touche { get; init; }
   public EnHaut(ConsoleKey clé)
   {
      Touche = clé;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == Touche)
         Console.WriteLine("Nord");
   }
}
class ÀGauche // : IRéactionClavier
{
   ConsoleKey Touche { get; init; }
   public ÀGauche(ConsoleKey clé)
   {
      Touche = clé;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == Touche)
         Console.WriteLine("Ouest");
   }
}
class EnBas // : IRéactionClavier
{
   ConsoleKey Touche { get; init; }
   public EnBas(ConsoleKey clé)
   {
      Touche = clé;
   }
   public void Réagir(ConsoleKeyInfo clé)
   {
      if (clé.Key == Touche)
         Console.WriteLine("Sud");
   }
}

const int N = 1_000_000;
var (r0,dt0) = Test(() =>
{
   int n = 0;
   var th0 = new Thread(() =>
   {
      for (int i = 0; i != N; ++i)
         ++n;
   });
   var th1 = new Thread(() =>
   {
      for (int i = 0; i != N; ++i)
         ++n;
   });
   th0.Start();
   th1.Start();
   th1.Join();
   th0.Join();
   return n;
});
var (r1, dt1) = Test(() =>
{
   int n = 0;
   var mutex = new object();
   var th0 = new Thread(() =>
   {
      for (int i = 0; i != N; ++i)
         lock (mutex)
         {
            ++n;
         }
   });
   var th1 = new Thread(() =>
   {
      for (int i = 0; i != N; ++i)
         lock (mutex)
         {
            ++n;
         }
   });
   th0.Start();
   th1.Start();
   th1.Join();
   th0.Join();
   return n;
});
var (r2, dt2) = Test(() =>
{
   int n = 0;
   var mutex = new object();
   var th0 = new Thread(() =>
   {
      int m = 0;
      for (int i = 0; i != N; ++i)
         ++m;
      lock (mutex)
      {
         n += m;
      }
   });
   var th1 = new Thread(() =>
   {
      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;
});
Console.WriteLine($"Sans synchro : {r0} obtenu en {dt0} tics");
Console.WriteLine($"Avec synchro : {r1} obtenu en {dt1} tics");
Console.WriteLine($"Avec synchro : {r2} obtenu en {dt2} tics");

static (T,long) Test<T>(Func<T> f)
{
   var sw = new System.Diagnostics.Stopwatch();
   sw.Start();
   T res = f();
   sw.Stop();
   return (res, sw.ElapsedTicks);
}

const int N = 25_000;
var tab = CréerTableau(N * N);

var (r0, dt0) = Tester(() => CompterMT(1, tab));
Console.WriteLine($"1 fil  : compté {r0} impairs en {dt0} ms");
var (r1, dt1) = Tester(() => CompterMT(2, tab));
Console.WriteLine($"2 fils : compté {r1} impairs en {dt1} ms");
var (r2, dt2) = Tester(() => CompterMT(4, tab));
Console.WriteLine($"4 fils : compté {r2} impairs en {dt2} ms");
var (r3, dt3) = Tester(() => CompterMT(8, tab));
Console.WriteLine($"8 fils : compté {r3} impairs en {dt3} ms");

static short[] CréerTableau(int n)
{
   short[] tab = new short[n];
   for (int i = 0; i != tab.Length; ++i)
      tab[i] = (short)(i * 2 + 1);
   return tab;
}
static int CompterSi<T>(T[] tab, Func<T, bool> pred, int début, int fin) // début inclus, fin exclue
{
   int n = 0;
   for (int i = début; i != fin; ++i)
      if (pred(tab[i]))
         ++n;
   return n;
}
static (T rés, long dt) Tester<T>(Func<T> f)
{
   var sw = new Stopwatch();
   sw.Start();
   T rés = f();
   sw.Stop();
   return (rés, sw.ElapsedMilliseconds);
}
static int CompterMT(int nbThreads, short [] tab)
{
   int[] nbImpairs = new int[nbThreads]; // initialisé à 0 en C#
   int tailleBloc = tab.Length / nbThreads;
   Thread[] thrs = new Thread[nbThreads - 1];
   for(int i = 0; i != thrs.Length; ++i)
   {
      int index = i;
      int début = index * tailleBloc;
      int fin = début + tailleBloc;
      thrs[index] = new Thread(() =>
      {
         for (int j = début; j != fin; ++j)
            if (tab[j] % 2 != 0)
               ++nbImpairs[index];
      });
   }
   foreach (var th in thrs) th.Start();
   ////
   {
      int début = (nbThreads - 1) * tailleBloc;
      int fin = tab.Length;
      for (int j = début; j != fin; ++j)
         if (tab[j] % 2 != 0)
            ++nbImpairs[nbThreads - 1];
   }
   ////
   foreach (var th in thrs) th.Join();
   int somme = 0;
   foreach (int n in nbImpairs)
      somme += n;
   return somme;
}

const int N = 25_000;
var tab = CréerTableau(N * N);

for(int i = 1; i <= 16; ++i)
{
   var (r, dt) = Tester(() => CompterMT(i, tab));
   Console.WriteLine($"{i} fil(s)  : compté {r} impairs en {dt} ms");
}
    
static short[] CréerTableau(int n)
{
   short[] tab = new short[n];
   for (int i = 0; i != tab.Length; ++i)
      tab[i] = (short)(i * 2 + 1);
   return tab;
}
static int CompterSi<T>(T[] tab, Func<T, bool> pred, int début, int fin) // début inclus, fin exclue
{
   int n = 0;
   for (int i = début; i != fin; ++i)
      if (pred(tab[i]))
         ++n;
   return n;
}
static (T rés, long dt) Tester<T>(Func<T> f)
{
   var sw = new Stopwatch();
   sw.Start();
   T rés = f();
   sw.Stop();
   return (rés, sw.ElapsedMilliseconds);
}
static int CompterMT(int nbThreads, short [] tab)
{
   int[] nbImpairs = new int[nbThreads]; // initialisé à 0 en C#
   int tailleBloc = tab.Length / nbThreads;
   Thread[] thrs = new Thread[nbThreads - 1];
   for(int i = 0; i != thrs.Length; ++i)
   {
      int index = i;
      int début = index * tailleBloc;
      int fin = début + tailleBloc;
      thrs[index] = new Thread(() =>
      {
         int nb = 0;
         for (int j = début; j != fin; ++j)
            if (tab[j] % 2 != 0)
               nb++;
         nbImpairs[index] = nb;
      });
   }
   foreach (var th in thrs) th.Start();
   ////
   {
      int début = (nbThreads - 1) * tailleBloc;
      int fin = tab.Length;
      int nb = 0;
      for (int j = début; j != fin; ++j)
         if (tab[j] % 2 != 0)
            ++nb;
      nbImpairs[nbThreads - 1] = nb;
   }
   ////
   foreach (var th in thrs) th.Join();
   int somme = 0;
   foreach (int n in nbImpairs)
      somme += n;
   return somme;
}

using System;
using System.Threading;
using System.Diagnostics;

const int N = 25_000;
var tab = CréerTableau(N * N);
for(int i = 1; i <= 16; ++i)
{
 var (r0, dt0) = Tester(() => CompterSiMT(tab, n => n % 2 != 0, i));
 if(i < 10) // bof, mais je ne me souviens plus du code de formatage...
    Console.WriteLine($"Compté {r0} impairs avec  {i} fils en {dt0} ms");
 else
    Console.WriteLine($"Compté {r0} impairs avec {i} fils en {dt0} ms");
}
      
static short[] CréerTableau(int n)
{
   short[] tab = new short[n];
   for (int i = 0; i != tab.Length; ++i)
      tab[i] = (short)(i * 2 + 1);
   return tab;
}
static (T rés, long dt) Tester<T>(Func<T> f)
{
   var sw = new Stopwatch();
   sw.Start();
   T rés = f();
   sw.Stop();
   return (rés, sw.ElapsedMilliseconds);
}

static int CompterSiMT(short[] tab, Func<short, bool> pred, int nthrs)
{
   var thrs = new Thread[nthrs-1]; // initialisés à null en C#
   var nimpairs = new int[nthrs]; // initialisés à 0 en C#
   int tailleBloc = tab.Length / nthrs;

   for(int i = 0; i < thrs.Length; ++i)
   {
      int monIndice = i;
      int début = i * tailleBloc; // inclus
      int fin = (i + 1) * tailleBloc; // exclue
      thrs[i] = new Thread(() =>
      {
         int m = 0;
         for (; début != fin; ++début)
            if (pred(tab[début]))
               ++m;
         nimpairs[monIndice] = m;
         //for (; début != fin; ++début)
         //   if (pred(tab[début]))
         //      ++nimpairs[monIndice];
      });
   }
   foreach (var th in thrs)
      th.Start();
   {
      int début = (nthrs - 1) * tailleBloc; // inclus
      int fin = tab.Length; // exclue
      int m = 0;
      for (; début != fin; ++début)
         if (pred(tab[début]))
            ++m;
      nimpairs[nthrs - 1] = m;
      //for (; début != fin; ++début)
      //   if (pred(tab[début]))
      //      ++nimpairs[nthrs - 1];
   }
   foreach (var th in thrs)
      th.Join();
   int cumul = 0;
   foreach (int n in nimpairs)
      cumul += n;
   return cumul;
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.IO;
using System.Diagnostics;


var fini = new bool[3];
var zt = new ZoneTransit<(string, string)>[3]
{
   new(), new(), new()
};
     
var thrs = new Thread[]
{
   // lecteur
   new Thread(() =>
   {
      foreach(var nom in args)
         zt[0].Ajouter((LireFichier(nom), nom));
      fini[0] = true; // dès maintenant, je ne produis plus
   }),
   // majusculeur
   new Thread(() =>
   {
      while(!fini[0])
      {
         var lst = zt[0].Extraire();
         foreach(var (s, nom) in lst)
            zt[1].Ajouter(Majusculer(s, nom));
      }
      {
         var lst = zt[0].Extraire();
         foreach(var (s, nom) in lst)
            zt[1].Ajouter(Majusculer(s, nom));
      }
      fini[1] = true; // dès maintenant, je ne produis plus
   }),
   // censeur
   new Thread(() =>
   {
      while(!fini[1])
      {
         var lst = zt[1].Extraire();
         foreach(var (s, nom) in lst)
            zt[2].Ajouter(Censurer(s, nom));
      }
      {
         var lst = zt[1].Extraire();
         foreach(var (s, nom) in lst)
            zt[2].Ajouter(Censurer(s, nom));
      }
      fini[2] = true;
   }),
   // scripteur
   new Thread(() =>
   {
      while(!fini[2])
      {
         var lst = zt[2].Extraire();
         foreach(var (s, nom) in lst)
            Écrire(s, nom);
      }
      {
         var lst = zt[2].Extraire();
         foreach(var (s, nom) in lst)
            Écrire(s, nom);
      }
   })
};
foreach (var th in thrs) th.Start();
foreach (var th in thrs) th.Join();

static string LireFichier(string nom)
{
   using (var fich = new StreamReader(nom))
      return fich.ReadToEnd();
}
static (string, string) Majusculer(string s, string nom)
   => (s.ToUpper(), nom);
static (string,string) Censurer(string s, string nom)
{
   string résultat = "";
   int début = 0;
   string àCensurer = "IF";
   int pos = s.IndexOf(àCensurer, début);
   while(pos != -1)
   {
      résultat += s.Substring(début, pos - début);
      résultat += "[CENSURÉ]";
      début = pos + àCensurer.Length;
      pos = s.IndexOf(àCensurer, début);
   }
   résultat += s.Substring(début);
   return (résultat, nom);
}
static void Écrire(string s, string nom)
{
   using (var sw = new StreamWriter(nom + ".out"))
      sw.Write(s);
}

static class Algos
{
   public static void Permuter<T>(ref T a, ref T b)
   {
      T temp = a;
      a = b;
      b = temp;
   }
}
class ZoneTransit<T>
{
   object mutex = new object();
   List<T> data = new();
   public void Ajouter(T elem) // à rediscuter (API suspecte)
   {
      lock (mutex)
         data.Add(elem);
   }
   public List<T> Extraire()
   {
      List<T> lst = new();
      lock (mutex)
         Algos.Permuter(ref lst, ref data);
      return lst;
   }
}