How to Import and Export Excel XLSX Using Blazor
Tags: webdev, devops, javascript, tutorial
Published: 2023-05-08 20:15:11

---
canonical_url: https://www.grapecity.com/blogs/how-to-import-export-excel-xlsx-using-blazor
description: Learn how to import and export Excel XLSX files using Blazor. See more from SpreadJS today.
---
Blazor is a relatively new framework for building an interactive client-side web UI with the power of .NET. A common use case is importing your existing Excel files to your Blazor application, presenting the spreadsheet data to your users, allowing any changes to be made, then exporting that data back out to an Excel file or saving it to a database. SpreadJS is a very powerful and extensible JavaScript spreadsheet component that makes this process easy.

If you want to follow along with this tutorial, the download for the sample can be found [here](https://files.grapecity.com/gc-website-media/kahp2p3w/spreadjs_blazor_lib.zip).

Here are the steps to import/export spreadsheet files in Blazor:

1.  [Create the SpreadJS Blazor Component](#component)
2.  [Create the Blazor Application](#application)
3.  [Excel Import within Blazor Application](#import)
4.  [Excel Export within Blazor Application](#export)

## <a id="component"></a>Creating the SpreadJS Blazor Component

Before we can put SpreadJS in a Blazor application, we must first create a Blazor component to contain SpreadJS. In this tutorial, we will use Visual Studio 2022 and SpreadJS v16\. To create a component, first start by creating a Razor Class Library:

![Razor Class Library](https://files.grapecity.com/gc-website-media/uivnttfm/01-newproject.png?width=500&height=461.0154125113327)

For simplicity, you can name it something like "SpreadJS_Blazor_Lib":

![Configure Project](https://files.grapecity.com/gc-website-media/0wrjjbau/02-configureproject.png?width=500&height=353.28532853285327)

After the project is created, we will need to copy the SpreadJS files to the "wwwroot" folder:

![Solution Explorer](https://files.grapecity.com/gc-website-media/c2af5vvr/03-solutionexplorer.png?width=474.7023809523809&height=500)

Creating this project should have also created a file called "exampleJSInterop.js", so we will need to edit it to add logic that will help connect the C# code to the JavaScript code of SpreadJS:

```
    // This file is to show how a library package may provide JavaScript interop features
    // wrapped in a .NET API

    window.sjsAdaptor = {
        init: function (host, config) {
            if (config.hostStyle) {
                var hostStyle = config.hostStyle;
                var styles = hostStyle.split(';');
                styles.forEach((styleStr) => {
                    var style = styleStr.split(':');
                    host.style[style[0]] = style[1];
                });
                delete config.hostStyle;
            }

            return new GC.Spread.Sheets.Workbook(host, config);
        },

        setValue: function (host, sheetIndex, row, col, value) {
            var spread = GC.Spread.Sheets.findControl(host);
            if (spread) {
                var sheet = spread.getSheet(sheetIndex);
                sheet.setValue(row, col, value);
            }
        },

        openExcel: function (host, inputFile) {
            var spread = GC.Spread.Sheets.findControl(host);
            if (spread) {
                var excelIO = new GC.Spread.Excel.IO();
                excelIO.open(inputFile.files[0], function (json) {
                    spread.fromJSON(json);
                })
            }
        }
    };
```

The application should have also created a default "Component1.razor" file, which we can rename to "SpreadJS.razor". This will be the component we will use as a wrapper:

```
    @using Microsoft.JSInterop
    @inject IJSRuntime JSRuntime

    <div @ref="host"></div>

    @code {
        [Parameter]
        public int SheetCount { get; set; }

        [Parameter]
        public string HostStyle { get; set; }

        private ElementReference host;

        public void setValue(int sheetIndex, int row, int col, object value)
        {
            JSRuntime.InvokeVoidAsync("sjsAdaptor.setValue", host, sheetIndex, row, col, value);
        }

        public void OpenExcel(ElementReference inputFile)
        {
            JSRuntime.InvokeVoidAsync("sjsAdaptor.openExcel", host, inputFile);
        }

        protected override void OnAfterRender(bool firstRender)
        {
            if (firstRender)
            {
                JSRuntime.InvokeVoidAsync("sjsAdaptor.init", host, new Dictionary<string, object>() {
                    { "sheetCount", SheetCount},
                    { "hostStyle", HostStyle }
                });
            }
        }
    }
```

## <a id="application"></a>Creating a Blazor Application with SpreadJS

Now that we have created a component with SpreadJS, we can use it in a Blazor application. To start, we can add a new project with the "Blazor WebAssemblyApp" template:

![Blazor WebAssembly App](https://files.grapecity.com/gc-website-media/q3rclotu/04-blazornewproject.png?width=500&height=326.0481712756467)

To add the SpreadJS component, we will want to right-click on the Dependencies of this new project in the Solution Explorer and click "Add project reference". Our SpreadJS_Blazor_Lib should be listed as one of the options:

![Add Project Reference](https://files.grapecity.com/gc-website-media/hp0h354w/05-addprojectreference.png?width=500&height=348.27144686299613)

In this new project, there should be a Pages folder that contains a few different razor files. In this, we will want to edit the Index.razor file to set the code-behind for the HTML:

```
    @page "/"

    @using SpreadJS_Blazor_Lib

    <h1>Hello, SpreadJS!</h1>

    <SpreadJS SheetCount="3" HostStyle="@HostStyle" />

    @code {
        private string HostStyle { get; set; } = "width:90wh;height:70vh;border: 1px solid darkgray";
    }
```

Now we can edit the index.html file in the "wwwroot" folder. In this file, we can add references to the SpreadJS JavaScript and CSS files:

(Index.html)

```
    <!DOCTYPE html>
    <html>

    <head>
        <meta charset="utf-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
        <title>BlazorApp1</title>
        <base href="/" />
        <link href="css/bootstrap/bootstrap.min.css" rel="stylesheet" />
        <link href="css/app.css" rel="stylesheet" />

        <link href="https://cdn.grapecity.com/spreadjs/hosted/css/gc.spread.sheets.excel2013white.16.0.5.css" rel="stylesheet" />

        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/gc.spread.sheets.all.16.0.5.min.js"></script>
        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/plugins/gc.spread.sheets.charts.16.0.5.min.js"></script>
        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/plugins/gc.spread.sheets.shapes.16.0.5.min.js"></script>
        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/plugins/gc.spread.sheets.slicers.16.0.5.min.js"></script>

        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/plugins/gc.spread.sheets.print.16.0.5.min.js"></script>
        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/plugins/gc.spread.sheets.barcode.16.0.5.min.js"></script>
        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/plugins/gc.spread.sheets.pdf.16.0.5.min.js"></script>
        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/plugins/gc.spread.sheets.tablesheet.16.0.5.min.js"></script>
        <script type="text/javascript" src="https://cdn.grapecity.com/spreadjs/hosted/scripts/interop/gc.spread.excelio.16.0.5.min.js"></script>

        <script src="_content/SJS_Blazor_Lib/exampleJsInterop.js" type="text/javascript"></script>
    </head>

    <body>
        <app>Loading...</app>

        <div id="blazor-error-ui">
            An unhandled error has occurred.
            <a href="" class="reload">Reload</a>
            <a class="dismiss">??</a>
        </div>
        <script src="_framework/blazor.webassembly.js"></script>
    </body>

    </html>
```

We can also edit the code in Index.razor in the “Pages” folder:

(Index.razor)

```
    @page "/"

    @using SJS_Blazor_Lib

    <h1>Hello, SpreadJS!</h1>

    <table>
        <tr>
            <td>
                <label>Sheet Index</label>
                <input @bind-value="@SheetIndex" />
            </td>
            <td>
                <label>Row Index</label>
                <input @bind-value="@Row" />
            </td>
            <td>
                <label>Column Index</label>
                <input @bind-value="@Column" />
            </td>
            <td>
                <lable>Value</lable>
                <input @bind-value="@Value" />
            </td>
        </tr>
        <tr>
            <td>
                <button @onclick="doSomething">Update Text</button>
            </td>
        </tr>
        <tr>
            <td>
                <input type="file" @ref="inputFileEle" />
            </td>
            <td>
                <button @onclick="ImportExcel">Import File</button>
            </td>
        </tr>
    </table>
    <br />
    <SpreadJS SheetCount="3" HostStyle="@HostStyle" @ref="ss" />

    @code {
        private SpreadJS ss;

        private ElementReference inputFileEle;

        public int SheetIndex { get; set; } = 0;

        public int Row { get; set; } = 0;

        public int Column { get; set; } = 0;

        public string Value { get; set; } = "";

        private string HostStyle { get; set; } = "width:90wh;height:70vh;border: 1px solid darkgray";

        private void doSomething()
        {
            ss.setValue(SheetIndex, Row, Column, Value);
        }

        private void ImportExcel()
        {
            ss.OpenExcel(inputFileEle);
        }
    }
```

That is all that is needed to run SpreadJS in a Blazor application:

![SpreadJS in a Blazor application](https://files.grapecity.com/gc-website-media/lb5hvcsa/06-spread.png?width=500&height=269.7916666666667)

## <a id="import"></a>Blazor Excel Import

The previous code was just a basic usage of SpreadJS in a Blazor application, but we can add to it by including some Excel Import functionality. With the power of SpreadJS, you can import your own Excel files within your Blazor applications. The implementation is similar to the basic SpreadJS Blazor code, but we would need to edit the Index.razor file to add some code for setting values and opening Excel files:

```
    @page "/"

    @using SpreadJS_Blazor_Lib

    <h1>Hello, SpreadJS!</h1>

    <table>
        <tr>
            <td>
                <label>Sheet Index</label>
                <input @bind-value="@SheetIndex" />
            </td>
            <td>
                <label>Row Index</label>
                <input @bind-value="@Row" />
            </td>
            <td>
                <label>Column Index</label>
                <input @bind-value="@Column" />
            </td>
            <td>
                <lable>Value</lable>
                <input @bind-value="@Value" />
            </td>
        </tr>
        <tr>
            <td>
                <button @onclick="doSomething">Update Text</button>
            </td>
        </tr>
        <tr>
            <td>
                <input type="file" @ref="inputFileEle" @onchange="ImportExcel" />
            </td>
        </tr>
    </table>
    <br />
    <SpreadJS SheetCount="3" HostStyle="@HostStyle" @ref="ss" />

    @code {
        private SpreadJS ss;

        private ElementReference inputFileEle;

        public int SheetIndex { get; set; } = 0;

        public int Row { get; set; } = 0;

        public int Column { get; set; } = 0;

        public string Value { get; set; } = "";

        private string HostStyle { get; set; } = "width:90wh;height:70vh;border: 1px solid darkgray";

        private void doSomething()
        {
            ss.setValue(SheetIndex, Row, Column, Value);
        }

        private void ImportExcel()
        {
            ss.OpenExcel(inputFileEle);
        }
    }
```

Once we have that code in Index.razor, it should work to import as we have already added the code in previous steps for the SpreadJS.razor and exampleJsInterop.js files in the SpreadJS_Blazor_Lib project.

## <a id="export"></a>Blazor Excel Export

In addition, we can also add functionality for exporting Excel files. To do this, we need to add code to the exampleJsInterop.js file:

```
    window.sjsAdaptor = {
        (....)
        saveExcel: function (host) {
            var spread = GC.Spread.Sheets.findControl(host);
            if (spread) {
                var json = spread.toJSON();
                var excelIO = new GC.Spread.Excel.IO();
                excelIO.save(json, function (blob) {
                    saveAs(blob, "export.xlsx");
                }, function (e) {
                    console.log(e);
                });
            }
        }
    };
```

For the “saveAs” function to work, we also need to add a reference to the FileSaver library in the index.html file:

```
    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.0/FileSaver.min.js"></script>
```

To have this code work on the page, we need to add the button for exporting to the Index.razor code:

```
    @page "/"

    @using SpreadJS_Blazor_Lib

    <h1>Hello, SpreadJS!</h1>

    <table>

        (....)

            <td>
                <button @onclick="ExportExcel">Export File</button>
            </td>
        </tr>
    </table>
    <br />
    <SpreadJS SheetCount="3" HostStyle="@HostStyle" @ref="ss" />

    @code {

        (....)

        private void ExportExcel()
        {
            ss.SaveExcel();
        }
    }
```

The “ss.SaveExcel()” call uses the code in the SpreadJS.razor file, so we need to make sure we add code in there that points to the right function in the exampleJsInterop.js file:

```
    @using Microsoft.JSInterop
    @inject IJSRuntime JSRuntime

    <div @ref="host"></div>

    @code {

        (....)

        public void SaveExcel()
        {
            JSRuntime.InvokeVoidAsync("sjsAdaptor.saveExcel", host);
        }

        (....)
    }
```

![SpreadJS](https://files.grapecity.com/gc-website-media/hnedmakj/07-spread.png?width=500&height=241.37029288702928)

This blog showed how to implement SpreadJS in your Blazor applications and leverage the power of .NET. To try this and see what other amazing features SpreadJS has, download a trial today!