IronXL 和 GrapeCity Excel 查看器的比较

What does GrapeCity Documents for Excel offer you?

• Allows for the creation, manipulation, and serialization of spreadsheets on the server.
• Low memory footprint.
• Performs complex calculations using the powerful calculation engine.
• High-speed intuitive document; embedded business intelligence.
• Provides full reporting solutions.
• Gives you full control of your documents at high speed.
• Generates output in a variety of formats, including .xlsx, and ssjson.
• Support for .NET Framework, .NET Core, and Mono across several platforms.
• Compatible with WinForms, WPF, ASP.NET, and other environments.

GrapeCity Excel — standout features

The latest release version 14.1 has many new and exciting features.

• Lightweight Spreadsheet API Architecture for Improved Efficiency

GcExcel .NET enables users to save a considerable amount of time, storage memory, and effort by improving the overall efficiency with its lightweight API architecture that can be used to generate, load, edit, save and convert spreadsheets.

• No Dependency on MS Excel

In order to work with GcExcel .NET, users don't need to install MS Office Suite or access MS Excel on their systems.

• Create an Interactive Experience with SpreadJS DSheets

GcExcel .NET can be used with spreadsheets for a completely interactive and user-friendly spreadsheet experience.

• Deploy Apps with Excel Spreadsheets to the Cloud

With GcExcel .NET, you can apply cloud-based deployments and deploy your applications on Azure and AWS Lambda.

• Shapes and Pictures

With the spreadsheet API, you can insert and customize shapes and pictures on cells of a worksheet, apply formatting, gradient fill, configure text, insert hyperlinks, set adjustment points of the shapes, group/ungroup them in a worksheet, and determine the position and size of an image.

IronXL Feature Set

• Load, Read, and Edit Data — from XLS/XLSX/CSV/TSV
• Saving and Exporting — to XLS/XLSX/CSV/TSV/JSON
• System.Data Objects — Work with Excel Spreadsheets as System.Data.DataSet and System.Data.DataTable objects.
• Formulas — works with Excel formulas. Formulas are recalculated every time a sheet is edited.
• Ranges — Easy-to-use WorkSheet ["A1:B10"] syntax. Combine and create ranges intuitively.
• Sorting — Sort Ranges, Columns, and Rows.
• Styling — Cell visual styles, font, size, background pattern, border, alignment, and number formats.

Using Visual Studio with NuGet Packages

Visual Studio provides the NuGet Package Manager to install NuGet packages in your projects. You can access it through the Project Menu, or by right-clicking your project in the Solution Explorer.

• Next, from the Browse tab -> search for IronXL.Excel -> Install

• And we are done.

Using the NuGet Package Manager Console

Another way to download and install Microsoft.Office.Interop.Excel C# library is to make use of the following steps to install the NuGet package through the Developer Command Prompt.

• Open the Developer Command Prompt — usually found in the Visual Studio folder.
• Type the following command:

Install-Package Microsoft.Office.Interop.Excel

• Press Enter.
• This will download and install the package.
• Reload your Visual Studio project and begin using it.

Add necessary using directives

1. In Solution Explorer, right-click the Program.cs file and then click View Code.
2. Add the following using directives to the top of the code file:

using Excel = Microsoft.Office.Interop.Excel;

using Excel = Microsoft.Office.Interop.Excel;

Imports Excel = Microsoft.Office.Interop.Excel

Creating Excel files using IronXL

It could not be any easier to create a new Excel Workbook using IronXL. Just one line of code! Yes, really. Add the following code to your static void main function in the Program.cs file:

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

Both XLS (older Excel file version) and XLSX (current and newer file version) file formats can be created with IronXL.

And, it’s even easier to create a default Worksheet:

var worksheet = workbook.CreateWorkSheet("IronXL Features");

var worksheet = workbook.CreateWorkSheet("IronXL Features");

Dim worksheet = workbook.CreateWorkSheet("IronXL Features")

You may now utilize the worksheet variable to set cell values and do practically anything an Excel file can do.

Creating Excel files using a Server-Side Excel API GrapeCity Excel

GrapeCity Documents for Excel (or GcExcel) is a server-side Excel API that allows you to create, load, save, convert, compute, format, parse, and export spreadsheets in any .NET Standard application. GcExcel can deploy to Azure without any Excel dependencies thanks to the full .NET5 support for Windows, Linux, and Mac.

GcExcel allows you to create and generate server-side Excel spreadsheets without having to use MS Excel.

• Create a workbook with GcExcel in a function.
• Return to the client-side after converting the workbook to JSON.

In this example, we're merely going to make a BidTracker.xlsx spreadsheet. This sample displays extra server-side functionality that may be programmed with GcExcel.

[HttpGet("{caseName}")]
public IActionResult GetSSJsonFromUseCase(string caseName)
{
    Workbook workbook = CreateWorkbookByCaseName(caseName);
    var ssjson = workbook.ToJson();
    return Ok(ssjson);
}

private Workbook CreateWorkbookByCaseName(string caseName)
{
    switch (caseName)
    {
        case "BidTracker":
            return GetBidTracker();
        default:
            break;
    }

    return new Workbook();
}

[HttpGet("{caseName}")]
public IActionResult GetSSJsonFromUseCase(string caseName)
{
    Workbook workbook = CreateWorkbookByCaseName(caseName);
    var ssjson = workbook.ToJson();
    return Ok(ssjson);
}

private Workbook CreateWorkbookByCaseName(string caseName)
{
    switch (caseName)
    {
        case "BidTracker":
            return GetBidTracker();
        default:
            break;
    }

    return new Workbook();
}

<HttpGet("{caseName}")>
Public Function GetSSJsonFromUseCase(ByVal caseName As String) As IActionResult
	Dim workbook As Workbook = CreateWorkbookByCaseName(caseName)
	Dim ssjson = workbook.ToJson()
	Return Ok(ssjson)
End Function

Private Function CreateWorkbookByCaseName(ByVal caseName As String) As Workbook
	Select Case caseName
		Case "BidTracker"
			Return GetBidTracker()
		Case Else
	End Select

	Return New Workbook()
End Function

Edit Excel files with GrapeCity Excel

Let's get started using GcExcel to address these issues.

You're handed a spreadsheet that looks like this:

First, we'll want to format the sheet:

• Change the font properties of the title of the sheet and the Total Income cell.
• Change table, table column, and cell styles.

Let's take a look at how to accomplish this using GcExcel.

Step 1: Load an existing Excel spreadsheet

Write the following code to load an existing spreadsheet into your GcExcel Workbook:

Workbook workbook = new Workbook();
workbook.Open("EventBudget.xlsx");

Workbook workbook = new Workbook();
workbook.Open("EventBudget.xlsx");

Dim workbook As New Workbook()
workbook.Open("EventBudget.xlsx")

Step 2: Get the worksheet that you want to modify

IWorksheet worksheet = workbook.ActiveWorksheet;

IWorksheet worksheet = workbook.ActiveWorksheet;

Dim worksheet As IWorksheet = workbook.ActiveWorksheet

Step 3: Modify the font properties of the titles

Change the font properties of B2 (font size) and E4 (set to bold) cells:

// Change range B2's font size.
worksheet.GetRange("B2").Font.Size = 22;

// Change range E4's font style to bold.
worksheet.GetRange("E4").Font.Bold = true;

// Change range B2's font size.
worksheet.GetRange("B2").Font.Size = 22;

// Change range E4's font style to bold.
worksheet.GetRange("E4").Font.Bold = true;

' Change range B2's font size.
worksheet.GetRange("B2").Font.Size = 22

' Change range E4's font style to bold.
worksheet.GetRange("E4").Font.Bold = True

Step 4: Modify table style

Set styles of the four tables to an in-built style.

worksheet.Tables["tblAdmissions"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblAds"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblVendors"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblItems"].TableStyle = workbook.TableStyles["TableStyleLight10"];

worksheet.Tables["tblAdmissions"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblAds"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblVendors"].TableStyle = workbook.TableStyles["TableStyleLight10"];
worksheet.Tables["tblItems"].TableStyle = workbook.TableStyles["TableStyleLight10"];

worksheet.Tables("tblAdmissions").TableStyle = workbook.TableStyles("TableStyleLight10")
worksheet.Tables("tblAds").TableStyle = workbook.TableStyles("TableStyleLight10")
worksheet.Tables("tblVendors").TableStyle = workbook.TableStyles("TableStyleLight10")
worksheet.Tables("tblItems").TableStyle = workbook.TableStyles("TableStyleLight10")

Step 5: Modify cell range style

Modify the cell style of Total Income cells. The Interior property of a range can help you set the ThemeColor and TintAndShade properties. You can also change the font of the entire range using the Font property. In addition, this code can set the borders of a range of cells.

Since the spreadsheet shows the budget data, set the number format of a range of cells to currency.

// Modify range F4:G5's cell style.
worksheet.GetRange("F4:G5").Interior.ThemeColor = ThemeColor.Light1;
worksheet.GetRange("F4:G5").Interior.TintAndShade = -0.15;
worksheet.GetRange("F4:G5").Font.ThemeFont = ThemeFont.Major;
worksheet.GetRange("F4:G5").Font.Size = 12;
worksheet.GetRange("F4:G5").Borders[BordersIndex.InsideHorizontal].LineStyle = BorderLineStyle.None;
worksheet.GetRange("F5:G5").NumberFormat = "$#,##0.00";

// Modify range F4:G5's cell style.
worksheet.GetRange("F4:G5").Interior.ThemeColor = ThemeColor.Light1;
worksheet.GetRange("F4:G5").Interior.TintAndShade = -0.15;
worksheet.GetRange("F4:G5").Font.ThemeFont = ThemeFont.Major;
worksheet.GetRange("F4:G5").Font.Size = 12;
worksheet.GetRange("F4:G5").Borders[BordersIndex.InsideHorizontal].LineStyle = BorderLineStyle.None;
worksheet.GetRange("F5:G5").NumberFormat = "$#,##0.00";

' Modify range F4:G5's cell style.
worksheet.GetRange("F4:G5").Interior.ThemeColor = ThemeColor.Light1
worksheet.GetRange("F4:G5").Interior.TintAndShade = -0.15
worksheet.GetRange("F4:G5").Font.ThemeFont = ThemeFont.Major
worksheet.GetRange("F4:G5").Font.Size = 12
worksheet.GetRange("F4:G5").Borders(BordersIndex.InsideHorizontal).LineStyle = BorderLineStyle.None
worksheet.GetRange("F5:G5").NumberFormat = "$#,##0.00"

Step 6: Modify table column styles

Since table column ranges are different, set the ThemeColor, TintAndShade properties, and NumberFormat on a different column range of the table.

worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.ThemeColor = ThemeColor.Light1;
worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.TintAndShade = -0.15;
worksheet.GetRange("E8:G11, E15:G18, E22:G25, E29:G33").NumberFormat = "$#,##0.00";

worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.ThemeColor = ThemeColor.Light1;
worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.TintAndShade = -0.15;
worksheet.GetRange("E8:G11, E15:G18, E22:G25, E29:G33").NumberFormat = "$#,##0.00";

worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.ThemeColor = ThemeColor.Light1
worksheet.GetRange("F8:G11, F15:G18, F22:G25, F29:G33").Interior.TintAndShade = -0.15
worksheet.GetRange("E8:G11, E15:G18, E22:G25, E29:G33").NumberFormat = "$#,##0.00"

Step 7: Save the Excel file

// Save to an Excel file
workbook.Save("EventBudget.xlsx");

// Save to an Excel file
workbook.Save("EventBudget.xlsx");

' Save to an Excel file
workbook.Save("EventBudget.xlsx")

Congratulations! You have entirely changed the formatting of the document. Run the application, and your Excel spreadsheet looks like this:

Edit Excel files with IronXL

Once you have installed IronXL, let's address the process of editing Excel files with it.

Edit the Values of Specific Cells

First, we'll look at how to change the values of certain cells in an Excel spreadsheet.

We do this by importing the Excel spreadsheet that has to be changed and accessing its WorkSheet. Then, we can make the changes as indicated below.

using IronXL;

static void Main(string[] args)
{
    // Import Excel Spreadsheet
    WorkBook wb = WorkBook.Load("sample.xlsx");

    // Access specific worksheet
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Access specific cell and modify its value
    ws.Rows[3].Columns[1].Value = "New Value";

    // Save changes
    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{
    // Import Excel Spreadsheet
    WorkBook wb = WorkBook.Load("sample.xlsx");

    // Access specific worksheet
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Access specific cell and modify its value
    ws.Rows[3].Columns[1].Value = "New Value";

    // Save changes
    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	' Import Excel Spreadsheet
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")

	' Access specific worksheet
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	' Access specific cell and modify its value
	ws.Rows(3).Columns(1).Value = "New Value"

	' Save changes
	wb.SaveAs("sample.xlsx")
End Sub

Here are before and after screenshots of the Excel spreadsheet sample.xlsx:

We can see how simple it is to modify the Excel spreadsheet value.

If needed, there is also an alternative way to edit the specific cell value by cell address:

// Alternative way to access specific cell and apply changes
ws["B4"].Value = "New Value";

// Alternative way to access specific cell and apply changes
ws["B4"].Value = "New Value";

' Alternative way to access specific cell and apply changes
ws("B4").Value = "New Value"

Edit Full Row Values

It is pretty simple to edit full row values of an Excel spreadsheet with a static value.

using IronXL;

static void Main(string[] args)
{    
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Set full row value
    ws.Rows[3].Value = "New Value";

    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{    
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Set full row value
    ws.Rows[3].Value = "New Value";

    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	' Set full row value
	ws.Rows(3).Value = "New Value"

	wb.SaveAs("sample.xlsx")
End Sub

See the screenshots of the sample.xlsx below:

For this, we also can edit the value of a specific range of the row by using the range function:

// Modify specific range within a row
ws["A3:E3"].Value = "New Value";

// Modify specific range within a row
ws["A3:E3"].Value = "New Value";

' Modify specific range within a row
ws("A3:E3").Value = "New Value"

Edit Full Column Values

In the same way as above, we can easily edit full columns of the Excel spreadsheet with a single value.

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Set full column value
    ws.Columns[1].Value = "New Value";

    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    // Set full column value
    ws.Columns[1].Value = "New Value";

    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	' Set full column value
	ws.Columns(1).Value = "New Value"

	wb.SaveAs("sample.xlsx")
End Sub

This will produce our sample.xlsx spreadsheet as such:

Edit Full Rows with Dynamic Values

Using IronXL, it is also possible to edit specific rows with dynamic values. This means we can edit a full row by assigning dynamic values for each cell. Let's take a look at the example:

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    for (int i = 0; i < ws.Columns.Count(); i++)
    {
        // Set cell value dynamically based on column index
        ws.Rows[3].Columns[i].Value = "New Value " + i.ToString();
    }

    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    for (int i = 0; i < ws.Columns.Count(); i++)
    {
        // Set cell value dynamically based on column index
        ws.Rows[3].Columns[i].Value = "New Value " + i.ToString();
    }

    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	For i As Integer = 0 To ws.Columns.Count() - 1
		' Set cell value dynamically based on column index
		ws.Rows(3).Columns(i).Value = "New Value " & i.ToString()
	Next i

	wb.SaveAs("sample.xlsx")
End Sub

In the table below, we can see the screenshots of the Excel spreadsheet sample.xlsx from this output:

Edit Full Columns with Dynamic Values

It is also easy to edit specific columns with dynamic values.

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    for (int i = 0; i < ws.Rows.Count(); i++)
    {
        // Skip header row
        if (i == 0) continue;

        // Set cell value dynamically based on row index
        ws.Rows[i].Columns[1].Value = "New Value " + i.ToString();
    }

    wb.SaveAs("sample.xlsx");
}

using IronXL;

static void Main(string[] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");

    for (int i = 0; i < ws.Rows.Count(); i++)
    {
        // Skip header row
        if (i == 0) continue;

        // Set cell value dynamically based on row index
        ws.Rows[i].Columns[1].Value = "New Value " + i.ToString();
    }

    wb.SaveAs("sample.xlsx");
}

Imports IronXL

Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

	For i As Integer = 0 To ws.Rows.Count() - 1
		' Skip header row
		If i = 0 Then
			Continue For
		End If

		' Set cell value dynamically based on row index
		ws.Rows(i).Columns(1).Value = "New Value " & i.ToString()
	Next i

	wb.SaveAs("sample.xlsx")
End Sub

With the table results of sample.xlsx below:

Using GrapeCity to convert spreadsheets to PDF

GrapeCity Documents for Excel, Java Edition (GcExcel Java) is a high-speed, small-footprint spreadsheet API that requires zero dependencies in Excel. With full support on Windows, Linux, and Mac, you can generate, load, modify, and save spreadsheets, then convert them to a PDF.

Here are the three steps for converting spreadsheets to PDFs in Java applications:

1. Load an existing Excel spreadsheet in a GcExcel workbook
2. Add PDFBox as a library
3. Convert the spreadsheet to PDF

Step 1: Load an existing Excel spreadsheet in a GcExcel workbook

Create a GcExcel workbook object and load an existing spreadsheet.

Workbook workbook = new Workbook();
workbook.Open("FinancialKPI.xlsx");

Workbook workbook = new Workbook();
workbook.Open("FinancialKPI.xlsx");

Dim workbook As New Workbook()
workbook.Open("FinancialKPI.xlsx")

Step 2: Add PDFBox as a library

GcExcel Java references PDFBox to convert spreadsheets to PDF. PDFBox also depends on FontBox and Commons Logging packages.

Following these steps will help you add these JAR files as a library to your project:

1. Download the package — PDFBox, FontBox, Commons Loggings JAR files.
2. Under the 'src' folder in the project, add a folder 'libs'.
3. Copy the three JAR files to the 'libs' folder.
4. Right-click the 'libs' folder and choose the 'Add as library' option.
5. Press OK.

Note: The above steps would be required only if the project is an original Java console project. If the project is a Maven or Gradle project, just adding the GcExcel Java dependency would be sufficient. Maven or Gradle will download and install all dependent JARs automatically.

In some versions of Maven, you may get a dependency error on adding the above JAR files. To resolve that, please add the following node before the dependencies in pom.xml:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.felix</groupId>
            <artifactId>maven-bundle-plugin</artifactId>
            <extensions>true</extensions>
        </plugin>
    </plugins>
</build>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.felix</groupId>
            <artifactId>maven-bundle-plugin</artifactId>
            <extensions>true</extensions>
        </plugin>
    </plugins>
</build>

Step 3: Convert the spreadsheet to PDF

Save the spreadsheet to PDF using the following code:

workbook.Save("FinancialKPI.pdf", SaveFileFormat.Pdf);

workbook.Save("FinancialKPI.pdf", SaveFileFormat.Pdf);

workbook.Save("FinancialKPI.pdf", SaveFileFormat.Pdf)

Your PDF will look like this:

Using IronXL to convert spreadsheets to XML and JSON

The following code demonstrates how to export an Excel file to an XML or a JSON file with IronXL. Add the following code:

Include the namespace:

using IronXL;

using IronXL;

Imports IronXL

Add the next few lines:

private void ExportToXmlJson()
{        
    WorkBook workbook = WorkBook.Load("IronXL_Output.xlsx");

    // Export to JSON
    workbook.SaveAsJson("IronXL_Output.json");

    // Export to XML
    workbook.SaveAsXml("IronXL_Output.xml");
}

private void ExportToXmlJson()
{        
    WorkBook workbook = WorkBook.Load("IronXL_Output.xlsx");

    // Export to JSON
    workbook.SaveAsJson("IronXL_Output.json");

    // Export to XML
    workbook.SaveAsXml("IronXL_Output.xml");
}

Private Sub ExportToXmlJson()
	Dim workbook As WorkBook = WorkBook.Load("IronXL_Output.xlsx")

	' Export to JSON
	workbook.SaveAsJson("IronXL_Output.json")

	' Export to XML
	workbook.SaveAsXml("IronXL_Output.xml")
End Sub

Here, an existing Excel Workbook object is loaded and then exported to JSON and XML formats.

IronXL Licensing and Pricing

IronXL is an openly commercial C# Excel library. It is free for development and can always be licensed for commercial deployment. Licenses are offered for single-project use, single developers, agencies, and multinational organizations, as well as SaaS and OEM redistribution. All licenses contain a 30-day money-back guarantee, one year of software support and upgrades, validity for dev/staging/production, and also a permanent license (one-time purchase). The Lite bundle starts from $799.

GrapeCity Licensing and Pricing