Comment et où utiliser les énumérateurs
Un énumérateur est un objet qui fournit la capacité de parcourir un conteneur ou une collection. Les énumérateurs peuvent être utilisés pour lire les données dans la collection, mais ils ne peuvent pas être utilisés pour modifier la collection sous-jacente, tandis que IEnumerable est une interface qui définit une méthode GetEnumerator qui renvoie une interface IEnumerator, ce qui permet un accès en lecture seule à une collection.
Les API Aspose.Cells fournissent une multitude d’énumérateurs, cependant, cet article traite principalement des trois types énumérés ci-dessous.
- Énumérateur de cellules
- Énumérateur de lignes
- Énumérateur de colonnes
Comment utiliser des énumérateurs
Énumérateur de cellules
Il existe diverses façons d’accéder à l’énumérateur de cellules, et l’on peut utiliser l’une de ces méthodes en fonction des besoins de l’application. Voici les méthodes qui renvoient l’énumérateur de cellules.
Toutes les méthodes mentionnées ci-dessus renvoient l’énumérateur qui permet de parcourir la collection de cellules qui ont été initialisées.
L’exemple de code suivant montre l’implémentation de l’interface IEnumerator pour une collection de cellules.
// 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); | |
} |
Itérateur de lignes
L’itérateur de lignes peut être accédé lors de l’utilisation de la méthode RowCollection.GetEnumerator. L’exemple de code suivant montre l’implémentation de l’interface IEnumerator pour RowCollection.
// 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); | |
} |
Itérateur de colonnes
L’itérateur de colonnes peut être accédé lors de l’utilisation de la méthode ColumnCollection.GetEnumerator. L’exemple de code suivant montre l’implémentation de l’interface IEnumerator pour ColumnCollection.
// 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 des énumérateurs, prenons un exemple en temps réel.
Scénario
Une exigence de l’application est de parcourir toutes les cellules dans un Worksheet donné pour lire leurs valeurs. Il pourrait y avoir plusieurs façons de mettre en œuvre cet objectif. Quelques exemples sont indiqué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 & 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 ci-dessus utilisent plus ou moins une logique similaire, c’est-à-dire parcourir toutes les cellules de la collection pour lire les valeurs des cellules. Cela pourrait poser problème pour un certain nombre de raisons, comme discuté ci-dessous.
- Les API telles que MaxRow, MaxDataRow, MaxColumn, MaxDataColumn & MaxDisplayRange nécessitent du temps supplémentaire pour rassembler les statistiques correspondantes. Dans le cas où la matrice de données (lignes x colonnes) est grande, l’utilisation de ces API pourrait entraîner une pénalité de performance.
- Dans la plupart des cas, toutes les cellules dans une plage donnée ne sont pas instanciées. Dans de telles situations, vérifier chaque cellule dans la matrice n’est pas aussi efficace que de vérifier uniquement les cellules initialisées.
- Accéder à une cellule dans une boucle en tant que Cells row, column entraînera l’instanciation de tous les objets de cellules dans une plage, ce qui pourrait finalement entraîner une OutOfMemoryException.
Conclusion
Sur la base des faits mentionnés ci-dessus, voici les scénarios possibles où les énumérateurs doivent être utilisés.
- Un accès en lecture seule de la collection de cellules est requis, c’est-à-dire; la nécessité est uniquement d’inspecter les cellules.
- Un grand nombre de cellules doit être parcouru.
- Seules les cellules/rangées/colonnes initialisées doivent être parcourues.