Question sur la modification de cet itérateur personnalisé

Question

J'ai le code ci-dessous, qui effectue une itération sur une liste basée sur un algorithme personnalisé:

 public static IEnumerable<TItem> 
MakeCustomIterator<TCollection, TCursor, TItem>(
this TCollection collection, // Extension method of the collection used (eg List<T>) 
TCursor cursor, // An array of ints which holds our progress 
Func<TCollection, TCursor, TItem> getCurrent, 
Func<TCursor, bool> isFinished, 
Func<TCursor, TCursor> advanceCursor) 
     { 
      while (!isFinished(cursor)) // While we haven't reached the end of the iteration...... 
      { 
       yield return getCurrent(collection, cursor); 
       cursor = advanceCursor(cursor); 

      } 

     } 


    var matrix = new List<List<double>> { 
    new List<double> { 1.0, 1.1, 1.2 }, 
     new List<double> { 2.0, 2.1, 2.2 }, 
     new List<double> { 3.0, 3.1, 3.2 } 
     }; 

    var iter = matrix.MakeCustomIterator(
    new int[] { 0, 0 }, 
    (coll, cur) => coll[cur[0]][cur[1]], 
    (cur) => cur[0] > 2 || cur[1] > 2, 
    (cur) => new int[] { cur[0] + 1, 
     cur[1] + 1 }); 



      foreach (var item in iter) 
      { 

      } 

Lorsque j'utilise ce code, il obtiendra 1,0 et 2,1 (diagonale ci-dessous, dans la liste suivante). Est-il possible d'aller de 1.0 à 1.1 dans le premier lien? Ou possible d'aller verticalement de 1.0 à 2.0?

Note: Cet extrait de code est de Accelerated C# 2008.

Merci

Answer 1

Vous avez juste besoin de changer l'idée de ce que « l'avancement » des moyens (potentiellement avec ce « fini » signifie). Par exemple, pour aller juste « vers le bas » vous pouvez utiliser:

var iter = matrix.MakeCustomIterator(
    new int[] { 0, 0 }, 
    (coll, cur) => coll[cur[0]][cur[1]], 
    (cur) => cur[0] > 2 || cur[1] > 2, 
    // Increase the row, but stay on the same column 
    (cur) => new int[] { cur[0] + 1, cur[1] }); 

aller « le long »:

var iter = matrix.MakeCustomIterator(
    new int[] { 0, 0 }, 
    (coll, cur) => coll[cur[0]][cur[1]], 
    (cur) => cur[0] > 2 || cur[1] > 2, 
    // Stay on the same row, but increase the column 
    (cur) => new int[] { cur[0], cur[1] + 1 }); 

Il serait plus délicat d'aller « et puis vers le bas », mais réalisable:

var iter = matrix.MakeCustomIterator(
    new int[] { 0, 0 }, 
    (coll, cur) => coll[cur[0]][cur[1]], 
    (cur) => cur[0] > 2, 
    // Stay on the same row if we can, otherwise move to next row 
    (cur) => cur[1] == 2 ? new int[] { cur[0] + 1, 0 } 
          : new int[] { cur[0], cur[1] + 1});