Documentation – Loading and Managing Excel, OpenOffice, JSON, CSV, and HTML Files with Golang via C++

Gocpp: Load Specific Worksheets in a Workbook with Golang via C++

Mon, 01 Jan 0001 00:00:00 +0000

By default, Aspose.Cells loads the entire spreadsheet into memory. It is possible to load only specific sheets, which can improve performance and consume less memory. This approach is useful when working with a large workbook made up of many worksheets.

Here is the implementation of the CustomLoad class.

Gocpp: Stop conversion or loading using InterruptMonitor when it is taking too long with Golang via C++

Mon, 01 Jan 0001 00:00:00 +0000

Possible Usage Scenarios

Aspose.Cells allows you to stop the conversion of a Workbook to various formats like PDF, HTML, etc., using the InterruptMonitor object when it is taking too long. The conversion process is often both CPU‑ and memory‑intensive, and it is useful to halt it when resources are limited. You can use InterruptMonitor both for stopping conversion as well as for stopping the loading of huge workbooks. Please use the Workbook.InterruptMonitor property for stopping conversion and the LoadOptions.InterruptMonitor property for loading huge workbooks.

Stop conversion or loading using InterruptMonitor when it is taking too long

The following sample code explains the usage of the InterruptMonitor object. The code converts a quite large Excel file to PDF. It will take several seconds (i.e., more than 30 seconds) to get it converted because of these lines of code.

As you see, J1000000 is quite a far cell in the XLSX file. However, the WaitForWhileAndThenInterrupt() method interrupts the conversion after 10 seconds, and the program ends/terminates. Please use the following code to execute the sample code.

Sample Code

Gocpp: Get Warnings while Loading Excel File with Golang via C++

Mon, 01 Jan 0001 00:00:00 +0000

Possible Usage Scenarios

Sometimes the user tries to load a workbook that is somewhat corrupt but still loadable. In such cases, Aspose.Cells throws warnings while loading the workbook. You can catch these warnings by implementing the IWarningCallback interface and setting the LoadOptions.GetWarningCallback() property.

Get Warnings while Loading Excel File

The following sample code explains how to get warnings while loading an Excel file. The code loads the sample Excel file, which throws a DuplicateDefinedName warning on loading. This warning is then caught by the IWarningCallback.Warning() method, which prints the warning messages on the console. The code then saves the workbook as an output Excel file. If you open the sample Excel file in Microsoft Excel, it will also display this warning, as shown in the screenshot below. Please also check the console output of the code given below for better understanding.

Sample Code

Console Output

Here is the console output of the above code when executed with the provided sample Excel file.

Duplicate Defined Name Warning: Name:PRINT_AREA;ReferTo:Introduction!$D$16:$D$17

Duplicate Defined Name Warning: Name:PRINT_AREA;ReferTo:Panel!$B$228

Duplicate Defined Name Warning: Name:PRINT_AREA;ReferTo:'Queries '!$D$14:$D$16

Gocpp: Using LightCells API with Golang via C++

Mon, 01 Jan 0001 00:00:00 +0000

Sometimes you need to read and write large Microsoft Excel files with a huge list of data or content in the worksheet. The LightCells API is useful for creating huge Excel spreadsheets: with it, you need less memory and get better performance and efficiency.

Event‑Driven Architecture

Aspose.Cells provides the LightCells API, mainly designed to manipulate cell data one by one without building a complete data model block (using the Cell collection etc.) into memory. It works in an event‑driven mode.

To save workbooks, provide the cell content cell by cell when saving, and the component saves it to the output file directly.

When reading template files, the component parses every cell and provides its value one by one.

In both procedures, one Cell object is processed and then discarded; the Workbook object does not hold the collection. In this mode, therefore, memory is saved when importing and exporting Microsoft Excel files that have a large data set which would otherwise use a lot of memory.

Even though the LightCells API processes the cells in the same way for XLSX and XLS files (it does not actually load all cells in memory but processes one cell and then discards it), it saves memory more effectively for XLSX files than XLS files because of the different data models and structures of the two formats.

However, for XLS files, to save more memory, developers can specify a temporary location for saving temporary data generated during the Save process. Commonly, using LightCells API to save an XLSX file may save 50% or more memory compared with the common method; saving XLS may save about 20–40% memory.

Writing a Large Excel File

Aspose.Cells provides an interface, LightCellsDataProvider, that needs to be implemented in your program. The interface represents the data provider for saving large spreadsheet files in light‑weight mode.

When saving a workbook in this mode, StartSheet(int) is called for each worksheet in the workbook. For one sheet, if StartSheet(int) returns true, then all the data and properties of rows and cells of this sheet to be saved are provided by this implementation. Initially, NextRow() is called to get the next row index to be saved. If a valid row index is returned (the row index must be in ascending order for the rows to be saved), then a Row object representing this row is provided for the implementation to set its properties via StartRow(Row).

For one row, NextCell() is checked first. If a valid column index is returned (the column index must be in ascending order for all cells of one row to be saved), then a Cell object representing that cell is provided for the implementation to set its data and properties via StartCell(Cell). After the data of the cell is set, the cell is saved directly to the generated spreadsheet file and the next cell is checked and processed.

Writing a Large Excel File: Example

Please see the following sample code to see the working of the LightCells API. Add, remove, or update the code segments according to your needs.

The program creates a huge file with 10,000 (10000 × 30 matrix) records in a worksheet and fills them with dummy data. You can specify your own matrix by changing the rowsCount and colsCount variables in the Main() method.

Reading Large Excel Files

Aspose.Cells provides an interface, LightCellsDataHandler, that needs to be implemented in your program. The interface represents the data provider for reading large spreadsheet files in light‑weight mode.

When reading a workbook in this mode, StartSheet is called for each worksheet in the workbook. For a sheet, if StartSheet returns true, then all the data and properties of the cells in the rows and columns of the sheet are processed by the implementation of this interface. For each row, StartRow is called to determine whether it needs to be processed. If a row needs processing, its properties are read first and the developer can access them with ProcessRow. If the row’s cells also need processing, then ProcessRow should return true and StartCell is called for each existing cell in the row to determine whether the cell should be processed. If a cell needs processing, then ProcessCell is called to handle the cell by the implementation of this interface.

Reading Large Excel Files: Example

Please see the following sample code to see the working of the LightCells API. Add, remove, or update the code segments according to your needs.

The program reads a huge file with millions of records in a worksheet. It takes a little time to read each sheet in the workbook. The sample code reads the file and retrieves the total number of cells, the string count and the formula count in each worksheet.

Gocpp: Optimizing Memory Usage while Working with Big Files that Have Large Datasets with Golang via C++

Mon, 01 Jan 0001 00:00:00 +0000

When building a workbook with large data sets, or reading a big Microsoft Excel file, the total amount of RAM the process will take is always a concern. There are measures that can be adapted to cope with the challenge. Aspose.Cells provides some relevant options and API calls to lower, reduce, and optimize memory use. It can also help the process work more efficiently and run faster.

Use the MemorySetting.MemoryPreference option to optimize memory use for cell data and decrease the overall memory cost. When building a large data set for cells, it can save a certain amount of memory compared to using the default setting (MemorySetting.Normal).

Optimizing Memory

Reading Large Excel Files

The following example shows how to read a large Microsoft Excel file in optimized mode.

Writing Large Excel Files

The following example shows how to write a large dataset to a worksheet in an optimized mode.

Caution

The default option, MemorySetting.Normal, is applied for all versions. For some situations, such as building a workbook with a large data set for cells, the MemorySetting.MemoryPreference option may optimize memory use and decrease the memory cost for the application. However, this option may degrade performance in some special cases such as the following.

Accessing Cells Randomly and Repeatedly: The most efficient sequence for accessing the cells collection is cell by cell in one row, and then row by row. Especially, if you access rows/cells by the enumerator acquired from Cells, RowCollection and Row, performance is maximized with MemorySetting.MemoryPreference.
Inserting & Deleting Cells & Rows: Please note that if there are many insert/delete operations for cells/rows, the performance degradation will be notable for MemoryPreference mode compared to the Normal mode.
Operating on Different Cell Types: If most of the cells contain string values or formulas, the memory cost will be the same as Normal mode, but if there are many empty cells, or cell values are numeric, boolean, and so on, the MemorySetting.MemoryPreference option will give better performance.

Gocpp: Filter Objects while loading Workbook or Worksheet with Golang via C++

Mon, 01 Jan 0001 00:00:00 +0000

Possible Usage Scenarios

Please use the LoadOptions.GetLoadFilter() property while filtering data from the workbook. However, if you want to filter data from individual worksheets, you will have to override the LoadFilter.StartSheet method. Please provide an appropriate value from the LoadDataFilterOptions enumeration when creating or using a LoadFilter.

The LoadDataFilterOptions enumeration has the following possible values.

All
BookSettings
CellBlank
CellBool
CellData
CellError
CellNumeric
CellString
CellValue
Chart
ConditionalFormatting
DataValidation
DefinedNames
DocumentProperties
Formula
Hyperlinks
MergedArea
PivotTable
Settings
Shape
SheetData
SheetSettings
Structure
Style
Table
VBA
XmlMap

Filter Objects while loading Workbook

The following sample code illustrates how to filter charts from the workbook. Please check the sample Excel file used in this code and the output PDF generated by it. As you can see in the output PDF, all charts have been filtered out of the workbook.

Filter Objects while loading Worksheet

The following sample code loads the source Excel file and filters the following data from its worksheets using a custom filter.

It filters charts from the worksheet named NoCharts.
It filters shapes from the worksheet named NoShapes.
It filters conditional formatting from the worksheet named NoConditionalFormatting.

Once it loads the source Excel file with a custom filter, it captures the images of all worksheets one by one. Here are the output images for your reference. As you can see, the first image does not have charts, the second image does not have shapes, and the third image does not have conditional formatting.

This is how to use the CustomLoadFilter class for specific worksheet names.

Gocpp: Filtering the kind of data while loading the workbook from a template file with Golang via C++

Mon, 01 Jan 0001 00:00:00 +0000

Sometimes you want to specify which kind of data should be loaded when building the workbook from the template file. Filtering loaded data can improve performance for your specific purpose, especially when using LightCells APIs. Please use the LoadOptions.GetLoadFilter() property for this purpose.

The following sample code loads only shape objects while loading the workbook from the template file which you can download from the given link. The following screenshot shows the template file contents and also explains that the data in red color and yellow background will not be loaded because the LoadOptions.GetLoadFilter() property has been set to LoadDataFilterOptions.Shape.

The following screenshot shows the output PDF which you can download from the given link. Here you can see that the data in red color and yellow background is not present, but all shapes are there.

Gocpp: Load Source Excel File Without Charts with Golang via C++

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells allows you to load an Excel file without charts. Please use the LoadOptions.GetLoadFilter() property for this purpose.

Load Spreadsheet Without Charts

The following sample code loads the sample Excel file without charts and saves it as a PDF file.