🎯 Why Modern Applications Need a Spreadsheet → Spreadsheet Engine

Business PainWhat Happens Without Sheetize
Scattered Data SourcesKPI numbers sit in CSV exports, sales logs in JSON, product catalogs in HTML, and legacy Excel 95 files – you have to open each file manually and copy‑paste.
Time‑Consuming ConsolidationAnalysts spend hours stitching dozens of files together before they can start analysis.
Inconsistent Layout & FormulasEach workbook has its own styling, named ranges, and hidden sheets, breaking downstream macros and dashboards.
Scalability BottlenecksAd‑hoc scripts can’t keep up with nightly jobs that must merge thousands of source files into a master report.

Solution: Sheetize Spreadsheet Merger for .NET – a single, royalty‑free library that preserves every cell style, formula, chart, and embedded object while merging any of the following source formats into a single output workbook:

Supported Input Formats

  • Spreadsheets: Xlsx, Xlsb, Xlsm, Xltm, Xlam, Excel97To2003, Excel95, SpreadsheetML, Xlt, Csv, Tsv, SqlScript, Dif
  • Markup & e‑books: Xml, Epub, Azw3, Html, MHtml
  • Other data: Json (converted to a formatted table)

Supported Output Formats

  • Xlsx, Xlsb, Xlsm, Xltm, Xlam, Excel97To2003, Excel95, SpreadsheetML, Xlt, Html, MHtml

All conversions happen with zero‑pain code and run on any .NET runtime (Framework 4.x, .NET 6/7/8, Azure Functions, AWS Lambda, etc.).


🚀 Core Benefits at a Glance

FeatureBenefit
One‑Click Multi‑File MergeSupply an array of source paths → get a ready‑to‑use master workbook in seconds.
Preserve Formulas & ChartsNo need to re‑create calculations – existing formulas survive the merge unchanged.
Full Styling FidelityCell colors, fonts, borders, conditional formatting, and merged cells are kept exactly as they appear in the source files.
Cross‑PlatformWorks on Windows, Linux, and macOS .NET runtimes.
Streaming APIMerge using streams → no temporary files, low memory footprint, ideal for cloud‑scale processing.
Transparent LicensingPerpetual runtime license, free updates, no per‑seat fees.
Performance‑OptimizedBench‑marked to merge > 200 source files/sec on an 8‑core VM.

📄 Merging Worksheets – 5‑Line Sample

using Sheetize;

var loadOptions = new LoadOptions(); // common load options for all sources
var saveOptions = new SpreadsheetSaveOptions
{
OutputFile = @"C:\Results\MasterReport.xlsx"
};

SpreadsheetMerger.Process(loadOptions, saveOptions, new[]
{
@"C:\Inputs\Sales_Q1.xlsx",
@"C:\Inputs\Inventory.csv",
@"C:\Inputs\ProductCatalog.html",
@"C:\Inputs\LegacyData.xls",
@"C:\Inputs\Metadata.json"
});

Result: A single workbook (MasterReport.xlsx) that contains a dedicated sheet for each source file, preserving every style, formula, and embedded object. The output can be saved as any of the supported formats (e.g., Html for web preview).


🛡️ Robust Error Handling & Validation

The snippet below shows best‑practice validation:

using Sheetize;
using System;
using System.IO;
using System.Linq;

try
{
// 1️⃣ License activation
var license = new Sheetize.License();
license.SetLicense(@"C:\Licenses\Sheetize.SpreadsheetMerger_for_.NET.lic");

// 2️⃣ Paths
string[] sources = {
@"C:\Data\Quarter1.xlsx",
@"C:\Data\Customers.csv",
@"C:\Data\Catalog.html"
};
string outputPath = @"C:\Data\CombinedReport.xlsb";

// 3️⃣ Supported extensions
var inputExts = new[]
{
".xlsx",".xlsb",".xlsm",".xltm",".xlam",".xls",".xml",
".csv",".tsv",".sqlscript",".dif",".epub",".azw3",
".html",".mhtml",".json"
};
var outputExts = new[]
{
".xlsx",".xlsb",".xlsm",".xltm",".xlam",
".xls",".xml",".xlt",".html",".mhtml"
};

// 4️⃣ Validate output type
if (!outputExts.Contains(Path.GetExtension(outputPath).ToLower()))
throw new InvalidOperationException("Output file must be a supported spreadsheet type.");

// 5️⃣ Validate each source
foreach (var src in sources)
{
if (!File.Exists(src))
throw new FileNotFoundException($"Source not found: {src}");
if (!inputExts.Contains(Path.GetExtension(src).ToLower()))
throw new NotSupportedException($"Unsupported source type: {src}");
}

// 6️⃣ Build options
var loadOpts = new LoadOptions(); // can be customized (e.g., password, sheet filters)
var saveOpts = new SpreadsheetSaveOptions { OutputFile = outputPath };

// 7️⃣ Execute merge
SpreadsheetMerger.Process(loadOpts, saveOpts, sources);
Console.WriteLine($"✅ Merge succeeded – file saved to {outputPath}");
}
catch (Exception ex)
{
// Centralised error logging (Serilog, NLog, Application Insights, etc.)
Console.Error.WriteLine($"❌ Merge failed: {ex.GetType().Name} – {ex.Message}");
// Optionally re‑throw for upstream handling
// throw;
}

🎬 Real‑World Scenarios Powered by Sheetize Spreadsheet Merger

#ScenarioInput TypesOutputBusiness Outcome
1️⃣Monthly KPI DashboardMultiple Xlsx files from different departmentsXlsb (single workbook)Analysts receive one file with all KPI sheets – no manual copy‑pasting.
2️⃣Legacy Data ArchiveExcel95, Dif, CsvSpreadsheetML (XML)Preserve old‑format data in a modern, searchable XML spreadsheet for compliance.
3️⃣E‑book Catalog ConsolidationEpub, Azw3, Html (metadata tables)Html (merged table view)Publish a web‑ready catalogue of all titles with one‑click updates.
4️⃣Automated Invoice PackJson (order feeds) + Xltm (template)Xlsx (filled invoices)Generate a batch of ready‑to‑send invoices without VBA macros.
5️⃣Data‑Lake IngestionTsv, SqlScript, CsvXlsm (with import macros)Load raw data into a macro‑enabled workbook that later pushes to a data warehouse.

📈 Performance & Scaling Tips

TipHow It Helps
Reuse the License objectAvoids repeated I/O → ~10 % speed boost for large batch jobs.
Stream instead of file paths (LoadOptions.InputStream / SpreadsheetSaveOptions.OutputStream)Cuts disk usage, enables processing of GB‑size sources on low‑memory containers.
Parallel merges (Parallel.ForEach on a collection of source‑set groups)Utilises multi‑core VMs to merge many groups concurrently.
Disable unneeded features (IncludeComments = false, EmbedImages = false when not required)Reduces output size and conversion time.
Pre‑filter sheets (LoadOptions.SheetNames = new[] { "Sales", "Summary" })Merges only needed worksheets, saving CPU cycles.

📦 Getting Started in Minutes

# 1️⃣ Install the NuGet package
dotnet add package Sheetize

# 2️⃣ Grab a free trial licence (no credit‑card required)
# https://purchase.sheetize.com/temp-license/113911

# 3️⃣ Place the .lic file in your project, e.g. ./Licenses/Sheetize.SpreadsheetMerger_for_.NET.lic

# 4️⃣ Use the sample code above – compile, run, and watch your master spreadsheet appear!

Frequently Asked Questions

QuestionAnswer
Does the library support .NET 8?Yes – fully tested on .NET 8, .NET 6, and .NET Framework 4.x.
Can I merge directly to HTML?Absolutely – SpreadsheetSaveOptions supports Html and MHtml as output.
What about files larger than 1 GB?Use the streaming API; the library processes data in chunks and keeps memory under 300 MB.
Are formulas recalculated after the merge?Formulas are preserved exactly as they appear; you can trigger a full workbook recalculation via Workbook.Calculate() if needed.
Is there enterprise support?Paid licenses include 24/7 email/Slack support, SLA‑backed bug fixes, and optional on‑prem assistance.

📣 Call‑to‑Action

  1. Download the NuGet packagedotnet add package Sheetize.
  2. Run the “Hello‑Merger” console app using the code snippets above.
  3. Contact our sales team for an enterprise agreement (unlimited merges, dedicated support, on‑prem licensing).

➡️ Grab your trial now: https://purchase.sheetize.com/temp-license/113911

Empower your applications to turn a chaos of files into a single, master‑class spreadsheet – instantly.

More in this category