420-KBK-LG – Veille technologique

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

foreach (int n in new Pairs(1, 10))
   Console.Write($"{n} "); // 2 4 6 8 10


class Pairs : IEnumerable<int>
{
   int Min { get; init; }
   int Max { get; init; }
   public Pairs(int min, int max)
   {
      Min = min;
      Max = max;
      // valider que Min <= Max si vous voulez
   }
   class ÉnumPairs : IEnumerator<int>
   {
      int Cur { get; set; }
      Pairs Source { get; init; }
      public ÉnumPairs(Pairs source)
      {
         Source = source;
         // en C# comme en Java, faut se placer avant le premier élément à parcourir
         Cur = Source.Min % 2 == 0 ? Source.Min - 2 : Source.Min - 1;
      }
      public bool MoveNext()
      {
         if (Cur + 2 > Source.Max) return false;
         Cur += 2;
         return true;
      }
      public int Current => Cur;
      object IEnumerator.Current => throw new NotImplementedException();
      // Vous devez aussi coder quelques trucs sans intérêt, que vous pouvez faire générer par Visual Studio
      public void Reset() { }
      public void Dispose() { }
   }
   // GetEnumerator doit retourner un IEnumerable capable de parcourir les éléments de la séquence
   public IEnumerator<int> GetEnumerator() => new ÉnumPairs(this);
   // Vous devez aussi coder un autre truc sans intérêt, que vous pouvez faire générer par Visual Studio
   System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() =>
      throw new NotImplementedException();
}

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

var lst = new Liste<string>();
lst.AjouterIntervalle(new []{ "J'aime", "mon", "prof" });
foreach (var s in lst)
   Console.Write($"{s} ");


class ListeVideException : Exception { }
class Liste<T> : IEnumerable<T>
{
   public IEnumerator<T> GetEnumerator() =>
      new Énumérateur(Tête);
   IEnumerator IEnumerable.GetEnumerator() =>
      new Énumérateur(Tête);
   // un énumérateur de C# / un itérateur de Java, modélise
   // une séquence à demi ouverte (debut, fin]
   class Énumérateur : IEnumerator<T>
   {
      Noeud Cur { get; set; }
      public Énumérateur(Noeud tête)
      {
         Cur = new (default);
         Cur.Succ = tête;
      }
      public bool MoveNext()
      {
         if (Cur.Succ == null)
            return false;
         Cur = Cur.Succ;
         return true;
      }
      public void Reset() => throw new NotImplementedException();
      public void Dispose() { }
      public T Current => Cur.Valeur;
      object IEnumerator.Current => Cur.Valeur;
   }
   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 void AjouterDébut(T val)
   {
      var noeud = new Noeud(val);
      if (EstVide)
         Tête = Queue = noeud;
      else
      {
         noeud.Succ = Tête;
         Tête = noeud;
      }
   }
   public void AjouterFin(T val)
   {
      Noeud noeud = new (val);
      if (EstVide)
         Tête = Queue = noeud;
      else
      {
         Queue.Succ = noeud;
         Queue = noeud;
      }
   }
   public void SupprimerDébut()
   {
      if (EstVide)
         throw new ListeVideException();
      Tête = Tête.Succ;
      if (Tête == null)
         Queue = null;
   }
   public T PeekDébut() =>
      EstVide? throw new ListeVideException(): Tête.Valeur;
   public T PeekFin()
   {
      if (EstVide)
         throw new ListeVideException();
      return Queue.Valeur;
   }
   //public static Liste<T> Dupliquer(Liste<T> src)
   //{
   //   Liste<T> dest = new();
    //   for (Noeud p = src.Tête; p != null; p = p.Succ)
   //      dest.AjouterFin(p.Valeur);
   //   return dest;
   //}
   public Liste<T> Dupliquer()
   {
      Liste<T> dest = new();
      for (Noeud p = Tête; p != null; p = p.Succ)
         dest.AjouterFin(p.Valeur);
      return dest;
   }
   public void AjouterIntervalle(IEnumerable<T> src)
   {
      foreach(T e in src)
         AjouterFin(e);
   }
}

string s = "mono allo\nch\nmono yo\nch\nmono coucou\nmono bye";

static int TrouverSi(string s, int depuis, Func<char, bool> pred)
{
   for (; depuis != s.Length && !pred(s[depuis]); ++depuis)
      ;
   return depuis;
}
static (Sorte, int) FabriquerBoiteGenre(string s, int cur = 0)
{
   int finPréfixe = TrouverSi(s, cur, c => c == ' ');
   string préfixe = s.Substring(cur, finPréfixe - cur);
   Console.WriteLine($"Préfixe trouvé : {préfixe}");
   switch(préfixe)
   {
      case "mono":
         {
            int finLigne = TrouverSi(s, finPréfixe, c => c == '\n');
            // le texte du monon est s.Substring(finPréfixe, finLigne - finPréfixe)
            return (Sorte.Mono, finLigne + 1);
         }
         break;
      case "ch":
         {
            int finLigne = TrouverSi(s, finPréfixe, c => c == '\n');
            var (b0, fin0) = FabriquerBoiteGenre(s, finLigne + 1);
            var (b1, fin1) = FabriquerBoiteGenre(s, fin0 + 1);
            return (Sorte.CH, fin1 + 1);
         }
         break;
      default:
         throw new Exception("bof");
   }
}

enum Sorte { Mono, CH } // etc.

Image p = new Bmp(ConsoleColor.DarkBlue);
p.Dessiner();
p = ModifierPeutÊtre(p);
p.Dessiner();
p = new Jpeg(ConsoleColor.Red);
p.Dessiner();
p = ModifierPeutÊtre(p);
p.Dessiner();


static Image ModifierPeutÊtre(Image p)
{
   // A) faire un backup de ce vers quoi p pointe
   Image backup = p.Cloner();

   // B) modifier l'image pointée par p
   p.Couleur = ConsoleColor.Cyan;
   // C) demander à l'usager s'il / si elle souhaite conserver les modifs7
   Console.Write("Nouvelle image : ");
   p.Dessiner();
   Console.Write("Conserver les modifs? (o / n) ");
   char c = char.Parse(Console.ReadLine());
   //    i) si oui, on retourne p
   //   ii) sinon, on retourne le backup
   return c == 'o' || c == 'O' ? p : backup;
}


abstract class Image
{
   public abstract Image Cloner();
   public ConsoleColor Couleur { get; set; }
   public void Dessiner() // Idiome NVI : non-virtual interface
   {
      ConsoleColor avant = Console.ForegroundColor;
      Console.ForegroundColor = Couleur;
      DessinerImpl();
      Console.ForegroundColor = avant;
   }
   protected abstract void DessinerImpl();
   protected Image(Image autre) : this(autre.Couleur)
   {
   }
   public Image(ConsoleColor couleur)
   {
      Couleur = couleur;
   }
}
class Bmp : Image
{
   public override Bmp Cloner() => new(this);
   protected Bmp(Bmp autre) : base(autre) { }
   public Bmp(ConsoleColor couleur) : base(couleur) { }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Bmp de couleur {Couleur}");
   }
}
class Png : Image
{
   public override Png Cloner() => new(this);
   protected Png(Png autre) : base(autre) { }
   public Png(ConsoleColor couleur) : base(couleur) { }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Png de couleur {Couleur}");
   }
}
class Jpeg : Image
{
   public override Jpeg Cloner() => new(this);
   protected Jpeg(Jpeg autre) : base(autre) { }
   public Jpeg(ConsoleColor couleur) : base(couleur) { }
   protected override void DessinerImpl()
   {
      Console.WriteLine($"Jpeg de couleur {Couleur}");
   }
}