C# Create Excel File Tutorial

using IronXL;

// Instantiate a new workbook with the default format XLSX
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);

// Create a new worksheet in the workbook
var workSheet = workBook.CreateWorkSheet("example_sheet");

// Set the value of cell A1 to "Example"
workSheet["A1"].Value = "Example";

// Set the value of cells A2, A3, and A4 to 5
workSheet["A2:A4"].Value = 5;

// Change the background color of cell A5 to light gray
workSheet["A5"].Style.SetBackgroundColor("#f0f0f0");

// Set the font style to bold for cells A5 and A6
workSheet["A5:A6"].Style.Font.Bold = true;

// Set a formula in cell A6 to calculate the sum of cells A2 through A4
workSheet["A6"].Formula = "=SUM(A2:A4)";

// Calculate the formula to ensure the cell displays the result
workSheet.EvaluateAll();

// Check if the calculated value of cell A6 matches the expected sum of A2 through A4
if (workSheet["A6"].IntValue == (workSheet["A2"].IntValue + workSheet["A3"].IntValue + workSheet["A4"].IntValue))
{
    // Output a success message if the test passes
    Console.WriteLine("Basic test passed");
}

// Save the workbook as an XLSX file
workBook.SaveAs("example_workbook.xlsx");

Imports IronXL



' Instantiate a new workbook with the default format XLSX

Private workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)



' Create a new worksheet in the workbook

Private workSheet = workBook.CreateWorkSheet("example_sheet")



' Set the value of cell A1 to "Example"

Private workSheet("A1").Value = "Example"



' Set the value of cells A2, A3, and A4 to 5

Private workSheet("A2:A4").Value = 5



' Change the background color of cell A5 to light gray

workSheet("A5").Style.SetBackgroundColor("#f0f0f0")



' Set the font style to bold for cells A5 and A6

workSheet("A5:A6").Style.Font.Bold = True



' Set a formula in cell A6 to calculate the sum of cells A2 through A4

workSheet("A6").Formula = "=SUM(A2:A4)"



' Calculate the formula to ensure the cell displays the result

workSheet.EvaluateAll()



' Check if the calculated value of cell A6 matches the expected sum of A2 through A4

If workSheet("A6").IntValue = (workSheet("A2").IntValue + workSheet("A3").IntValue + workSheet("A4").IntValue) Then

	' Output a success message if the test passes

	Console.WriteLine("Basic test passed")

End If



' Save the workbook as an XLSX file

workBook.SaveAs("example_workbook.xlsx")

// Import necessary namespaces for dealing with Excel files
using GemBox.Spreadsheet;

// The main code execution starts here.

// Initialize GemBox Spreadsheet by setting the license. 
// You can replace "FREE-LIMITED-KEY" with your own license key if you have one.
SpreadsheetInfo.SetLicense("FREE-LIMITED-KEY");

// Create a new Excel file represented by a Workbook object.
// GemBox.Spreadsheet provides a simple way to create, read, write, and manipulate Excel spreadsheet files.
var workbook = new ExcelFile();

// Add a new worksheet to the workbook.
// In this example, we'll create a single worksheet named "Sheet1".
var worksheet = workbook.Worksheets.Add("Sheet1");

// Example of writing data to cells in the worksheet.
// Let's set the value of the first cell (A1) in the worksheet to "Hello, World!".
worksheet.Cells["A1"].Value = "Hello, World!";

// Save the workbook to a file in Excel format, such as XLSX.
// You can adjust the path and filename as needed for your application.
workbook.Save("output.xlsx");

// Note:
// - GemBox.Spreadsheet is a third-party library used for processing Excel files without needing Excel installed.
// - The code might require adding the GemBox.Spreadsheet library to your project through NuGet or direct download.
// - Ensure that you have the correct setup and licensing to avoid any runtime issues.

' Import necessary namespaces for dealing with Excel files

Imports GemBox.Spreadsheet



' The main code execution starts here.



' Initialize GemBox Spreadsheet by setting the license. 

' You can replace "FREE-LIMITED-KEY" with your own license key if you have one.

SpreadsheetInfo.SetLicense("FREE-LIMITED-KEY")



' Create a new Excel file represented by a Workbook object.

' GemBox.Spreadsheet provides a simple way to create, read, write, and manipulate Excel spreadsheet files.

Dim workbook = New ExcelFile()



' Add a new worksheet to the workbook.

' In this example, we'll create a single worksheet named "Sheet1".

Dim worksheet = workbook.Worksheets.Add("Sheet1")



' Example of writing data to cells in the worksheet.

' Let's set the value of the first cell (A1) in the worksheet to "Hello, World!".

worksheet.Cells("A1").Value = "Hello, World!"



' Save the workbook to a file in Excel format, such as XLSX.

' You can adjust the path and filename as needed for your application.

workbook.Save("output.xlsx")



' Note:

' - GemBox.Spreadsheet is a third-party library used for processing Excel files without needing Excel installed.

' - The code might require adding the GemBox.Spreadsheet library to your project through NuGet or direct download.

' - Ensure that you have the correct setup and licensing to avoid any runtime issues.

// This C# code snippet assumes that there's a defined Workbook class
// with a CreateWorkSheet method. It demonstrates the creation of a 
// worksheet in a workbook using a simple simulation for educational purposes.

using System;

namespace WorkbookExample
{
    // Simulating a Workbook class for demonstration purposes.
    public class Workbook
    {
        // Method to create a worksheet given a name.
        public Worksheet CreateWorkSheet(string name)
        {
            // Validation check: Ensure the name is not null or empty.
            if (string.IsNullOrWhiteSpace(name))
            {
                throw new ArgumentException("Worksheet name cannot be null or empty.");
            }

            // Creating a new Worksheet object with the provided name.
            Console.WriteLine($"Worksheet '{name}' created successfully.");
            return new Worksheet() { Name = name };
        }
    }

    // Simulating a Worksheet class for demonstration purposes.
    public class Worksheet
    {
        // Property to store the name of the worksheet.
        public string Name { get; set; }
    }
}

// This part of the code demonstrates the use of Workbook and Worksheet classes.
// The following code is executed at the top-level and demonstrates creating a worksheet.
Workbook workbook = new Workbook(); // Create a new Workbook instance.
Worksheet worksheet = workbook.CreateWorkSheet("2020 Budget"); // Create a new worksheet with a specified name.

' This C# code snippet assumes that there's a defined Workbook class

' with a CreateWorkSheet method. It demonstrates the creation of a 

' worksheet in a workbook using a simple simulation for educational purposes.



Imports System



Namespace WorkbookExample

	' Simulating a Workbook class for demonstration purposes.

	Public Class Workbook

		' Method to create a worksheet given a name.

		Public Function CreateWorkSheet(ByVal name As String) As Worksheet

			' Validation check: Ensure the name is not null or empty.

			If String.IsNullOrWhiteSpace(name) Then

				Throw New ArgumentException("Worksheet name cannot be null or empty.")

			End If



			' Creating a new Worksheet object with the provided name.

			Console.WriteLine($"Worksheet '{name}' created successfully.")

			Return New Worksheet() With {.Name = name}

		End Function

	End Class



	' Simulating a Worksheet class for demonstration purposes.

	Public Class Worksheet

		' Property to store the name of the worksheet.

		Public Property Name() As String

	End Class

End Namespace



' This part of the code demonstrates the use of Workbook and Worksheet classes.

' The following code is executed at the top-level and demonstrates creating a worksheet.

Private workbook As New Workbook() ' Create a new Workbook instance.

Private worksheet As Worksheet = workbook.CreateWorkSheet("2020 Budget") ' Create a new worksheet with a specified name.

// This code assigns the names of the months of the year, from January to December, 
// to the first row in a worksheet, specifically in cells A1 through L1. 
// It assumes that `workSheet` is an instance of a worksheet object, such as one from a 
// spreadsheet library like EPPlus.

workSheet.Cells["A1"].Value = "January";   // Set cell A1 to "January"
workSheet.Cells["B1"].Value = "February";  // Set cell B1 to "February"
workSheet.Cells["C1"].Value = "March";     // Set cell C1 to "March"
workSheet.Cells["D1"].Value = "April";     // Set cell D1 to "April"
workSheet.Cells["E1"].Value = "May";       // Set cell E1 to "May"
workSheet.Cells["F1"].Value = "June";      // Set cell F1 to "June"
workSheet.Cells["G1"].Value = "July";      // Set cell G1 to "July"
workSheet.Cells["H1"].Value = "August";    // Set cell H1 to "August"
workSheet.Cells["I1"].Value = "September"; // Set cell I1 to "September"
workSheet.Cells["J1"].Value = "October";   // Set cell J1 to "October"
workSheet.Cells["K1"].Value = "November";  // Set cell K1 to "November"
workSheet.Cells["L1"].Value = "December";  // Set cell L1 to "December"

' This code assigns the names of the months of the year, from January to December, 

' to the first row in a worksheet, specifically in cells A1 through L1. 

' It assumes that `workSheet` is an instance of a worksheet object, such as one from a 

' spreadsheet library like EPPlus.



workSheet.Cells("A1").Value = "January" ' Set cell A1 to "January"

workSheet.Cells("B1").Value = "February" ' Set cell B1 to "February"

workSheet.Cells("C1").Value = "March" ' Set cell C1 to "March"

workSheet.Cells("D1").Value = "April" ' Set cell D1 to "April"

workSheet.Cells("E1").Value = "May" ' Set cell E1 to "May"

workSheet.Cells("F1").Value = "June" ' Set cell F1 to "June"

workSheet.Cells("G1").Value = "July" ' Set cell G1 to "July"

workSheet.Cells("H1").Value = "August" ' Set cell H1 to "August"

workSheet.Cells("I1").Value = "September" ' Set cell I1 to "September"

workSheet.Cells("J1").Value = "October" ' Set cell J1 to "October"

workSheet.Cells("K1").Value = "November" ' Set cell K1 to "November"

workSheet.Cells("L1").Value = "December" ' Set cell L1 to "December"

// Import relevant namespaces if needed

using System;

// Assume 'workSheet' here is an instance of a class that supports indexing and has a .Value property,
// such as a cell in an Excel sheet. 

// Initialize a random number generator
Random r = new Random();

// This loop populates cells in a worksheet with random numbers
// The numbers in each column increment the range by 1000
for (int i = 2; i <= 11; i++)
{
    // Assign a random number between 1 (inclusive) and 1000 (exclusive) to cell A[i]
    workSheet[$"A{i}"].Value = r.Next(1, 1000);

    // Assign a random number between 1000 (inclusive) and 2000 (exclusive) to cell B[i]
    workSheet[$"B{i}"].Value = r.Next(1000, 2000);

    // Assign a random number between 2000 (inclusive) and 3000 (exclusive) to cell C[i]
    workSheet[$"C{i}"].Value = r.Next(2000, 3000);

    // Assign a random number between 3000 (inclusive) and 4000 (exclusive) to cell D[i]
    workSheet[$"D{i}"].Value = r.Next(3000, 4000);

    // Assign a random number between 4000 (inclusive) and 5000 (exclusive) to cell E[i]
    workSheet[$"E{i}"].Value = r.Next(4000, 5000);

    // Assign a random number between 5000 (inclusive) and 6000 (exclusive) to cell F[i]
    workSheet[$"F{i}"].Value = r.Next(5000, 6000);

    // Assign a random number between 6000 (inclusive) and 7000 (exclusive) to cell G[i]
    workSheet[$"G{i}"].Value = r.Next(6000, 7000);

    // Assign a random number between 7000 (inclusive) and 8000 (exclusive) to cell H[i]
    workSheet[$"H{i}"].Value = r.Next(7000, 8000);

    // Assign a random number between 8000 (inclusive) and 9000 (exclusive) to cell I[i]
    workSheet[$"I{i}"].Value = r.Next(8000, 9000);

    // Assign a random number between 9000 (inclusive) and 10000 (exclusive) to cell J[i]
    workSheet[$"J{i}"].Value = r.Next(9000, 10000);

    // Assign a random number between 10000 (inclusive) and 11000 (exclusive) to cell K[i]
    workSheet[$"K{i}"].Value = r.Next(10000, 11000);

    // Assign a random number between 11000 (inclusive) and 12000 (exclusive) to cell L[i]
    workSheet[$"L{i}"].Value = r.Next(11000, 12000);
}

' Import relevant namespaces if needed



Imports System



' Assume 'workSheet' here is an instance of a class that supports indexing and has a .Value property,

' such as a cell in an Excel sheet. 



' Initialize a random number generator

Private r As New Random()



' This loop populates cells in a worksheet with random numbers

' The numbers in each column increment the range by 1000

For i As Integer = 2 To 11

	' Assign a random number between 1 (inclusive) and 1000 (exclusive) to cell A[i]

	workSheet($"A{i}").Value = r.Next(1, 1000)



	' Assign a random number between 1000 (inclusive) and 2000 (exclusive) to cell B[i]

	workSheet($"B{i}").Value = r.Next(1000, 2000)



	' Assign a random number between 2000 (inclusive) and 3000 (exclusive) to cell C[i]

	workSheet($"C{i}").Value = r.Next(2000, 3000)



	' Assign a random number between 3000 (inclusive) and 4000 (exclusive) to cell D[i]

	workSheet($"D{i}").Value = r.Next(3000, 4000)



	' Assign a random number between 4000 (inclusive) and 5000 (exclusive) to cell E[i]

	workSheet($"E{i}").Value = r.Next(4000, 5000)



	' Assign a random number between 5000 (inclusive) and 6000 (exclusive) to cell F[i]

	workSheet($"F{i}").Value = r.Next(5000, 6000)



	' Assign a random number between 6000 (inclusive) and 7000 (exclusive) to cell G[i]

	workSheet($"G{i}").Value = r.Next(6000, 7000)



	' Assign a random number between 7000 (inclusive) and 8000 (exclusive) to cell H[i]

	workSheet($"H{i}").Value = r.Next(7000, 8000)



	' Assign a random number between 8000 (inclusive) and 9000 (exclusive) to cell I[i]

	workSheet($"I{i}").Value = r.Next(8000, 9000)



	' Assign a random number between 9000 (inclusive) and 10000 (exclusive) to cell J[i]

	workSheet($"J{i}").Value = r.Next(9000, 10000)



	' Assign a random number between 10000 (inclusive) and 11000 (exclusive) to cell K[i]

	workSheet($"K{i}").Value = r.Next(10000, 11000)



	' Assign a random number between 11000 (inclusive) and 12000 (exclusive) to cell L[i]

	workSheet($"L{i}").Value = r.Next(11000, 12000)

Next i

// Import necessary libraries
using System;
using System.Data;
using System.Data.SqlClient;
using OfficeOpenXml; // Assuming usage of EPPlus for Excel operations

// Define and initialize database objects to populate data from the database
string connectionString; // Stores the connection string to connect to the database
string sqlQuery; // Stores the SQL query used to retrieve data from the database
DataSet dataSet = new DataSet("DataSetName"); // DataSet to hold the retrieved data
SqlConnection connection; // SqlConnection object for database connection
SqlDataAdapter dataAdapter; // SqlDataAdapter for executing the query and filling the DataSet

// Set the database connection string 
connectionString = @"Data Source=Server_Name;Initial Catalog=Database_Name;User ID=User_ID;Password=Password";

// Define the SQL Query to obtain data
sqlQuery = "SELECT Field_Names FROM Table_Name";

// Initialize the connection and data adapter objects
connection = new SqlConnection(connectionString);
dataAdapter = new SqlDataAdapter(sqlQuery, connection);

// Open the connection and fill the DataSet with data
try
{
    connection.Open(); // Open the connection to the database
    dataAdapter.Fill(dataSet); // Execute the query and fill the DataSet
}
catch (Exception ex)
{
    // Handle potential exceptions, such as database connection errors
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    // Ensure the connection is closed after the operation
    if (connection != null)
    {
        connection.Close(); // Close the database connection
    }
}

// Assuming 'workSheet' is an EPPlus ExcelWorksheet object set up elsewhere for Excel operations
// Loop through the contents of the DataSet
foreach (DataTable table in dataSet.Tables)
{
    int rowCount = table.Rows.Count; // Get the number of rows in the table
    for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) // Iterate through each row in the table
    {
        // Use the table row index plus an offset to map onto the worksheet row
        int worksheetRowIndex = rowIndex + 12; // Adjust starting index as needed

        // Map each field value to a corresponding cell in the worksheet
        workSheet.Cells["A" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_1"].ToString();
        workSheet.Cells["B" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_2"].ToString();
        workSheet.Cells["C" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_3"].ToString();
        workSheet.Cells["D" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_4"].ToString();
        workSheet.Cells["E" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_5"].ToString();
        workSheet.Cells["F" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_6"].ToString();
        workSheet.Cells["G" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_7"].ToString();
        workSheet.Cells["H" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_8"].ToString();
        workSheet.Cells["I" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_9"].ToString();
        workSheet.Cells["J" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_10"].ToString();
        workSheet.Cells["K" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_11"].ToString();
        workSheet.Cells["L" + worksheetRowIndex].Value = table.Rows[rowIndex]["Field_Name_12"].ToString();
    }
}

' Import necessary libraries

Imports System

Imports System.Data

Imports System.Data.SqlClient

Imports OfficeOpenXml ' Assuming usage of EPPlus for Excel operations



' Define and initialize database objects to populate data from the database

Private connectionString As String ' Stores the connection string to connect to the database

Private sqlQuery As String ' Stores the SQL query used to retrieve data from the database

Private dataSet As New DataSet("DataSetName") ' DataSet to hold the retrieved data

Private connection As SqlConnection ' SqlConnection object for database connection

Private dataAdapter As SqlDataAdapter ' SqlDataAdapter for executing the query and filling the DataSet



' Set the database connection string 

connectionString = "Data Source=Server_Name;Initial Catalog=Database_Name;User ID=User_ID;Password=Password"



' Define the SQL Query to obtain data

sqlQuery = "SELECT Field_Names FROM Table_Name"



' Initialize the connection and data adapter objects

connection = New SqlConnection(connectionString)

dataAdapter = New SqlDataAdapter(sqlQuery, connection)



' Open the connection and fill the DataSet with data

Try

	connection.Open() ' Open the connection to the database

	dataAdapter.Fill(dataSet) ' Execute the query and fill the DataSet

Catch ex As Exception

	' Handle potential exceptions, such as database connection errors

	Console.WriteLine("An error occurred: " & ex.Message)

Finally

	' Ensure the connection is closed after the operation

	If connection IsNot Nothing Then

		connection.Close() ' Close the database connection

	End If

End Try



' Assuming 'workSheet' is an EPPlus ExcelWorksheet object set up elsewhere for Excel operations

' Loop through the contents of the DataSet

For Each table As DataTable In dataSet.Tables

	Dim rowCount As Integer = table.Rows.Count ' Get the number of rows in the table

	For rowIndex As Integer = 0 To rowCount - 1 ' Iterate through each row in the table

		' Use the table row index plus an offset to map onto the worksheet row

		Dim worksheetRowIndex As Integer = rowIndex + 12 ' Adjust starting index as needed



		' Map each field value to a corresponding cell in the worksheet

		workSheet.Cells("A" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_1").ToString()

		workSheet.Cells("B" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_2").ToString()

		workSheet.Cells("C" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_3").ToString()

		workSheet.Cells("D" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_4").ToString()

		workSheet.Cells("E" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_5").ToString()

		workSheet.Cells("F" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_6").ToString()

		workSheet.Cells("G" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_7").ToString()

		workSheet.Cells("H" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_8").ToString()

		workSheet.Cells("I" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_9").ToString()

		workSheet.Cells("J" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_10").ToString()

		workSheet.Cells("K" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_11").ToString()

		workSheet.Cells("L" & worksheetRowIndex).Value = table.Rows(rowIndex)("Field_Name_12").ToString()

	Next rowIndex

Next table

// It appears that you are working with an Excel library, most likely EPPlus, to manipulate Excel spreadsheets.
// The code below assumes that you are iterating over a worksheet object to set the background color
// of the specified range. Ensure that you have included the necessary using directives for your library.

using OfficeOpenXml; // Assuming you are using EPPlus or similar library
using OfficeOpenXml.Style; // For Excel fill styles
using System.Drawing; // For the Color structure

// Assuming 'workSheet' is a valid ExcelWorksheet object that you want to modify
// This code sets the background color of the range from cell A1 to L1 on the worksheet.

void SetBackgroundColor(ExcelWorksheet workSheet)
{
    // Convert the hexadecimal color code to a Color object.
    Color backgroundColor = ColorTranslator.FromHtml("#d3d3d3");

    // Set the background color for the specified range on the worksheet.
    workSheet.Cells["A1:L1"].Style.Fill.PatternType = ExcelFillStyle.Solid;
    workSheet.Cells["A1:L1"].Style.Fill.BackgroundColor.SetColor(backgroundColor);
}

// Note: The above code assumes you have an existing Excel package and worksheet.
// Make sure that your project includes the EPPlus NuGet package and any relevant libraries.

' It appears that you are working with an Excel library, most likely EPPlus, to manipulate Excel spreadsheets.

' The code below assumes that you are iterating over a worksheet object to set the background color

' of the specified range. Ensure that you have included the necessary using directives for your library.



Imports OfficeOpenXml ' Assuming you are using EPPlus or similar library

Imports OfficeOpenXml.Style ' For Excel fill styles

Imports System.Drawing ' For the Color structure



' Assuming 'workSheet' is a valid ExcelWorksheet object that you want to modify

' This code sets the background color of the range from cell A1 to L1 on the worksheet.



Private Sub SetBackgroundColor(ByVal workSheet As ExcelWorksheet)

	' Convert the hexadecimal color code to a Color object.

	Dim backgroundColor As Color = ColorTranslator.FromHtml("#d3d3d3")



	' Set the background color for the specified range on the worksheet.

	workSheet.Cells("A1:L1").Style.Fill.PatternType = ExcelFillStyle.Solid

	workSheet.Cells("A1:L1").Style.Fill.BackgroundColor.SetColor(backgroundColor)

End Sub



' Note: The above code assumes you have an existing Excel package and worksheet.

' Make sure that your project includes the EPPlus NuGet package and any relevant libraries.

// Ensure that the IronXL library is referenced in your project.
using IronXL;

// The following code sets the border styles and colors for different cell ranges in an Excel worksheet.

// Set the top border color of the range A1:L1 to black.
workSheet["A1:L1"].Style.TopBorder.SetColor("#000000");

// Set the bottom border color of the range A1:L1 to black.
workSheet["A1:L1"].Style.BottomBorder.SetColor("#000000");

// Set the right border color of the range L2:L11 to black.
workSheet["L2:L11"].Style.RightBorder.SetColor("#000000");

// Set the right border type of the range L2:L11 to Medium.
workSheet["L2:L11"].Style.RightBorder.Type = IronXL.Styles.BorderType.Medium;

// Set the bottom border color of the range A11:L11 to black.
workSheet["A11:L11"].Style.BottomBorder.SetColor("#000000");

// Set the bottom border type of the range A11:L11 to Medium.
workSheet["A11:L11"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Medium;

' Ensure that the IronXL library is referenced in your project.

Imports IronXL



' The following code sets the border styles and colors for different cell ranges in an Excel worksheet.



' Set the top border color of the range A1:L1 to black.

workSheet("A1:L1").Style.TopBorder.SetColor("#000000")



' Set the bottom border color of the range A1:L1 to black.

workSheet("A1:L1").Style.BottomBorder.SetColor("#000000")



' Set the right border color of the range L2:L11 to black.

workSheet("L2:L11").Style.RightBorder.SetColor("#000000")



' Set the right border type of the range L2:L11 to Medium.

workSheet("L2:L11").Style.RightBorder.Type = IronXL.Styles.BorderType.Medium



' Set the bottom border color of the range A11:L11 to black.

workSheet("A11:L11").Style.BottomBorder.SetColor("#000000")



' Set the bottom border type of the range A11:L11 to Medium.

workSheet("A11:L11").Style.BottomBorder.Type = IronXL.Styles.BorderType.Medium

// IronXL is a library used for reading, writing, and modifying Excel files within .NET applications.
// This code snippet demonstrates how to use IronXL's built-in aggregation functions 
// to perform operations such as Sum, Avg, Max, and Min on specific ranges of an Excel worksheet 
// and assign the resulting values to specific cells.

// Ensure the IronXL namespace is referenced.
using IronXL;

// Load an existing workbook.
var workbook = WorkBook.Load("Filename.xlsx");

// Select the worksheet to perform operations on using the worksheet's name.
var workSheet = workbook.GetWorkSheet("SheetName");

// Calculate the sum of values in the range A2:A11.
decimal sum = workSheet["A2:A11"].Sum();

// Calculate the average of values in the range B2:B11.
decimal avg = workSheet["B2:B11"].Avg();

// Find the maximum value in the range C2:C11.
decimal max = workSheet["C2:C11"].Max();

// Find the minimum value in the range D2:D11.
decimal min = workSheet["D2:D11"].Min();

// Assign the calculated values to specific cells in the worksheet.
workSheet["A12"].Value = sum;
workSheet["B12"].Value = avg;
workSheet["C12"].Value = max;
workSheet["D12"].Value = min;

// Save changes to the workbook. Ensure you have write permissions to save the file.
workbook.SaveAs("UpdatedFilename.xlsx");

' IronXL is a library used for reading, writing, and modifying Excel files within .NET applications.

' This code snippet demonstrates how to use IronXL's built-in aggregation functions 

' to perform operations such as Sum, Avg, Max, and Min on specific ranges of an Excel worksheet 

' and assign the resulting values to specific cells.



' Ensure the IronXL namespace is referenced.

Imports IronXL



' Load an existing workbook.

Private workbook = WorkBook.Load("Filename.xlsx")



' Select the worksheet to perform operations on using the worksheet's name.

Private workSheet = workbook.GetWorkSheet("SheetName")



' Calculate the sum of values in the range A2:A11.

Private sum As Decimal = workSheet("A2:A11").Sum()



' Calculate the average of values in the range B2:B11.

Private avg As Decimal = workSheet("B2:B11").Avg()



' Find the maximum value in the range C2:C11.

Private max As Decimal = workSheet("C2:C11").Max()



' Find the minimum value in the range D2:D11.

Private min As Decimal = workSheet("D2:D11").Min()



' Assign the calculated values to specific cells in the worksheet.

Private workSheet("A12").Value = sum

Private workSheet("B12").Value = avg

Private workSheet("C12").Value = max

Private workSheet("D12").Value = min



' Save changes to the workbook. Ensure you have write permissions to save the file.

workbook.SaveAs("UpdatedFilename.xlsx")

// The code below demonstrates how to protect an Excel worksheet with a password 
// and freeze the top row using C#. The assumption is that a library handling 
// Excel operations is being used, such as EPPlus or a similar library.

// Ensure you have included the correct library that handles worksheet operations.
// Below is a demonstration using the EPPlus library as an example.

using OfficeOpenXml;  // Example of a needed namespace if using EPPlus
using OfficeOpenXml.Excel;  // Ensure the correct namespace is used

// Assuming 'workSheet' is a valid reference to an Excel worksheet in your code,
// the following actions will protect the worksheet with a password
// and freeze the top row.

// Protect the worksheet with the specified password.
workSheet.Protection.SetPassword("Password");
// Note: Depending on the library, the method to set a password might differ.
// In EPPlus, it's necessary to set different attributes of the protection.

// The following code freezes the first row, keeping it visible while scrolling vertically.
// Note: Parameters may vary depending on the library. For EPPlus, it might look like this.
workSheet.View.FreezePanes(2, 1);  // EPPlus uses a 1-based index, so '2' freezes the first row.

// Note: Always refer to the documentation of the library being used for the correct method calls and usage.

' The code below demonstrates how to protect an Excel worksheet with a password 

' and freeze the top row using C#. The assumption is that a library handling 

' Excel operations is being used, such as EPPlus or a similar library.



' Ensure you have included the correct library that handles worksheet operations.

' Below is a demonstration using the EPPlus library as an example.



Imports OfficeOpenXml ' Example of a needed namespace if using EPPlus

Imports OfficeOpenXml.Excel ' Ensure the correct namespace is used



' Assuming 'workSheet' is a valid reference to an Excel worksheet in your code,

' the following actions will protect the worksheet with a password

' and freeze the top row.



' Protect the worksheet with the specified password.

workSheet.Protection.SetPassword("Password")

' Note: Depending on the library, the method to set a password might differ.

' In EPPlus, it's necessary to set different attributes of the protection.



' The following code freezes the first row, keeping it visible while scrolling vertically.

' Note: Parameters may vary depending on the library. For EPPlus, it might look like this.

workSheet.View.FreezePanes(2, 1) ' EPPlus uses a 1-based index, so '2' freezes the first row.



' Note: Always refer to the documentation of the library being used for the correct method calls and usage.

// Assuming that `workSheet` is an instance of a worksheet from a library like IronXL.
// This code snippet configures the print settings of the worksheet.

using IronXL;
using IronXL.Styles;
using IronXL.Printing;

// The following code configures the print settings for a worksheet.
// First, the print area is set, then the orientation and paper size are configured.

// Set the print area of the worksheet to the range A1 to L12.
// This ensures that only this specific area is included when printing the worksheet.
workSheet.SetPrintArea("A1:L12");

// Set the print orientation to Landscape. 
// This will print the worksheet in landscape format, which is wider than it is tall.
workSheet.PrintSetup.PrintOrientation = PrintOrientation.Landscape;

// Set the paper size to A4. 
// This specifies that the worksheet should be printed on A4 paper, a common international paper size.
workSheet.PrintSetup.PaperSize = PaperSize.A4;

' Assuming that `workSheet` is an instance of a worksheet from a library like IronXL.

' This code snippet configures the print settings of the worksheet.



Imports IronXL

Imports IronXL.Styles

Imports IronXL.Printing



' The following code configures the print settings for a worksheet.

' First, the print area is set, then the orientation and paper size are configured.



' Set the print area of the worksheet to the range A1 to L12.

' This ensures that only this specific area is included when printing the worksheet.

workSheet.SetPrintArea("A1:L12")



' Set the print orientation to Landscape. 

' This will print the worksheet in landscape format, which is wider than it is tall.

workSheet.PrintSetup.PrintOrientation = PrintOrientation.Landscape



' Set the paper size to A4. 

' This specifies that the worksheet should be printed on A4 paper, a common international paper size.

workSheet.PrintSetup.PaperSize = PaperSize.A4

// This snippet demonstrates saving a workbook as an Excel file named "Budget.xlsx".
// Please ensure that you have added necessary references to the Excel library, 
// such as Microsoft.Office.Interop.Excel if using .NET Framework or its 
// equivalent for .NET Core with Excel interop.

using Microsoft.Office.Interop.Excel; // Ensure you include the necessary namespace for Excel interop;

// Create a new instance of Excel Application
Application excelApp = new Application();

// Check if the Excel application instance was created successfully
if (excelApp == null)
{
    Console.WriteLine("Excel is not properly installed on your system.");
    return; // Exit if Excel is not installed
}

// Make Excel visible for debugging. Comment this out if no GUI is needed.
// excelApp.Visible = true;

// Add a new workbook
_Workbook workBook = excelApp.Workbooks.Add();

// ToDo: Add data/manipulate the workbook as needed
// This section should include any logic to populate the workbook with data before saving.
// Example: 
// Worksheet workSheet = (_Worksheet)workBook.Sheets[1];
// workSheet.Cells[1, 1] = "Hello World";

// Save the workbook as a file named "Budget.xlsx"
try
{
    workBook.SaveAs("Budget.xlsx", XlFileFormat.xlWorkbookDefault);
    Console.WriteLine("Workbook saved successfully as Budget.xlsx.");
}
catch (Exception ex)
{
    // Catch any exception that might occur during the save process
    Console.WriteLine("An error occurred while saving the workbook: " + ex.Message);
}
finally
{
    // Properly close the Excel application to release resources
    workBook.Close(false);
    excelApp.Quit();

    // Release COM objects to fully kill the Excel process from running in the background
    System.Runtime.InteropServices.Marshal.ReleaseComObject(workBook);
    System.Runtime.InteropServices.Marshal.ReleaseComObject(excelApp);
    
    // Set variables to null and run garbage collection to clean up the memory
    workBook = null;
    excelApp = null;
    GC.Collect();
}

' This snippet demonstrates saving a workbook as an Excel file named "Budget.xlsx".

' Please ensure that you have added necessary references to the Excel library, 

' such as Microsoft.Office.Interop.Excel if using .NET Framework or its 

' equivalent for .NET Core with Excel interop.



Imports Microsoft.Office.Interop.Excel ' Ensure you include the necessary namespace for Excel interop;



' Create a new instance of Excel Application

Private excelApp As New Application()



' Check if the Excel application instance was created successfully

If excelApp Is Nothing Then

	Console.WriteLine("Excel is not properly installed on your system.")

	Return ' Exit if Excel is not installed

End If



' Make Excel visible for debugging. Comment this out if no GUI is needed.

' excelApp.Visible = true;



' Add a new workbook

Dim workBook As _Workbook = excelApp.Workbooks.Add()



' ToDo: Add data/manipulate the workbook as needed

' This section should include any logic to populate the workbook with data before saving.

' Example: 

' Worksheet workSheet = (_Worksheet)workBook.Sheets[1];

' workSheet.Cells[1, 1] = "Hello World";



' Save the workbook as a file named "Budget.xlsx"

Try

	workBook.SaveAs("Budget.xlsx", XlFileFormat.xlWorkbookDefault)

	Console.WriteLine("Workbook saved successfully as Budget.xlsx.")

Catch ex As Exception

	' Catch any exception that might occur during the save process

	Console.WriteLine("An error occurred while saving the workbook: " & ex.Message)

Finally

	' Properly close the Excel application to release resources

	workBook.Close(False)

	excelApp.Quit()



	' Release COM objects to fully kill the Excel process from running in the background

	System.Runtime.InteropServices.Marshal.ReleaseComObject(workBook)

	System.Runtime.InteropServices.Marshal.ReleaseComObject(excelApp)



	' Set variables to null and run garbage collection to clean up the memory

	workBook = Nothing

	excelApp = Nothing

	GC.Collect()

End Try