Comment et où utiliser les énumérateurs

Un énumérateur est un objet qui permet de parcourir un conteneur ou une collection. Les énumérateurs peuvent être utilisés pour lire les données de la collection, mais ils ne peuvent pas être utilisés pour modifier la collection sous-jacente, alors que IEnumerable est une interface qui définit une méthode GetEnumerator qui renvoie une interface IEnumerator, ce qui, à son tour, permet un accès en lecture seule à une collection.

Aspose.Cells Les API fournissent un tas d’énumérateurs cependant, cet article traite principalement des trois types répertoriés ci-dessous.

1. Cells Recenseur
2. Énumérateur de lignes
3. Énumérateur de colonnes

Comment utiliser les énumérateurs

Cells Recenseur

Il existe différentes façons d’accéder à l’énumérateur Cells, et on peut utiliser l’une de ces méthodes en fonction des exigences de l’application. Voici les méthodes qui renvoient l’énumérateur de cellules.

1. Cells.GetEnumerator
2. Row.GetEnumerator
3. Range.GetEnumerator

Toutes les méthodes mentionnées ci-dessus retournent l’énumérateur qui permet de parcourir la collection de cellules qui ont été initialisées.

Lors du parcours des cellules, la collection ne doit pas être modifiée (opérations qui entraîneront l’instanciation d’un nouveau Cell ou la suppression d’un Cell existant). Sinon, l’énumérateur peut ne pas être en mesure de parcourir toutes les cellules correctement (certains éléments peuvent être parcourus à plusieurs reprises ou ignorés).

L’exemple de code suivant illustre l’implémentation de l’interface IEnumerator pour une collection Cells.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

// Load a file in an instance of Workbook
var book = new Workbook(dataDir + "sample.xlsx");

// Get the enumerator from Cells collection
IEnumerator cellEnumerator = book.Worksheets[0].Cells.GetEnumerator();
// Traverse cells in the collection
while (cellEnumerator.MoveNext())
{
    var cell = cellEnumerator.Current as Aspose.Cells.Cell;
    Console.WriteLine(cell.Name + " " + cell.Value);
}

// Get enumerator from an object of Row
IEnumerator rowEnumerator = book.Worksheets[0].Cells.Rows[0].GetEnumerator();
// Traverse cells in the given row
while (rowEnumerator.MoveNext())
{
    var cell = rowEnumerator.Current as Aspose.Cells.Cell;
    Console.WriteLine(cell.Name + " " + cell.Value);
}

// Get enumerator from an object of Range
IEnumerator rangeEnumerator = book.Worksheets[0].Cells.CreateRange("A1:B10").GetEnumerator();
// Traverse cells in the range
while (rangeEnumerator.MoveNext())
{
    var cell = rangeEnumerator.Current as Aspose.Cells.Cell;
    Console.WriteLine(cell.Name + " " + cell.Value);
}

Énumérateur de lignes

L’énumérateur de lignes est accessible lors de l’utilisation deRowCollection.GetEnumerator méthode. L’exemple de code suivant illustre l’implémentation de l’interface IEnumerator pourRowCollection.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// Load a file in an instance of Workbook
var book = new Workbook(dataDir + "sample.xlsx");
// Get the enumerator for RowCollection
IEnumerator rowsEnumerator = book.Worksheets[0].Cells.Rows.GetEnumerator();
// Traverse rows in the collection
while (rowsEnumerator.MoveNext())
{
    var row = rowsEnumerator.Current as Aspose.Cells.Row;
    Console.WriteLine(row.Index);
}

Énumérateur de colonnes

L’énumérateur de colonnes est accessible lors de l’utilisation deColumnCollection.GetEnumeratorColumnCollection.GetEnumerator méthode. L’exemple de code suivant illustre l’implémentation de l’interface IEnumerator pourColonneCollection.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// Load a file in an instance of Workbook
var book = new Workbook(dataDir + "sample.xlsx");
// Get the enumerator for ColumnsCollection
IEnumerator colsEnumerator = book.Worksheets[0].Cells.Columns.GetEnumerator();
// Traverse columns in the collection
while (colsEnumerator.MoveNext())
{
    var col = colsEnumerator.Current as Aspose.Cells.Column;
    Console.WriteLine(col.Index);
}

Où utiliser les énumérateurs

Afin de discuter des avantages de l’utilisation d’énumérateurs, prenons un exemple en temps réel.

Scénario

Une exigence de l’application est de parcourir toutes les cellules d’unFeuille de travailpour lire leurs valeurs. Il pourrait y avoir plusieurs façons de mettre en œuvre cet objectif. Quelques-uns sont illustrés ci-dessous.

Utilisation de la plage d’affichage

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// Load a file in an instance of Workbook
var book = new Workbook(dataDir + "sample.xlsx");
// Get Cells collection of first worksheet
var cells = book.Worksheets[0].Cells;

// Get the MaxDisplayRange
var displayRange = cells.MaxDisplayRange;

// Loop over all cells in the MaxDisplayRange
for (int row = displayRange.FirstRow; row < displayRange.RowCount; row++)
{
    for (int col = displayRange.FirstColumn; col < displayRange.ColumnCount; col++)
    {
        // Read the Cell value
        Console.WriteLine(displayRange[row, col].StringValue);
    }
}

Utilisation de MaxDataRow et MaxDataColumn

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// Load a file in an instance of Workbook
var book = new Workbook(dataDir + "sample.xlsx");
// Get Cells collection of first worksheet
var cells2 = book.Worksheets[0].Cells;
int maxDataRow = cells2.MaxDataRow;
int maxDataColumn = cells2.MaxDataColumn;

// Loop over all cells
for (int row = 0; row <= maxDataRow; row++)
{
    for (int col = 0; col <= maxDataColumn; col++)
    {
        // Read the Cell value
        var currentCell = cells2.CheckCell(row, col);
        if (currentCell != null)
        {
            Console.WriteLine(currentCell.StringValue);
        }
    }
}

Comme vous pouvez le constater, les deux approches mentionnées ci-dessus utilisent une logique plus ou moins similaire, c’est-à-dire ; boucle sur toutes les cellules de la collection pour lire les valeurs des cellules. Cela pourrait être problématique pour un certain nombre de raisons, comme indiqué ci-dessous.

1. API telles queMaxRow, MaxDataRow, MaxColonne, MaxDataColumn & MaxDisplayRangebesoin de temps supplémentaire pour rassembler les statistiques correspondantes. Dans le cas où la matrice de données (lignes x colonnes) est volumineuse, l’utilisation de ces API peut entraîner une baisse des performances.
2. Dans la plupart des cas, toutes les cellules d’une plage donnée ne sont pas instanciées. Dans de telles situations, vérifier chaque cellule de la matrice n’est pas aussi efficace que de vérifier uniquement les cellules initialisées.
3. L’accès à une cellule dans une boucle en tant que ligne Cells, colonne entraînera l’instanciation de tous les objets de cellule d’une plage, ce qui peut éventuellement provoquer OutOfMemoryException.

Conclusion

Sur la base des faits mentionnés ci-dessus, voici les scénarios possibles dans lesquels les enquêteurs doivent être utilisés.

1. Un accès en lecture seule à la collection de cellules est requis, c’est-à-dire ; l’exigence est d’inspecter uniquement les cellules.
2. Un grand nombre de cellules sont à traverser.
3. Seules les cellules/lignes/colonnes initialisées doivent être traversées.