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

//
// code produit pour vous aider et pour amorcer une réflexion avec vous
//
using MonNamespace;
List<Orque> orques = new();
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 nie)
{
   Console.WriteLine(nie.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}");

//
//
//
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[] orq = orques.ToArray(); 
   for (int i = 0; i < orq.Length - 1; ++i)
      for (int j = i + 1; j < orq.Length; ++j)
         if (!(orq[i].Nom.CompareTo(orq[j].Nom) < 0)) // désordre
         {
            Permuter(ref orq[i], ref orq[j]);
            ++nbPermutations;
         }
   orques = orq.ToList();
   return nbPermutations == 0;
}

// using...
namespace MonNamespace
{
   static class Algos
   {
      static char [] voyelles = { 'a', 'e', 'i', 'o', 'u', 'y' };
      public static bool Contient(char [] tab, char c)
      {
         foreach (char ch in tab)
            if (ch == c)
               return true;
         return false;
      }
      public static bool EstVoyelle(char c) =>
         Contient(voyelles, char.ToLower(c));
      public static int CompterVoyelles(string s)
      {
         int n = 0;
         foreach (char c in s)
            if (EstVoyelle(c))
               ++n;
         return n;
      }
      public static bool EstEntreInclusif(int val, int min, int max) =>
         min <= val && val <= max;
   }
}

using static MonNamespace.Algos;
// ...
class NomInvalideException : Exception;

class Orque
{
   static bool EstNomValide(string nom) =>
      nom != null &&
      EstEntreInclusif(nom.Length, 1, 4) &&
      Algos.CompterVoyelles(nom) <= 1;

   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;
   }
}

// ...
class NomInvalideException : Exception { }
abstract class Soldat
{
   public string Nom { get; private init; }
   public Soldat(string nom)
   {
      Nom = nom;
   }
   public abstract void Saluer();
}

// ...
class Orque : Soldat
{
   const int LG_NOM_MIN = 1,
             LG_NOM_MAX = 4;
   static bool EstNomValide(string s) =>
      EstEntreInclusif(s.Length, LG_NOM_MIN, LG_NOM_MAX) &&
      CompterVoyelles(s) <= 1;
   static string ValiderNom(string s) =>
      EstNomValide(s) ? s : throw new NomInvalideException();
      public Orque(string nom)
         : base(ValiderNom(nom))
      {
      }
      public override void Saluer()
      {
         Console.WriteLine($"MOI {Nom.ToUpper()}, MOI PUE");
      }
   }
}

Image[] images = new Image[]
{
   new Jpeg(ConsoleColor.Magenta),
   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.Red;

   // 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 :) Pour des détails, voir :
// https://codeql.github.com/codeql-query-help/csharp/cs-class-implements-icloneable/
abstract class Image
{
   public ConsoleColor Teinte { get; set; }
   protected 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 (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 (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 (this);
}

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[] { ' ', '\t', '\r', '\n' }))
   if(s.Trim().Length > 0)
      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");

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
{
   List<IRéactionClavier> Abonnés { get; } = new();
   public void Abonner(IRéactionClavier p)
   {
      Abonnés.Add(p);
   }
   GesClavier() // note : privé
   {
   }
   public static GesClavier Get { get; } = new();
   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");
   }
}

GesClavier ges = GesClavier.Get;
SignalArrêt signal = new();
ges.Abonner(new Magie().Wow);
ges.Abonner(new Assassin(signal).Réagir);
ges.Abonner(new Afficheur().Réagir);
ges.Abonner(new Est().Réagir);
ges.Abonner(new Nord().Réagir);
ges.Abonner(new Ouest().Réagir);
ges.Abonner(new Sud().Réagir);
while (!signal.Valeur)
{
   ges.Exécuter();
}
class SignalArrêt
{
   public bool Valeur { get; set; } = false;
}
delegate void RéactionTouche(char c);
class Magie
{
   public void Wow(char c)
   {
      // ...
   }
}
class Assassin
{
   SignalArrêt Signal { get; init; }
   public Assassin(SignalArrêt signal)
   {
      Signal = signal;
   }
   public void Réagir(char c)
   {
      if (char.ToLower(c) == 'q')
         Signal.Valeur = true; //Environment.Exit(0);
   }
}
class Afficheur
{
   public void Réagir(char c)
   {
      Console.WriteLine(c);
   }
}
class Est
{
   public void Réagir(char c)
   {
      if (char.ToLower(c) == 'd')
         Console.WriteLine("Vers l'Est");
   }
}
class Nord
{
   public void Réagir(char c)
   {
      if (char.ToLower(c) == 'w')
         Console.WriteLine("Vers le Nord");
   }
}
class Ouest
{
   public void Réagir(char c)
   {
      if (char.ToLower(c) == 'a')
         Console.WriteLine("Vers l'Ouest");
   }
}
class Sud
{
   public void Réagir(char c)
   {
      if (char.ToLower(c) == 's')
         Console.WriteLine("Vers le Sud");
   }
}

class GesClavier
{
   List<RéactionTouche> Abonnés { get; } = new();
   public void Abonner(RéactionTouche /*IRéactionTouche*/ p)
   {
      Abonnés.Add(p);
   }
   public void Exécuter()
   {
      char c = Console.ReadKey(true).KeyChar;
      foreach (RéactionTouche f in Abonnés)
         f(c);
   }
   public static GesClavier Get { get; } = new();
   GesClavier() // note : privé
   {
   }
}

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;
}

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;
}