The C# Excel Library

 Read Excel Files without Interop
using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

 Excel Worksheets
using IronXL;

// Create new Excel spreadsheet
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);

// Create worksheets (workSheet1, workSheet2, workSheet3)
WorkSheet workSheet1 = workBook.CreateWorkSheet("workSheet1");
WorkSheet workSheet2 = workBook.CreateWorkSheet("workSheet2");
WorkSheet workSheet3 = workBook.CreateWorkSheet("workSheet3");

// Set worksheet position (workSheet2, workSheet1, workSheet3)
workBook.SetSheetPosition("workSheet2", 0);

// Set active for workSheet3
workBook.SetActiveTab(2);

// Remove workSheet1
workBook.RemoveWorkSheet(1);

workBook.SaveAs("manageWorkSheet.xlsx");

 Create Excel Files
using IronXL;

// Create new Excel WorkBook document
WorkBook workBook = WorkBook.Create();

// Convert XLSX to XLS
WorkBook xlsWorkBook = WorkBook.Create(ExcelFileFormat.XLS);

// Create a blank WorkSheet
WorkSheet workSheet = workBook.CreateWorkSheet("new_sheet");

// Add data and styles to the new worksheet
workSheet["A1"].Value = "Hello World";
workSheet["A1"].Style.WrapText = true;
workSheet["A2"].BoolValue = true;
workSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Double;

// Save the excel file as XLS, XLSX, CSV, TSV, JSON, XML, HTML and streams
workBook.SaveAs("sample.xlsx");

 Convert Spreadsheet File Types
using IronXL;
using System.IO;

// Import any XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Export the excel file as XLS, XLSX, XLSM, CSV, TSV, JSON, XML
workBook.SaveAs("sample.xls");
workBook.SaveAs("sample.xlsx");
workBook.SaveAs("sample.tsv");
workBook.SaveAsCsv("sample.csv");
workBook.SaveAsJson("sample.json");
workBook.SaveAsXml("sample.xml");

// Export the excel file as Html, Html string
workBook.ExportToHtml("sample.html");
string htmlString = workBook.ExportToHtmlString();

// Export the excel file as Binary, Byte array, Data set, Stream
byte[] binary = workBook.ToBinary();
byte[] byteArray = workBook.ToByteArray();
System.Data.DataSet dataSet = workBook.ToDataSet(); // Allow easy integration with DataGrids, SQL and EF
Stream stream = workBook.ToStream();

 Excel to SQL via System.Data.DataSet
using IronXL;
using System;
using System.Data;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Convert the whole Excel WorkBook to a DataSet
DataSet dataSet = workBook.ToDataSet();

foreach (DataTable table in dataSet.Tables)
{
    Console.WriteLine(table.TableName);

    // Enumerate by rows or columns first at your preference
    foreach (DataRow row in table.Rows)
    {
        for (int i = 0 ; i < table.Columns.Count ; i++)
        {
            Console.Write(row[i]);
        }
    }
}

 Excel to SQL and DataGrid via DataTable
using IronXL;
using System;
using System.Data;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select default sheet
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Convert the worksheet to DataTable
DataTable dataTable = workSheet.ToDataTable(true);

// Enumerate by rows or columns first at your preference
foreach (DataRow row in dataTable.Rows)
{
    for (int i = 0 ; i < dataTable.Columns.Count ; i++)
    {
        Console.Write(row[i]);
    }
}

 Excel Conditional Formatting
using IronXL;
using IronXL.Formatting.Enums;
using IronXL.Styles;

WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Create conditional formatting rule
var rule = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(ComparisonOperator.LessThan, "8");
// Set style options
rule.FontFormatting.IsBold = true;
rule.FontFormatting.FontColor = "#123456";
rule.BorderFormatting.RightBorderColor = "#ffffff";
rule.BorderFormatting.RightBorderType = BorderType.Thick;
rule.PatternFormatting.BackgroundColor = "#54bdd9";
rule.PatternFormatting.FillPattern = FillPattern.Diamonds;
// Apply formatting on specified region
workSheet.ConditionalFormatting.AddConditionalFormatting("A3:A8", rule);

// Create conditional formatting rule
var rule1 = workSheet.ConditionalFormatting.CreateConditionalFormattingRule(ComparisonOperator.Between, "7", "10");
// Set style options
rule1.FontFormatting.IsItalic = true;
rule1.FontFormatting.UnderlineType = FontUnderlineType.Single;
// Apply formatting on specified region
workSheet.ConditionalFormatting.AddConditionalFormatting("A3:A9", rule1);

workBook.SaveAs("applyConditionalFormatting.xlsx");

 Protect Excel Files
using IronXL;

WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Open protected spreadsheet file
WorkBook protectedWorkBook = WorkBook.Load("sample.xlsx", "IronSoftware");

// Spreadsheet protection
// Set protection for spreadsheet file
workBook.Encrypt("IronSoftware");

// Remove protection for spreadsheet file. Original password is required.
workBook.Password = null;

workBook.Save();

// Worksheet protection
// Set protection for individual worksheet
workSheet.ProtectSheet("IronXL");

// Remove protection for particular worksheet. It works without password!
workSheet.UnprotectSheet();

workBook.Save();

 Excel Formulas in C#
using IronXL;
using System.Linq;

WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Set Formulas
workSheet["A1"].Formula = "Sum(B8:C12)";
workSheet["B8"].Formula = "=C9/C11";
workSheet["G30"].Formula = "Max(C3:C7)";

// Force recalculate all formula values in all sheets.
workBook.EvaluateAll();

// Get the formula's calculated value.  e.g. "52"
var formulaValue = workSheet["G30"].First().FormattedCellValue;

// Get the formula as a string. e.g. "Max(C3:C7)"
string formulaString = workSheet["G30"].Formula;

// Save changes with updated formulas and calculated values.
workBook.Save();

 Edit Excel Metadata in C#
using IronXL;
using System;

WorkBook workBook = WorkBook.Load("sample.xlsx");

// Set author
workBook.Metadata.Author = "Your Name";
// Set comments
workBook.Metadata.Comments = "Monthly report";
// Set title
workBook.Metadata.Title = "July";
// Set keywords
workBook.Metadata.Keywords = "Report";

// Read the creation date of the excel file
DateTime? creationDate = workBook.Metadata.Created;

// Read the last printed date of the excel file
DateTime? printDate = workBook.Metadata.LastPrinted;

workBook.SaveAs("editedMetadata.xlsx");

 Update Excel Database Records
using IronXL;
using System.Data;
using System.Data.SqlClient;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Convert the workbook to ToDataSet
DataSet dataSet = workBook.ToDataSet();

// Your sql query
string sql = "SELECT * FROM Users";

// Your connection string
string connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=usersdb;Integrated Security=True";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    // Open connections to the database
    connection.Open();
    SqlDataAdapter adapter = new SqlDataAdapter(sql, connection);

    // Update the values in database using the values in Excel
    adapter.Update(dataSet);
}

 Style Excel Cell Borders & Fonts
using IronSoftware.Drawing;
using IronXL;
using IronXL.Styles;
using System.Linq;

WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();

var range = workSheet["A1:H10"];

var cell = range.First();

// Set background color of the cell with an rgb string
cell.Style.SetBackgroundColor("#428D65");

// Apply styling to the whole range.

// Set underline property to the font
// FontUnderlineType is enum that stands for different types of font underlying
range.Style.Font.Underline = FontUnderlineType.SingleAccounting;

// Define whether to use horizontal line through the text or not
range.Style.Font.Strikeout = false;

// Define whether the font is bold or not
range.Style.Font.Bold = true;

// Define whether the font is italic or not
range.Style.Font.Italic = false;

// Get or set script property of a font
// Font script enum stands for available options
range.Style.Font.FontScript = FontScript.Super;

// Set the type of the border line
// There are also TopBorder,LeftBorder,RightBorder,DiagonalBorder properties
// BorderType enum indicates the line style of a border in a cell
range.Style.BottomBorder.Type = BorderType.MediumDashed;

// Indicate whether the cell should be auto-sized
range.Style.ShrinkToFit = true;

// Set alignment of the cell
range.Style.VerticalAlignment = VerticalAlignment.Bottom;

// Set border color
range.Style.DiagonalBorder.SetColor("#20C96F");

// Define border type and border direction as well
range.Style.DiagonalBorder.Type = BorderType.Thick;

// DiagonalBorderDirection enum stands for direction of diagonal border inside cell
range.Style.DiagonalBorderDirection = DiagonalBorderDirection.Forward;

// Set background color of cells
range.Style.SetBackgroundColor(Color.Aquamarine);

// Set fill pattern of the cell
// FillPattern enum indicates the style of fill pattern
range.Style.FillPattern = FillPattern.Diamonds;

// Set the number of spaces to intend the text
range.Style.Indention = 5;

// Indicate if the text is wrapped
range.Style.WrapText = true;

workBook.SaveAs("stylingOptions.xls");

 Sort Excel Ranges in C#
using IronXL;

WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Select a range
var range = workSheet["A1:D20"];

// Select a column(B)
var column = workSheet.GetColumn(1);

// Sort the range in ascending order (A to Z)
range.SortAscending();

// Sort the range by column(C) in ascending order
range.SortByColumn("C", SortOrder.Ascending);

// Sort the column(B) in descending order (Z to A)
column.SortDescending();

workBook.SaveAs("sortExcelRange.xlsx");

 Repeat Excel Rows & Columns
using IronXL;

WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Set repeating rows for row(2-4)
workSheet.SetRepeatingRows(1, 3);

// Set repeating columns for column(C-D)
workSheet.SetRepeatingColumns(2, 3);

// Set column break after column(H). Hence, the first page will only contain column(A-G)
workSheet.SetColumnBreak(7);

workBook.SaveAs("repeatingRows.xlsx");

 Excel Print Setup
using IronXL;
using IronXL.Printing;

WorkBook workBook = WorkBook.Load("sample.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Set the print header and footer of the worksheet
workSheet.Header.Center = "My document";
workSheet.Footer.Center = "Page &P of &N";

// Set the header margin
workSheet.PrintSetup.HeaderMargin = 2.33;

// Set the size of the paper
// Paper size enum represents different sizes of paper
workSheet.PrintSetup.PaperSize = PaperSize.B4;

// Set the print orientation of the worksheet
workSheet.PrintSetup.PrintOrientation = PrintOrientation.Portrait;

// Set black and white printing
workSheet.PrintSetup.NoColor = true;

workBook.SaveAs("PrintSetup.xlsx");

 Cell Data Display Format
using IronXL;
using System;
using System.Linq;

// Load an existing WorkSheet
WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();

// Set data display format to cell
// The cell value will look like 12300%
workSheet["A2"].Value = 123;
workSheet["A2"].FormatString = "0.0%";

// The cell value will look like 123.0000
workSheet["A2"].First().FormatString = "0.0000";

// Set data display format to range
DateTime dateValue = new DateTime(2020, 1, 1, 12, 12, 12);
workSheet["A3"].Value = dateValue;
workSheet["A4"].First().Value = new DateTime(2022, 3, 3, 10, 10, 10);
workSheet["A5"].First().Value = new DateTime(2021, 2, 2, 11, 11, 11);

var range = workSheet["A3:A5"];

// The cell(A3) value will look like 1/1/2020 12:12:12 PM
range.FormatString = "MM/dd/yy h:mm:ss";

workBook.SaveAs("numberFormats.xls");

 Load Excel From SQL Database
using IronXL;
using System.Data;
using System.Data.SqlClient;

// Your sql query
string sql = "SELECT * FROM Users";

// Your connection string
string connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=usersdb;Integrated Security=True";

using (SqlConnection connection = new SqlConnection(connectionString))
{
    // Open connections to the database
    connection.Open();
    SqlDataAdapter adapter = new SqlDataAdapter(sql, connection);
    DataSet ds = new DataSet();
    // Fill DataSet with data
    adapter.Fill(ds);

    // Create an Excel workbook from the SQL DataSet
    WorkBook workBook = WorkBook.Load(ds);
}

 Combine Excel Ranges
using IronXL;
using System;
using System.Linq;

WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();

// Get a range from an Excel worksheet
var range = workSheet["A2:A8"];

// Combine two ranges
var combinedRange = range + workSheet["A9:A10"];

// Iterate over combined range
foreach (var cell in combinedRange)
{
    Console.WriteLine(cell.Value);
}

 Select Excel Range
using IronXL;
using System;
using System.Linq;

WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();

// Get range from worksheet
var range = workSheet["A2:A8"];

// Get column from worksheet
var columnA = workSheet.GetColumn(0);

// Get row from worksheet
var row1 = workSheet.GetRow(0);

// Iterate over the range
foreach (var cell in range)
{
    Console.WriteLine($"{cell.Value}");
}

// Select and print every row
var rows = workSheet.Rows;

foreach (var eachRow in rows)
{
    foreach (var cell in eachRow)
    {
        Console.Write($"  {cell.Value}  |");
    }
    Console.WriteLine($"");
}

 Convert Excel to HTML
using IronXL;
using IronXL.Options;

WorkBook workBook = WorkBook.Load("sample.xlsx");

var options = new HtmlExportOptions()
{
    // Set row/column numbers visible in html document
    OutputRowNumbers = true,
    OutputColumnHeaders = true,

    // Set hidden rows/columns visible in html document
    OutputHiddenRows = true,
    OutputHiddenColumns = true,

    // Set leading spaces as non-breaking
    OutputLeadingSpacesAsNonBreaking = true
};

// Export workbook to the HTML file
workBook.ExportToHtml("workBook.html", options);

 Aggregate Excel Functions
using IronXL;
using System.Linq;

WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();

// Get range from worksheet
var range = workSheet["A1:A8"];

// Apply sum of all numeric cells within the range
decimal sum = range.Sum();

// Apply average value of all numeric cells within the range
decimal avg = range.Avg();

// Identify maximum value of all numeric cells within the range
decimal max = range.Max();

// Identify minimum value of all numeric cells within the range
decimal min = range.Min();

 Create Excel Line Chart
using IronXL;
using IronXL.Drawing.Charts;

WorkBook workBook = WorkBook.Load("test.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Set the chart type and it's position  on the worksheet.
var chart = workSheet.CreateChart(ChartType.Line, 10, 10, 18, 20);

// Add the series to the chart
// The first parameter represents the address of the range for horizontal(category) axis.
// The second  parameter represents the address of the range for vertical(value) axis.
var series = chart.AddSeries("B3:B8", "A3:A8");

// Set the chart title.
series.Title = "Line Chart";

// Set the legend position.
// Can be removed by setting it to None.
chart.SetLegendPosition(LegendPosition.Bottom);

// We can change the position of the chart.
chart.Position.LeftColumnIndex = 2;
chart.Position.RightColumnIndex = chart.Position.LeftColumnIndex + 3;

// Plot all the data that was added to the chart before.
// Multiple call of this method leads to plotting multiple charts instead of modifying the existing chart.
// Yet there is no possibility to remove chart or edit it's series/position.
// We can just create new one.
chart.Plot();

workBook.SaveAs("CreateLineChart.xlsx");

 Freeze Panes in Excel
using IronXL;
using System.Linq;

WorkBook workBook = WorkBook.Load("sample.xls");
WorkSheet workSheet = workBook.WorkSheets.First();

// Create freeze pane from column(A-B) and row(1-3)
workSheet.CreateFreezePane(2, 3);

// Overwriting freeze or split pane to column(A-E) and row(1-5) as well as applying prescroll
// The column will show E,G,... and the row will show 5,8,...
workSheet.CreateFreezePane(5, 5, 6, 7);

workBook.SaveAs("createFreezePanes.xls");

// Remove all existing freeze or split pane
workSheet.RemovePane();

 Copy Excel Worksheets
using IronXL;

WorkBook firstBook = WorkBook.Load("sample.xlsx");
WorkBook secondBook = WorkBook.Create();

// Select first worksheet in the workbook
WorkSheet workSheet = firstBook.DefaultWorkSheet;

// Duplicate the worksheet to the same workbook
workSheet.CopySheet("Copied Sheet");

// Duplicate the worksheet to another workbook with the specified name
workSheet.CopyTo(secondBook, "Copied Sheet");

firstBook.Save();
secondBook.SaveAs("copyExcelWorksheet.xlsx");

Using IronXL

July 1, 2024

How to Import Excel to SQL Server in C#

In many different business contexts, importing data from Excel into SQL Server is a typical necessity. Reading data from an Excel file and entering it into a SQL Server database are the tasks involved in this activity

April 29, 2024

How to Use C# Excel Font Style

However, this option isn't as flexible or convenient as alternative _solutions._ Hence, this post will discuss using IronXL, on how to use C# Excel to set font style.

April 29, 2024

How to Rename Excel WorkSheet in C#

In this article, we'll explore how to rename Excel files using IronXL library from IronSoftware.

April 29, 2024

How to Autofit Cells in Excel Using C#

In this article, we will learn how to autofit column width and height in Excel using C# and IronXL.

April 29, 2024

How to Create a new Excel Workbook in C#

We'll walk through the necessary steps, from setting up your development environment to writing the code that generates a new Excel workbook.

April 29, 2024

How to parse an Excel file in Python

We will examine how to parse an Excel file in Python using IronXL in this in-depth tutorial.

April 3, 2024

How to Read an Excel File in a C# Console Application

This article will guide you through the process of reading Excel files in a C# Console Application using the IronXL library

January 27, 2024

How to Export Datagridview To Excel in C#

This tutorial provides a comprehensive guide on how to export data from a DataGridView control in a Windows Forms Application to an Excel file using the IronXL library in C#

January 27, 2024

How to Read Data From CSV File And Store It In Database C#

This tutorial covers the steps to read data from a CSV file and store it in an SQL Server Database using C#, specifically utilizing the IronXL library

January 27, 2024

How to Import an Excel File to SQL Database in VB .NET

In this article, we are going to see how VB .NET imports Excel files into the SQL Server database table without using the provider Microsoft.ace.oledb 12.0 data.

January 27, 2024

How to Import CSV To Datatable in C#

January 27, 2024

How to Convert CSV File Into List in C#

In this tutorial for beginners, we are going to see how to read CSV files into a list in C# using the IronXL

January 27, 2024

How to Save An Excel File in VB .NET

In this article, we're going to look at how you can use VB.NET to save Excel files with the help of IronXL.

January 27, 2024

How to Convert An Excel File to XML in C#

It is an essential tool for organizing, evaluating, and using data to inform choices. In the article, we are going to learn how to convert Excel to XML in C#.

January 14, 2024

C# Excel Automation (Developer Tutorial)

In this article, we are going to see more about Excel automation in C#

January 14, 2024

C# Excel Library Without Office (Beginner Tutorial)

This makes it a go-to solution for server environments where installing Microsoft Office is not feasible due to licensing or server performance constraints.

January 4, 2024

How to Convert Excel to Datatable in C# Without oledb

In this article, we are going to convert Excel to datatable in C# without OLEDB connectivity.

January 4, 2024

How to Concatenate or Merge Excel Files in C# Combine XLS

IronXL is a powerful Excel library that can be used to perform various types of Excel operations. In this article, we are going learn how to concatenate or merge Excel files in C# combine xls.

November 22, 2023

How to Write A CSV File in C#

In this article, we will see how to write CSV files using a C# library named IronXL in a new project.

November 22, 2023

How to Load An Excel File in C#

To organize operations like arithmetic calculations and other data manipulations, spreadsheets such as Excel use a grid of cells arranged in numbered rows and letter-named columns.

November 22, 2023

C# CSV Library (Developer Tutorial)

In this article, we will delve into the world of C# exploring the features, methods, and techniques to efficiently work with any CSV file

November 22, 2023

How to Export to CSV in .NET Core

It will also build an environment for reading, writing, and exporting Excel spreadsheets to CSV files.

November 14, 2023

How to Export to Excel With Formatting in C#

In this article, we'll discuss methods for exporting data from a CSV file to visually engaging Excel spreadsheets with cell stylings using IronXL.

November 14, 2023

How to Export File to CSV in C#

IronXL. Moreover, it will create a setting for writing, reading, and exporting Excel spreadsheets to CSV files.

November 14, 2023

How to Edit a Spreadsheet in C#

In this article, we will explore the art of spreadsheet manipulation in C#, with the help of most advanced C# data manipulating Library named as IronXL without interacting with the user interface.

November 14, 2023

How to Save A CSV File in C#

In this article we will use IronXL's market leading data manipulating library to save spreadsheets as a CSV File and how it can be used also in writing data to CSV files.

November 13, 2023

.NET Excel Library (Developer Tutorial)

Documents created in Microsoft Excel can be read and converted to CSV files using the C# IronXL, .NET Excel library

July 22, 2023

How to Merge Cells in Excel Without Losing Data

IronXL allows us to merge multiple columns/cells in the existing Excel sheets. Below is the sample code to merge multiple cells.

July 22, 2023

How to Open Excel File in ASP .NET Core

In this tutorial, we will learn how to open an Excel file using IronXL in an ASP.NET Core application using the IronXL library.

June 28, 2023

How to Convert XLS to XLSX File in C#

Here in this article, we are going to explore the IronXL library to convert XLS to XLSX format in the C# console application.

June 27, 2023

How to View Excel in ASP.NET

In this tutorial, we'll create an Excel viewer with ASP.NET MVC and IronXL, allowing users to display, edit, and navigate Excel files on their webpage.

June 20, 2023

How To Write Data in CSV File in C#

Let's explore how IronXL allows you to save or export data from Excel files to various formats such as CSV or DataTable programmatically.

June 20, 2023

How To Set Background Color in Excel Cell Using C#

In C#, Excel is commonly used for spreadsheets and provides numerous formatting options, such as setting cell background colors. IronXL offers the simplest way to style cells.

June 20, 2023

How To Disable Protected View in Excel Using C#

In this article we will see how you can easily disable the excel protected view message using Advance C# Excel Library IronXL.

June 20, 2023

How to Open Excel File and Write Data in C#

This article explores using the IronXL library to read and write data to an Excel file in a C# console application with utmost efficiency.

June 6, 2023

How to Export Huge Data From Datatable to Excel in C#

With a simple line of code, IronXL provides an effective approach in C# for exporting a large amount of data from a DataTable to an Excel sheet.

May 23, 2023

How to Convert Excel to Datatable in C#

This Excel to DataTable conversion can be done easily using IronXL, which provides an efficient method to handle Excel files in C#.

May 23, 2023

How to Export to CSV in Blazor

By the end of this tutorial, you'll be able to create a basic Blazor application that exports Excel data in various formats, including CSV.

May 23, 2023

How to Convert Excel to Datagridview in C#

IronXL is a powerful C# library that enables Excel file reading with minimal code. Exporting data to a DataGridView demonstrates its efficiency in working with various Excel formats.

May 8, 2023

How to Export File to Excel in .NET 6

Exporting data to Excel format can be easily done using IronXL. We can export data into various file types, such as XLS, XLSX, CSV, JSON, and XML, using IronXL.

May 1, 2023

How to Read Excel Data and Insert to Database Table in C#

IronXL provides excellent Excel support, ensuring a smooth process when it comes to extracting data from Excel sheets and inserting it into database tables.

April 19, 2023

How to Convert Dataset to Excel in C#

In this article, we will explore how to use C# to export data from a dataset to an Excel spreadsheet using a market-leading C# Excel library

April 19, 2023

How to Read CSV File in C#

In this article, we will explore how to create a C# CSV Reader using the IronXL library and utilize its powerful capabilities to interact with various Excel formats.

April 19, 2023

How to Get Cell Value From Excel File in C#

Understanding how to retrieve cell values in C# can help you manipulate and analyze data in Excel more efficiently and effectively.

April 19, 2023

How to Export Datatable to CSV in C#

With IronXL, we can export and save files with a wide range of suffixes, including XLS, CSV, TSV, JSON, and others in a few lines of code.

April 18, 2023

How to Convert Dataset to CSV in C#

In the following article, we will learn about converting a C# dataset into a CSV file using IronXL at our convenience to enhance productivity.

April 18, 2023

How to Import Excel File in C#

IronXL allows developers to import and read Excel files in C# without needing Excel installed.

April 18, 2023

How to Export Datatable to Excel in ASP.NET Core

In this article, we will explore the different ways to export DataTable to Excel file and the benefits of doing so.

March 30, 2023

How to Export DataTable to Excel in the Fastest Way

This article demonstrates how to create a datatable in C# and export it to an Excel document using the IronXL .NET Excel library, while maintaining full Excel feature compatibility.

March 29, 2023

How to Export Datatable to Excel in VB.NET

The IronXL library enables manipulation of Excel files in VB.NET, including exporting DataTables into different file formats with just a few lines of code.

March 28, 2023

How to Export to Excel in ASP.NET Core

In this tutorial, we'll delve into the process of exporting data from an Excel file into JSON, CSV, or XML formats using ASP.NET Core.

March 27, 2023

How to Unhide All Rows in Excel

This article covers how to unhide all rows and columns in Excel and IronXL for improved data access and productivity.

March 26, 2023

How to Export CSV and Excel in Razor

Web development that interacts with Excel and CSV files is simplified by Razor and IronXL for productivity.

March 25, 2023

How to Freeze a Row in Excel (Beginner Guide)

IronXL offer features like freeze panes to view content from different workbook areas simultaneously, enhancing productivity.

March 24, 2023

How to Write to Excel File in VB.NET

Microsoft Excel can be automated for data input and analysis using VB.NET to streamline processes and save time. IronXL helps to speed up this process.

March 19, 2023

How to Open Excel File in C#

This tutorial examines how IronXL can open, read, and edit Excel documents in C# projects, a vital part of modern business applications.

March 18, 2023

How to Read Excel File in C#

IronXL is a C# Excel data reader library that allows developers to read, write, and manipulate Excel files without the need for Microsoft Excel on the machine.

February 27, 2023

How to Convert a Table to a Range in Excel

This guide explains the process of transforming Excel data into a formatted table. IronXL is included to enhance interaction with tables, rows, columns, and cells.

February 26, 2023

How to Fetch Data From Excel Sheet in C#

This tutorial explores how to fetch data from Excel sheets and put it into DataTables in C# using IronXL.

February 12, 2023

C# CSV Parser (Step-By-Step) Tutorial

The IronXL library helps to parse CSV files and convert them to XLSX or XLS files programmatically and efficiently with two lines of code.

February 11, 2023

How to Create CSV File in C# (Step-By-Step) Tutorial

The IronXL library assists in creating CSV files from data using the C#.NET class library in console applications in the most efficient manner.

December 6, 2022

How to Export Data to Excel in Blazor Using IronXL

This tutorial will simplify the process of exporting data to Excel files in a Blazor Server App with an appealing presentation, without the need for additional component installation.

November 14, 2022

How to Generate an Excel File on Razor Pages

This tutorial provides a straightforward method for generating and exporting Excel files or Excel reports with dummy data and header rows in Razor Pages using IronXL.

September 15, 2022

How to Use a CSV Parser in C#

IronXL C# library enables easy creation of CSV parsers, simplifying the process for users with different expertise levels.

June 29, 2022

Read CSV File Using C# (Code Example Tutorial)

The IronXL library provides an easy way to read CSV files in C#. Converting and editing Excel files has never been easier.

June 28, 2022

C# Open Excel File Programmatically (Code Example Tutorial)

Creating XLSX files programmatically can quickly become complicated. The IronXL C# library helps to simplify this process.

June 27, 2022

How to Highlight Every Other Row in Excel

We often highlight Excel rows to emphasize important data. IronXL can automate this process, enhancing productivity.

June 26, 2022

Datatable to Excel in C# (Code Example Tutorial)

This guide will show you how to create an Excel file and efficiently export a DataTable to an Excel sheet using IronXL. This C# library offers a programmatic and automated way to interact with Excel files.

June 23, 2022

How to Move Rows in Excel

There are various ways to move rows or selected cells in Excel. The IronXL C# library offers programmatic ways to interact with rows, columns, and cells.

February 25, 2022

How to Merge Cells in Excel: Step by Step Tutorial

Learning how to merge cells in Microsoft Excel and automate those common tasks using IronXL in C# to enhance productivity.

February 24, 2022

How to Lock Cells in Excel: a Step by Step Tutorial

Securing cells in Excel effectively locks editing and customization, ensuring confidentiality. Implementing the IronXL C# library enables a quick process and delivers a secure Excel file.

December 9, 2021

Reading CSV Files in C#: a Tutorial

The IronXL C# library offers first-class support for interacting with CSV files. This includes reading, writing, and complex parsing for each data type, thereby optimizing productivity.

October 7, 2020