Aspose.Excel (1.8.7.1) Memory Issue


#1

I am trying to produce an excel file with 65,000 rows (82 col) through ASP.NET application but without success. Aspose component is eating all the memory. The server has 8 gig of total RAM and 60% of it can be used for ASPNET worker process.

I have created a test application that generates about 2500 rows with 82 columns and Aspose alone is costing about 96 MB memory. See the memory allocations at the bottom of this post captured by CLRProfiler.

Here are my psudo codes:

CreateReport(96 MB) --> WriteData(49 MB); Save(46 MB)--->WriteGroupData(49 MB)

How can I improve the memory consumption? Did you realize that I would need 2.4 gig of memory just to run the CreateReport method if I were to produce an excel file with 65,000 rows?

Thanks in advance.

Prodip

Codes and Memory allocation:

public string CreateReport()
{
try
{
string licenseFile = GetAsposeLicense();
oExcel = new Aspose.Excel.Excel(licenseFile);

// Open Template
oExcel.Open(GetTemplate());

//Write Data
if (dtData.Rows.Count > 0)
WriteData();
else
oExcel.Replace("&Data", "");

//Save Excel Report
oExcel.Save(ReportDest, FileFormatType.Excel2000);
oExcel = null;

//Return report path
return ReportDest;
}
catch (Exception e)
{
throw (e);
}
}

private int WriteGroupData(DataView dv, int Row, int Col)
{
int InitCol = Col;
Worksheet ws=oExcel.Worksheets.GetAt(0);
Cells oCells = ws.Cells;

double dColWidth;

//Define Styles
Styles oStyles = oExcel.Styles;
int styleIndexCustom = oStyles.Add();
int styleIndex40 = oStyles.Add();
int styleIndex14 = oStyles.Add();
int styleIndexDefault = oStyles.Add();
int styleIndex0 = oStyles.Add();

Style styleDefault = oExcel.Styles.GetAt(styleIndexDefault);
styleDefault.Font.Name="Tahoma";
styleDefault.Font.Size=10;
styleDefault.Number=0;
styleDefault.HorizontalAlignment=TextAlignmentType.Left;

Style styleCustom = oExcel.Styles.GetAt(styleIndexCustom);
styleCustom.Font.Name="Tahoma";
styleCustom.Font.Size=10;
styleCustom.HorizontalAlignment=TextAlignmentType.Right;
styleCustom.Custom="#0.00000_);[Red](#0.00000)";

Style style40 = oExcel.Styles.GetAt(styleIndex40);
style40.Font.Name="Tahoma";
style40.Font.Size=10;
style40.Number=40;
style40.HorizontalAlignment=TextAlignmentType.Right;

Style style14 = oExcel.Styles.GetAt(styleIndex14);
style14.Font.Name="Tahoma";
style14.Font.Size=10;
style14.Number=14;
style14.HorizontalAlignment=TextAlignmentType.Right;

Style style0 = oExcel.Styles.GetAt(styleIndex0);
style0.Font.Name="Tahoma";
style0.Font.Size=10;
style0.Number=0;
style0.HorizontalAlignment=TextAlignmentType.Right;

//Cell oCell=null;

// Write each row
foreach(DataRowView drv in dv)
{
// Write each column
for(int i = 0; i<dv.Table.Columns.Count; i++)
{
if (HasSubtotals)
{ // If subtotals, then add column value to running total
int iCol = FindColumn(dtData.ColumnsIdea [I].ToString());
if (iCol >= 0)
{
Column oCol = (Column) columnTotals[iCol];
if (oCol.Type == "Subtotal")
{
oCol.AddGroupTotal(groupBy.Count-1, (decimal) drvIdea [I]);
}
else if(oCol.Type == "SubtotalInt")
{
oCol.AddGroupTotal(groupBy.Count-1, (int) drvIdea [I]);
}
else
{
oCol.AddGroupCount(groupBy.Count-1, (int) 1);
}
}
}
// Write value
Cell oCell = oCells[Row, (byte) Col];

//oCell.PutValue(drvIdea [I]);
oCell.PutValue(drvIdea [I]);

// Set CellFormat based on datatype
if (dtData.ColumnsIdea [I].DataType.Name == "Decimal")
{
if (RateFormat(dtData.ColumnsIdea [I].ColumnName.ToString()))
{
oCell.Style=styleCustom;

}
else
{
oCell.Style=style40;

}
}
else if (dtData.ColumnsIdea [I].DataType.Name == "DateTime")
{
oCell.Style=style14;
dColWidth = oCells.GetColumnWidth((byte) i);
if (dColWidth < 10)
oCells.SetColumnWidth((byte) i, 10);
}
else if (dtData.ColumnsIdea [I].DataType.Name == "Int32")
{
oCell.Style=style0;
}
else
{
oCell.Style=styleDefault;

}

Col++;
oCell=null;
}
Row++;
Col = InitCol;
}

//Release the local objects
oStyles=null;
styleDefault=null;
styleCustom=null;
style40=null;
style14=null;

//oCell=null;
oCells=null;
ws=null;

//Return Value
return Row;
}

: 111 MB (100.00%)
ProbAspose.ProfileAspose::Main static void (String[]): 111 MB (99.99%)
ProbAspose.MasterFile::CreateReport String (): 111 MB (99.98%)
ProbAspose.ExcelReport::CreateReport String (): 96 MB (86.33%)
ProbAspose.MasterFile::GetData void (): 15 MB (13.64%)
ProbAspose.ExcelReport::WriteData void (): 49 MB (44.53%)
Aspose.Excel.Excel::Save void (String Aspose.Excel.FileFormatType): 46 MB (41.53%)
EMCSQLDataAccessImplementation.OleDbHelper::ExecuteDataset void (String String): 15 MB (13.64%)
ProbAspose.ExcelReport::WriteGroupData int32 ( int32 int32): 49 MB (44.52%)
Aspose.Excel.Worksheets::a void (String Aspose.Excel.SaveType Aspose.Excel.FileFormatType ): 46 MB (41.50%)
EMCSQLDataAccessImplementation.OleDbHelper::ExecuteDataset void (String String []): 15 MB (13.64%)
Aspose.Excel.Worksheets::d void (b5): 46 MB (41.50%)
EMCSQLDataAccessImplementation.OleDbHelper::ExecuteDataset void ( String []): 15 MB (13.60%)
Aspose.Excel.Cell::set_Style void (Aspose.Excel.Style): 11 MB (10.00%)
System.RuntimeType::get_Name String (): 9.3 MB (8.42%)
System.Data.DataRowView::get_Item Object (int32): 1.4 MB (1.22%)
Aspose.Excel.Worksheet::c void (b5): 46 MB (41.15%)
Aspose.Excel.Cells::get_Item Aspose.Excel.Cell (int32 unsigned int8): 27 MB (23.96%)
System.Data.Common.DbDataAdapter::Fill int32 (System.Data.DataSet): 15 MB (13.60%)
System.Data.DataColumn::get_Item Object (int32): 1.4 MB (1.22%)
Aspose.Excel.Cells::d void (b5 Aspose.Excel.FileFormatType): 46 MB (41.15%)
System.Data.Common.DbDataAdapter::Fill int32 (System.Data.DataSet int32 int32 String System.Data.IDbCommand System.Data.CommandBehavior): 15 MB (13.60%)
System.Data.Common.DecimalStorage::Get Object (int32): 1.3 MB (1.16%)
Aspose.Excel.Cell::a void (b5 Aspose.Excel.FileFormatType): 36 MB (32.03%)
System.Data.Common.DbDataAdapter::FillFromCommand int32 (Object int32 int32 String System.Data.IDbCommand System.Data.CommandBehavior): 15 MB (13.60%)
Aspose.Excel.Cells::c unsigned int32 (b5 Aspose.Excel.FileFormatType): 7.3 MB (6.56%)
Aspose.Excel.Cells::b void (Aspose.Excel.Cell): 2.0 MB (1.80%)
dg::a bool (unsigned int16 unsigned int16 unsigned int16 float64): 23 MB (20.32%)
System.Data.Common.DbDataAdapter::Fill int32 (System.Data.DataSet String System.Data.IDataReader int32 int32): 15 MB (13.57%)
f::a void (b5): 4.2 MB (3.80%)
df::a void (b5): 3.1 MB (2.79%)
Aspose.Excel.Cells::a void (Aspose.Excel.Cell): 2.0 MB (1.80%)
System.Data.Common.DbDataAdapter::FillFromReader int32 (Object String System.Data.IDataReader int32 int32 System.Data.DataColumn Object): 15 MB (13.57%)
dg::a bool (float64): 7.6 MB (6.84%)
System.Collections.ArrayList::Insert void (int32 Object): 2.0 MB (1.80%)
System.Data.Common.DbDataAdapter::FillLoadDataRow int32 (System.Data.Common.SchemaMapping): 15 MB (13.32%)
System.BitConverter::GetBytes static unsigned int8[] (float64): 3.9 MB (3.52%)
System.Data.Common.SchemaMapping::LoadDataRow void (bool bool): 15 MB (13.32%)
System.Data.DataTable::LoadDataRow System.Data.DataRow (Object[] bool): 8.5 MB (7.65%)
System.Data.OleDb.OleDbDataReader::GetValues int32 (Object[]): 6.3 MB (5.67%)
System.Data.DataTable::NewRecordFromArray int32 (Object[]): 8.3 MB (7.46%)
System.Data.OleDb.DBBindings::get_Value Object (): 6.3 MB (5.67%)
System.Data.RecordManager::NewRecordBase int32 (): 8.3 MB (7.46%)
System.Data.OleDb.DBBindings::get_Value_NUMERIC void (): 2.0 MB (1.78%)
System.Data.RecordManager::GrowRecordCapacity void (): 8.3 MB (7.46%)
System.Data.OleDb.DBBindings::Get_NUMERIC static void (int int32[]): 2.0 MB (1.78%)
System.Data.RecordManager::set_RecordCapacity void (int32): 8.3 MB (7.44%)
System.Collections.ArrayList::EnsureCapacity void (int32): 2.5 MB (2.22%)
System.Data.DataColumn::SetCapacity void (int32): 8.3 MB (7.44%)
System.Collections.ArrayList::set_Capacity void (int32): 2.5 MB (2.22%)
System.Data.Common.DecimalStorage::SetCapacity void (int32): 7.3 MB (6.59%)
System.Delegate::Combine static System.Delegate (System.Delegate System.Delegate): 5.6 MB (5.00%)
System.MulticastDelegate::CombineImpl System.Delegate (System.Delegate): 5.6 MB (5.00%)
System.Byte [] : 34 MB (31.05%)
Aspose.Excel.Cell : 22 MB (20.02%)
a3 : 11 MB (10.01%)
System.String : 10 MB (9.40%)
System.Decimal [] : 7.3 MB (6.54%)
System.UInt16 : 5.1 MB (4.55%)
cx : 4.8 MB (4.29%)
System.Decimal : 4.7 MB (4.20%)
System.Object [] : 3.8 MB (3.38%)
dg : 2.9 MB (2.63%)
df : 1.2 MB (1.04%)


#2

Hi Laurance- Can you comment on this post, please?


#3

Could you please zip and post your test project here? I will check and run it in my machine.

Aspose.Excel is changed to Aspose.Cells. Have you tried the latest version of Aspose.Cells?


#4

Laurance- Thanks for response. Unfortunately, I could not post the test project since it gets data from a database using stored procedure. However, I have posted the function that is using too much memory.

Change is COST!

It's been a while since we developed the applications to use Aspose.Excel. Is there a significant improvement in terms of memory usages? We don't care much on other features at this moment. I think we bought unlimited lic. Is there any cost for upgrade? If so, how extent?

Thanks,

Prodip


#5

Hi Prodip,

Aspose.Excel v1.8.7 is released about 2 years ago. We have done many feature enhancement and optimization. I hope you can try the latest version to see if it works better for your program. I don't mean to change all you program with new Aspose.Cells.

I understand that changing your test application with Aspose.Cells will cost your effort. So I make a following test case with Aspose.Cells and I think it's easy for you to change it back to Aspose.Excel.

Workbook workbook = new Workbook();

//Define Styles
Styles oStyles = workbook.Styles;
int styleIndexCustom = oStyles.Add();
int styleIndex40 = oStyles.Add();
int styleIndex14 = oStyles.Add();
int styleIndexDefault = oStyles.Add();
int styleIndex0 = oStyles.Add();

Style styleDefault = workbook.Styles[styleIndexDefault];
styleDefault.Font.Name="Tahoma";
styleDefault.Font.Size=10;
styleDefault.Number=0;
styleDefault.HorizontalAlignment=TextAlignmentType.Left;

Style styleCustom = workbook.Styles[styleIndexCustom];
styleCustom.Font.Name="Tahoma";
styleCustom.Font.Size=10;
styleCustom.HorizontalAlignment=TextAlignmentType.Right;
styleCustom.Custom="#0.00000_);[Red](#0.00000)";

Style style40 = workbook.Styles[styleIndex40];
style40.Font.Name="Tahoma";
style40.Font.Size=10;
style40.Number=40;
style40.HorizontalAlignment=TextAlignmentType.Right;

Style style14 = workbook.Styles[styleIndex14];
style14.Font.Name="Tahoma";
style14.Font.Size=10;
style14.Number=14;
style14.HorizontalAlignment=TextAlignmentType.Right;

Style style0 = workbook.Styles[styleIndex0];
style0.Font.Name="Tahoma";
style0.Font.Size=10;
style0.Number=0;
style0.HorizontalAlignment=TextAlignmentType.Right;


Cells cells = workbook.Worksheets[0].Cells;

for(int i = 0; i < 2500; i ++)
{
for(int j = 0; j < 82; j ++)
{
switch(j % 3)
{
case 0:
cells[i, j].PutValue("hello" + i.ToString() + "world" + j.ToString());
break;
case 1:
cells[i, j].PutValue(i * 100 + j);
cells[i, j].Style = styleDefault;
break;
case 2:
cells[i, j].PutValue(DateTime.Now.AddSeconds( i * 100 + j));
cells[i, j].Style = style14;
break;
}
}
}

workbook.Save("d:\\test\\abc.xls");

It creates a 4.5MB file and consumes 60MB memory at run time.

For your case, I think 65000 rows and 82 columns data in an Excel file is too much for an aspnet program. The output file will be more than 100MB!


#6

Laurance- Thanks for the sample codes. I will definitely test the codes with newer version.

However, I am planning to change the reporting design to queue the requests and add a windows service to run the reports. My goal is to separate the Aspose from w3wp process. For some reason IIS6 is not releasing memory when used with Aspose.

Thanks,

Prodip


#7

Laurance- I downloaded the latest version (4.0.x) and run your sample codes. To produce a 2500*82 excel file it costs about 124 MB (this is when I run with the CLRProfiler). This is very much inline with the version I currently have (1.8.7.1). See the memory consumption in details at the end of this post.

Conclusion: There is no improvement as far as CPU or Memory consumptions.

In another test to create an excel file with 65000 * 82 it cost about 800 MB memory with Aspose.Cell and the file size is about 118 MB. Obviously, Aspose is NOT a good candidate when it comes to memory utilization. I am sorry to say, you can not tell the users that it's not possible to create large report. They will find someone who can do the job! That's the hard fact.

As said before, I am planning to separate the Aspose report creation process to another process on a separate machine. Am I going to bring down that server? Possibly yes but I would have greater control to limit the concurrent threads.

Thanks,

Prodip K. Saha

: 124 MB (100.00%)
ProbAspose.ProfileAspose::Main static void (String[]): 124 MB (99.99%)
ProbAspose.MasterFile::CreateReport String (): 124 MB (99.98%)
Aspose.Cells.Workbook::Save void (String Aspose.Cells.FileFormatType): 86 MB (69.00%)
Aspose.Cells.Cell::PutValue void (): 12 MB (9.95%)
System.String::Concat static String (String String String String): 3.3 MB (2.62%)
Aspose.Cells.Workbook::Save void ( Aspose.Cells.FileFormatType): 86 MB (69.00%)
Aspose.Cells.Cell::PutValue void (float64): 12 MB (9.95%)
Aspose.Cells.Worksheets:: void (Aspose.Cells.FileFormatType): 85 MB (68.68%)
Aspose.Cells.Worksheets:: void (Aspose.Cells.RW.ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ): 85 MB (68.68%)
Aspose.Cells.Cell::get_Style Aspose.Cells.Style (): 11 MB (9.12%)
Aspose.Cells.Cell::PutValue void (String): 5.2 MB (4.20%)
Aspose.Cells.Worksheet:: void (Aspose.Cells.RW.ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ): 69 MB (55.51%)
Aspose.Cells.Record. void (Aspose.Cells.RW.ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ Aspose.Cells.Worksheets): 16 MB (12.55%)
Aspose.Cells.Cells::get_Item Aspose.Cells.Cell (int32 int32): 14 MB (11.05%)
Aspose.Cells.Record. void (String Object Aspose.Cells.Cell): 5.2 MB (4.20%)
Aspose.Cells.Cells:: void (Aspose.Cells.RW.ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ Aspose.Cells.FileFormatType): 69 MB (55.51%)
System.Int32::ToString String (): 3.1 MB (2.52%)
Aspose.Cells.Cell:: void (unsigned int8[]& int32& Aspose.Cells.RW.ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ): 30 MB (24.12%)
Aspose.Cells.CellsHelper:: static bool (float64): 10 MB (8.29%)
Aspose.Cells.Cells:: int64 (Aspose.Cells.RW.ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ Aspose.Cells.FileFormatType): 4.7 MB (3.78%)
Aspose.Cells.Cell:: void (unsigned int8[]& int32& int32 Aspose.Cells.RW.ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ): 27 MB (21.76%)
Aspose.Cells.Record. void (): 11 MB (8.47%)
Aspose.Cells.Record. void (String unsigned int8[]): 13 MB (10.10%)
Aspose.Cells.Record. bool (unsigned int16 unsigned int16 unsigned int16 float64): 9.4 MB (7.56%)
Aspose.Cells.Record. bool (unsigned int16 unsigned int16 unsigned int16 int32): 8.1 MB (6.53%)
Aspose.Cells.Style::GetStyle void (Aspose.Cells.Worksheets int32): 5.9 MB (4.78%)
Aspose.Cells.Record. void (unsigned int16 unsigned int16 unsigned int16 float64): 5.7 MB (4.56%)
System.Collections.ArrayList::Insert void (int32 Object): 2.0 MB (1.63%)
System.IO.MemoryStream::Write void (unsigned int8[] int32 int32): 9.7 MB (7.85%)
Aspose.Cells.Style::Copy void (Aspose.Cells.Style): 5.9 MB (4.79%)
System.Text.Encoding::GetBytes unsigned int8[] (String): 4.7 MB (3.78%)
Aspose.Cells.Record. bool (float64): 3.9 MB (3.11%)
System.Text.ASCIIEncoding::GetString String (unsigned int8[]): 3.3 MB (2.62%)
Aspose.Cells.Record. void (String unsigned int8[] unsigned int8[]): 2.3 MB (1.85%)
System.BitConverter::GetBytes static unsigned int8[] (float64): 12 MB (9.33%)
System.IO.MemoryStream::EnsureCapacity bool (int32): 9.7 MB (7.85%)
System.String::CreateStringFromASCII static String (unsigned int8[] int32 int32): 3.3 MB (2.62%)
System.Collections.ArrayList::EnsureCapacity void (int32): 2.5 MB (2.04%)
System.Text.Encoding::GetBytes unsigned int8[] (wchar[] int32 int32): 1.8 MB (1.47%)
Aspose.Cells.Style::set_BackgroundColor void (): 1.6 MB (1.26%)
Aspose.Cells.Style::set_ForegroundColor void (): 1.5 MB (1.24%)
System.IO.MemoryStream::set_Capacity void (int32): 9.7 MB (7.85%)
Aspose.Cells.Record.PaletteRecord::GetColorPaletteIndex int32 (): 3.1 MB (2.51%)
System.Collections.ArrayList::set_Capacity void (int32): 2.5 MB (2.04%)
Aspose.Cells.Record.PaletteRecord::GetColorPaletteIndex int32 (int32): 3.1 MB (2.49%)
System.Collections.Hashtable::set_Item void (Object Object): 4.1 MB (3.34%)
System.Collections.Hashtable::Insert void (Object Object bool): 4.1 MB (3.34%)
System.Collections.Hashtable::rehash void (int32): 4.1 MB (3.34%)
System.String::ToCharArray wchar[] (int32 int32): 2.9 MB (2.30%)
System.Byte [] : 55 MB (43.90%)
System.Object [] : 13 MB (10.35%)
Aspose.Cells.Cell : 12 MB (9.44%)
System.String : 9.7 MB (7.79%)
Aspose.Cells.Record. : 8.8 MB (7.07%)
Aspose.Cells.Style : 5.4 MB (4.36%)
System.Collections.Hashtable.bucket [] : 4.1 MB (3.34%)
System.Int32 : 3.9 MB (3.12%)
System.Collections.ArrayList : 3.1 MB (2.49%)
System.Char [] : 2.9 MB (2.31%)
Aspose.Cells.Font : 2.8 MB (2.28%)
System.Double : 2.1 MB (1.66%)


#8

Hi Prodip,

1. In the latest version, we don't use Win32 APIs to write Excel files to disk. That make our component much faster but it does consume memory more than v1.8.7.1.

2. Aspose.Cells can process very large reports if you have enough memory. However we don't recommend this action.

3. I have check some competitors' products. Aspose.Cells runs much faster than them and consume less memory.