Wie und wo Enumeratoren verwendet werden

Ein Enumerator ist ein Objekt, das die Möglichkeit bietet, einen Container oder eine Sammlung zu durchlaufen. Enumeratoren können verwendet werden, um die Daten in der Sammlung zu lesen, aber sie können nicht verwendet werden, um die zugrunde liegende Sammlung zu ändern, während IEnumerable eine Schnittstelle ist, die eine Methode GetEnumerator definiert, die eine IEnumerator-Schnittstelle zurückgibt, die wiederum einen schreibgeschützten Zugriff auf ermöglicht eine Sammlung.

Aspose.Cells APIs bieten eine Reihe von Enumeratoren, dieser Artikel behandelt jedoch hauptsächlich die drei unten aufgeführten Typen.

1. Cells Zähler
2. Zeilen-Enumerator
3. Spalten-Enumerator

Verwendung von Enumeratoren

Cells Zähler

Es gibt verschiedene Möglichkeiten, auf den Cells-Enumerator zuzugreifen, und je nach Anwendungsanforderungen kann jede dieser Methoden verwendet werden. Hier sind die Methoden, die den Zellen-Enumerator zurückgeben.

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

Alle oben genannten Methoden geben den Enumerator zurück, der das Durchlaufen der Sammlung von initialisierten Zellen ermöglicht.

Beim Durchlaufen der Zellen sollte die Sammlung nicht geändert werden (Operationen, die dazu führen, dass ein neuer Cell instanziiert oder ein bestehender Cell gelöscht wird). Andernfalls kann der Enumerator möglicherweise nicht alle Zellen korrekt durchlaufen (einige Elemente werden möglicherweise wiederholt durchlaufen oder übersprungen).

Das folgende Codebeispiel veranschaulicht die Implementierung der IEnumerator-Schnittstelle für eine Cells-Auflistung.

// 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);
}

Zeilen-Enumerator

Auf den Rows Enumerator kann zugegriffen werden, während Sie die verwendenRowCollection.GetEnumerator Methode. Das folgende Codebeispiel veranschaulicht die Implementierung der IEnumerator-Schnittstelle fürRowCollection.

// 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);
}

Spalten-Enumerator

Auf den Columns Enumerator kann während der Verwendung von zugegriffen werdenColumnCollection.GetEnumerator Methode. Das folgende Codebeispiel veranschaulicht die Implementierung der IEnumerator-Schnittstelle fürColumnCollection.

// 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);
}

Wo Enumeratoren verwendet werden

Um die Vorteile der Verwendung von Enumeratoren zu erörtern, nehmen wir ein Echtzeitbeispiel.

Szenario

Eine Anwendungsanforderung besteht darin, alle Zellen in einem gegebenen zu durchlaufenArbeitsblattihre Werte zu lesen. Es könnte mehrere Möglichkeiten geben, dieses Ziel umzusetzen. Einige werden unten demonstriert.

Anzeigebereich verwenden

// 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);
    }
}

Verwenden von 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);
        }
    }
}

Wie Sie feststellen können, verwenden beide oben genannten Ansätze eine mehr oder weniger ähnliche Logik, das heißt; Schleife über alle Zellen in der Sammlung, um die Zellenwerte zu lesen. Dies könnte aus einer Reihe von Gründen problematisch sein, wie unten diskutiert wird.

1. APIs wie zMaxRow, MaxDataRow, MaxSpalte, MaxDataColumn & MaxDisplayRangeerfordern zusätzliche Zeit, um die entsprechenden Statistiken zu sammeln. Falls die Datenmatrix (Zeilen x Spalten) groß ist, kann die Verwendung dieser APIs zu Leistungseinbußen führen.
2. In den meisten Fällen werden nicht alle Zellen in einem bestimmten Bereich instanziiert. In solchen Situationen ist es nicht so effizient, jede Zelle in der Matrix zu prüfen, als nur die initialisierten Zellen zu prüfen.
3. Der Zugriff auf eine Zelle in einer Schleife als Cells Zeile, Spalte führt dazu, dass alle Zellobjekte in einem Bereich instanziiert werden, was schließlich OutOfMemoryException verursachen kann.

Fazit

Basierend auf den oben genannten Fakten sind die folgenden möglichen Szenarien, in denen Enumeratoren verwendet werden sollten.

1. Nur-Lese-Zugriff auf die Zellsammlung ist erforderlich, das heißt; Die Anforderung besteht darin, nur die Zellen zu inspizieren.
2. Eine große Anzahl von Zellen soll durchquert werden.
3. Nur initialisierte Zellen/Zeilen/Spalten werden durchlaufen.