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");

using GénérateurId;
using System;
using System.Collections.Generic;
//
//
//
static class 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();
   }
}
// ...

class Animal
{
   // ...
}
class Oiseau : Animal
{
   // ...
}
class Insecte : Animal
{
   // ...
}
class OiseauVolant : Oiseau
{
   public void Voler() {  /* ... */ }
   // ...
}
class OiseauNonVolant : Oiseau
{
   // ...
}
class InsecteVolant : Insecte
{
   public void Voler() {  /* ... */ }
   // ...
}
class InsecteNonVolant : Insecte
{
}

class Animal
{
   // ...
}
class Volant : Animal
{
   public void Voler() { /* ... */ } // virtual?
}
class NonVolant : Animal
{
   // ...
}
class OiseauVolant : Volant
{
   // ...
}
class OiseauNonVolant : NonVolant
{
   // ...
}
class InsecteVolant : Volant
{
   // ...
}
class InsecteNonVolant : NonVolant
{
   // ...
}

class Animal
{
    ...
}
class Oiseau : Animal
{
    ...
}
class Insecte : Animal
{
    ...
}
interface IVolant
{
   void Voler();
}

class OiseauVolant : Oiseau, IVolant
{
   public void Voler() { /* ... */ }
    ...
}
class OiseauNonVolant : Oiseau
{
    ...
}
class InsecteVolant : Insecte, IVolant
{
   public void Voler() { /* ... */ }
    ...
}
class InsecteNonVolant : Insecte
{
}

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; // note : ici, il y a une variable cachée
   //                                             // et pas seulement un calcul
   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 »
}

enum Lancer { Pile, Face }
class Cenne // pour jouer à pile ou face
{
   Random Dé { get; } = new(); // cool : crée un Random au début de la
                               // vie de l'objet et le conserve par la suite
   // Random Dé => new();     // NOOON! Créerait un Random à chaque get (quelle horreur!)
   public Lancer Jouer() => Dé.Next() % 2 == 0 ? Lancer.Pile : Lancer.Face;
}

// ...
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 System.Text.Json;
using System.Text.Json.Serialization;

string s = "";
using (StreamReader sr = new("../../../fichier.json"))
{
   for (string str = sr.ReadLine(); str != null; str = sr.ReadLine())
      s += $"{str}\n";
}
Caractères cars = JsonSerializer.Deserialize<Caractères>(s);
Console.WriteLine($"Nom : {cars.NomSurface}");
foreach (Caractère c in cars.Cars)
{
   ConsoleColor avant = Console.ForegroundColor;
   Console.ForegroundColor = c.Couleur;
   Console.WriteLine($"Symbole {c.Symbole}");
   Console.ForegroundColor= avant;
}


//
// classes représentant les types de données lus
//
class Caractère
{
   public char Symbole { get; set; }
   [JsonConverter(typeof(JsonStringEnumConverter))]
   public ConsoleColor Couleur { get; set; }
}
class Caractères
{
   public string NomSurface { get; set; }
   public List<Caractère> Cars { get; set; }
}

{
  "NomSurface": "Surf",
  "Cars": [
    {
      "Symbole": "$",
      "Couleur": "Red"
    },
    {
      "Symbole": "*",
      "Couleur": "Blue"
    }
  ]
}

// ...
   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;
      }
   }
`// ...

using System;
using System.Collections.Generic;

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

static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
static List<T> RotaterGauche<T>(List<T> src)
{
   List<T> dest = new(src);
   for(int i = 1; i < dest.Count; ++i)
      (dest[i-1], dest[i]) = (dest[i], dest[i-1]); // permuter
   return dest;
}

using System;
using System.Collections.Generic;

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

static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
static List<T> RotaterDroite<T>(List<T> src)
{
   List<T> dest = new(src);
   for(int i = dest.Count - 1; i > 0; --i)
      (dest[i-1], dest[i]) = (dest[i], dest[i-1]); // permuter
   return dest;
}

using System;
using System.Collections.Generic;

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

static void Test<T>(List<T> lst)
{
   Console.Write("Avant : "); Afficher(lst);
   Inverser(lst);
   Console.Write("Après : "); Afficher(lst);
}
static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
static void Inverser<T>(List<T> lst)
{
   int milieu = lst.Count / 2;
   for(int i = 0; i < milieu; ++i)
      (lst[i], lst[lst.Count - i - 1]) = (lst[lst.Count - i - 1], lst[i]);
}

using System;
using System.Collections.Generic;

Test(new List<int>(){ 2 });
Test(new List<int>(){});
Test(new List<int>(){ 2, 3 });
Test(new List<int>(){ 1, 2, 2, 1 });
Test(new List<int>(){ 1, 2, 3, 2, 1 });
Test(new List<int>(){ 1, 3, 3, 2, 1 });

static void Test<T>(List<T> lst) where T : IEquatable<T>
{
   Console.Write($"EstPalindrome : {EstPalindrome(lst)} pour la séquence : ");
   Afficher(lst);
}
static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
static bool EstPalindrome<T>(List<T> lst) where T : IEquatable<T>
{
   int milieu = lst.Count / 2;
   for(int i = 0; i < milieu; ++i)
      if(!lst[i].Equals(lst[lst.Count - i - 1]))
         return false;
   return true;
}

using System;
using System.Collections.Generic;

Test(new List<int>(){ 1, 2, 3, 4 });
Test(new List<int>(){ 2, 4, 6 });
Test(new List<int>(){ 1, 3, 5, 7, 9 });

static void Test(List<int> lst)
{
   Console.Write("Séquence : "); Afficher(lst);
   if(SontTous(lst, n => n % 2 == 0)) Console.WriteLine("Tous les éléments sont pairs");
   if(AuMoinsUn(lst, n => n % 2 == 0)) Console.WriteLine("Au moins un élément est pair");
   if(Aucun(lst, n => n % 2 == 0)) Console.WriteLine("Aucun élément n'est pair");
}
static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
// précondition : src n'est pas vide
static bool SontTous<T>(IEnumerable<T> src, Func<T, bool> pred)
{
   foreach(T e in src)
      if(!pred(e))
         return false;
   return true;
}
// précondition : src n'est pas vide
static bool AuMoinsUn<T>(IEnumerable<T> src, Func<T, bool> pred)
{
   foreach(T e in src)
      if(pred(e))
         return true;
   return false;
}
// précondition : src n'est pas vide
static bool Aucun<T>(IEnumerable<T> src, Func<T, bool> pred)
{
   foreach(T e in src)
      if(pred(e))
         return false;
   return true;
}

using System;
using System.Collections.Generic;

Test(new List<int>());
Test(new List<int>(){ 3 });
Test(new List<int>(){ 1, 2, 3, 4 });
Test(new List<int>(){ 2, 6, 4 });
Test(new List<int>(){ 1, 3, 5, 7, 9 });

static void Test<T>(List<T> lst) where T : IComparable<T>
{
   Console.Write(EstTrié(lst) ? "Séquence triée : " : "Séquence non triée : ");
   Afficher(lst);
}
static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
static bool EstTrié<T>(List<T> lst) where T : IComparable<T>
{
   for(int i = 1; i < lst.Count; ++i)
      if(lst[i-1].CompareTo(lst[i]) > 0)
         return false;
   return true;
}

using System;
using System.Collections.Generic;

Test(new List<int>());
Test(new List<int>(){ 3 });
Test(new List<int>(){ 1, 2, 3, 4 });
Test(new List<int>(){ 2, 6, 4 });
Test(new List<int>(){ 1, 3, 5, 7, 9 });

static void Test<T>(List<T> lst) where T : IComparable<T>
{
   Console.Write(EstTrié(lst, (a,b) => a.CompareTo(b)) ?
                 "Séquence triée : " : "Séquence non triée : ");
   Afficher(lst);
}
static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
static bool EstTrié<T>(List<T> lst, Func<T,T,int> crit)
{
   for(int i = 1; i < lst.Count; ++i)
      if(crit(lst[i-1], lst[i]) > 0)
         return false;
   return true;
}

using System;
using System.Collections.Generic;

List<int> a = new(){ 2,3,5,7,11 };
List<int> b = new(){ 1,2,3,4,5,6,7 };
Afficher(UnionEnsembliste(a, b));
Afficher(UnionEnsembliste(a, new List<int>()));
Afficher(UnionEnsembliste(new List<int>(), b));

static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
static List<T> UnionEnsembliste<T>(List<T> a, List<T> b) where T : IComparable<T>
{
   List<T> dest = new();
   int ia = 0, ib = 0;
   for(; ia < a.Count && ib < b.Count; )
   {
      T e;
      if(a[ia].CompareTo(b[ib]) < 0)
      {
         e = a[ia];
         ++ia;
      }
      else if(a[ia].CompareTo(b[ib]) > 0)
      {
         e = b[ib];
         ++ib;
      }
      else
      {
         e = a[ia]; // ou e = b[ib]; , au choix
         ++ia;
         ++ib;
      }
      if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(e) != 0)
         dest.Add(e);
   }
   // une seule des deux boucles fera du travail à ce stade
   for(; ia < a.Count; ++ia)
      if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(a[ia]) != 0)
         dest.Add(a[ia]);
   for(; ib < b.Count; ++ib)
      if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(b[ib]) != 0)
         dest.Add(b[ib]);
   return dest;
}

// ...
static List<T> UnionEnsembliste<T>(List<T> a, List<T> b) where T : IComparable<T>
{
   List<T> dest = new();
   int ia = 0, ib = 0;
   static void AjouterFin(List<T> dest, T elem)
   {
      if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(elem) != 0)
         dest.Add(elem);
   }
   for(; ia < a.Count && ib < b.Count; )
   {
      if(a[ia].CompareTo(b[ib]) < 0)
         AjouterFin(dest, a[ia++]);
      else if(a[ia].CompareTo(b[ib]) > 0)
         AjouterFin(dest, b[ib++]);
      else
      {
         AjouterFin(dest, a[ia]); // ou AjouterFin(dest, b[ib]);
         ++ia;
         ++ib;
      }
   }
   // une seule des deux boucles fera du travail à ce stade
   for(; ia < a.Count; ++ia)
      AjouterFin(dest, a[ia]);
   for(; ib < b.Count; ++ib)
      AjouterFin(dest, b[ib]);
   return dest;
}

using System;
using System.Collections.Generic;

List<int> a = new(){ 2,3,5,7,11 };
List<int> b = new(){ 1,2,3,4,5,6,7 };
Afficher(UnionEnsembliste(a, b));
Afficher(UnionEnsembliste(a, new List<int>()));
Afficher(UnionEnsembliste(new List<int>(), b));

static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
static List<T> UnionEnsembliste<T>(List<T> a, List<T> b)
   where T : IComparable<T>, IEquatable<T>
{
   List<T> dest = Concaténer(a, b); // voir S08
   dest.Sort();  
   return SupprimerDoublons(dest); // voir S08
}

using System;
using System.Collections.Generic;

List<int> a = new(){ 2,3,5,7,11 };
List<int> b = new(){ 1,2,3,4,5,6,7 };
Afficher(IntersectionEnsembliste(a, b));
Afficher(IntersectionEnsembliste(a, new List<int>()));
Afficher(IntersectionEnsembliste(new List<int>(), b));

static void Afficher<T>(IEnumerable<T> elems)
{
   foreach(T e in elems)
      Console.Write($"{e} ");
   Console.WriteLine();
}
// précondition : a est triée
// précondition : b est triée
static List<T> IntersectionEnsembliste<T>(List<T> a, List<T> b)
   where T : IComparable<T>
{
   List<T> dest = new();
   for(int ia = 0, ib = 0; ia != a.Count && ib != b.Count; )
   {
      int res = a[ia].CompareTo(b[ib]);
      if(res < 0)
         ++ia;
      else if (res > 0)
         ++ib;
      else if(dest.Count == 0 || dest[dest.Count - 1].CompareTo(a[ia]) != 0)
      {
         dest.Add(a[ia]); // ou b[ib]
         ++ia; ++ib;
      }
   }
   return dest;
}