Come e dove utilizzare gli enumeratori
Un enumeratore è un oggetto che offre la possibilità di attraversare un contenitore o una raccolta. Gli enumeratori possono essere utilizzati per leggere i dati nella raccolta, ma non possono essere utilizzati per modificare la raccolta sottostante, mentre IEnumerable è un’interfaccia che definisce un metodo GetEnumerator che restituisce un’interfaccia IEnumerator, questa, a sua volta, consente l’accesso in sola lettura a una collezione.
Aspose.Cells Le API forniscono una serie di enumeratori, tuttavia, questo articolo discute principalmente i tre tipi elencati di seguito.
- Cells Enumeratore
- Enumeratore di righe
- Enumeratore di colonne
Come usare gli enumeratori
Cells Enumeratore
Esistono vari modi per accedere all’enumeratore Cells e si può utilizzare uno qualsiasi di questi metodi in base ai requisiti dell’applicazione. Ecco i metodi che restituiscono l’enumeratore di celle.
Tutti i metodi sopra menzionati restituiscono l’enumeratore che consente di attraversare la raccolta di celle che sono state inizializzate.
Nell’esempio di codice seguente viene illustrata l’implementazione dell’interfaccia IEnumerator per una raccolta 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); | |
} |
Enumeratore di righe
È possibile accedere all’enumeratore di righe durante l’utilizzo diRowCollection.GetEnumerator metodo. Nell’esempio di codice seguente viene illustrata l’implementazione dell’interfaccia IEnumerator perRowCollection.
// 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); | |
} |
Enumeratore di colonne
È possibile accedere all’enumeratore di colonne durante l’utilizzo diColumnCollection.GetEnumerator metodo. Nell’esempio di codice seguente viene illustrata l’implementazione dell’interfaccia IEnumerator perRaccolta di colonne.
// 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); | |
} |
Dove usare gli enumeratori
Per discutere i vantaggi dell’utilizzo degli enumeratori, facciamo un esempio in tempo reale.
Scenario
Un requisito dell’applicazione è attraversare tutte le celle in un datoFoglio di lavoroper leggere i loro valori. Ci potrebbero essere diversi modi per implementare questo obiettivo. Alcuni sono dimostrati di seguito.
Utilizzo dell’intervallo di visualizzazione
// 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); | |
} | |
} |
Utilizzo di MaxDataRow e 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); | |
} | |
} | |
} |
Come puoi osservare, entrambi gli approcci sopra menzionati utilizzano una logica più o meno simile, ovvero; eseguire il ciclo su tutte le celle della raccolta per leggere i valori delle celle. Questo potrebbe essere problematico per una serie di motivi come discusso di seguito.
- API comeMaxRow, MaxDataRow, Colonna massima, MaxDataColumn & MaxDisplayRangerichiedono più tempo per raccogliere le statistiche corrispondenti. Nel caso in cui la matrice di dati (righe x colonne) sia grande, l’utilizzo di queste API potrebbe imporre una riduzione delle prestazioni.
- Nella maggior parte dei casi, non tutte le celle in un determinato intervallo vengono istanziate. In tali situazioni controllare ogni cella della matrice non è così efficiente rispetto a controllare solo le celle inizializzate.
- L’accesso a una cella in un ciclo come riga Cells, colonna causerà l’istanziazione di tutti gli oggetti cella in un intervallo, il che potrebbe eventualmente causare OutOfMemoryException.
Conclusione
Sulla base dei fatti sopra menzionati, i seguenti sono i possibili scenari in cui dovrebbero essere utilizzati gli enumeratori.
- È richiesto l’accesso in sola lettura della raccolta di celle, ovvero; il requisito è quello di ispezionare solo le celle.
- Un gran numero di celle deve essere attraversato.
- Solo celle/righe/colonne inizializzate da attraversare.