Porównanie IronXL i Epplus

Czym jest oprogramowanie EPPlus?

EPPlus to biblioteka .NET Framework/.NET Core oparta na NuGet, służąca do obsługi arkuszy kalkulacyjnych Office Open XML. Wersja 5 obsługuje platformy .NET Framework 3.5 i .NET Core 2.0. EPPlusnie korzysta z żadnych innych bibliotek, takich jak Microsoft Excel.

EPPlus posiada interfejs API, który umożliwia pracę z dokumentami programu Office Excel. EPPlusto biblioteka .NET, która odczytuje i zapisuje pliki Excel w formacie Office OpenXML. Biblioteka ta jest dostępna jako pakiet w serwisie NuGet.

Biblioteka została stworzona z myślą o programistach. Celem zawsze było umożliwienie programistom zaznajomionym z Excelem lub inną biblioteką arkuszy kalkulacyjnych szybkiego opanowania API. Alternatywnie, jak ktoś to ujął: "IntelliSense – droga do zwycięstwa!"

Instalacja EPPlus

Aby zainstalować EPPlusz poziomu Visual Studio, przejdź do menu Widok > Inne okna > Konsola menedżera pakietów i wpisz następujące polecenie:

Install-Package EPPlus

Jeśli wolisz skorzystać z interfejsu CLI platformy .NET, uruchom następujące polecenie z wiersza poleceń z uprawnieniami administratora lub z wiersza poleceń PowerShell:

dotnet add package EPPlus

EPPlus to pakiet dotnet, który można dodać do swojego projektu.

Czym jest IronXL?

IronXL to interfejs API C# i VB dla programu Excel, który umożliwia odczytywanie, edytowanie i tworzenie plików arkuszy kalkulacyjnych Excel w środowisku .NET bez konieczności instalowania pakietu Microsoft Office lub korzystania z interfejsu Excel Interop. Biblioteka IronXLobsługuje natywnie formaty XLS, XLSX, CSV i inne formaty arkuszy kalkulacyjnych.

IronXL obsługuje platformy .NET Core, .NET Framework, Xamarin, Mobile, Linux, macOS oraz Azure.

Istnieje wiele różnych sposobów odczytu i zapisu danych do i z arkusza kalkulacyjnego.

Dodawanie IronXLza pomocą pakietu NuGet

Możemy dodać pakiet IronXLdo Twojego konta na jeden z trzech sposobów, więc możesz wybrać ten, który najbardziej Ci odpowiada.

• Instalacja IronXLza pomocą konsoli menedżera pakietów

Użyj następującego polecenia, aby otworzyć konsolę menedżera pakietów w swoim projekcie:

Aby uzyskać dostęp do konsoli menedżera pakietów, przejdź do menu Narzędzia => Menedżer pakietów NuGet => Konsola menedżera pakietów.

Spowoduje to przejście do konsoli menedżera pakietów. Następnie w terminalu menedżera pakietów wpisz następujące polecenie:

Install-Package IronXl.Excel

• Używanie menedżera pakietów NuGet do instalacji IronXL

Jest to inne podejście do instalacji Menedżera pakietów NuGet. Nie będziesz musiał korzystać z tego podejścia, jeśli wcześniej ukończyłeś instalację przy użyciu poprzedniej metody.

Aby uzyskać dostęp do Menedżera pakietów NuGet, przejdź do Narzędzia > Menedżer pakietów NuGet => Wybierz Zarządzaj pakietami NuGet dla rozwiązania z menu rozwijanego.

Spowoduje to uruchomienie NuGet-Solution; wybierz "Przeglądaj" i wyszukaj IronXL.

W pasku wyszukiwania wpisz Excel:

IronXL zostanie zainstalowany po kliknięciu przycisku "Zainstaluj". Po zainstalowaniu IronXLmożesz przejść do swojego formularza i zacząć go rozwijać.

Przed zagłębieniem się w przykłady kodu, poniżej znajduje się przegląd porównawczy porównania EPPlusi IronXLw kluczowych obszarach omówionych w tym artykule:

Funkcja	EPPlus	IronXL
Odczyt plików XLSX	Tak	Tak
Tworzenie plików XLSX	Tak	Tak
Obsługa formatu XLS	Nie	Tak
Eksport do CSV, JSON, XML	Tylko CSV	CSV, JSON, XML
Eksport bazy danych (Entity Framework)	Nie obejmuje	Tak
Pomocnicy walidacji danych	Nie obejmuje	Tak
Operacje na wielu skoroszytach	Pojedynczy arkusz roboczy	Wiele arkuszy i wiele skoroszytów
Licencjonowanie	Komercyjne lub Polyform niekomercyjne	Komercyjne (wieczyste)

Aby przetestować działanie IronXLw Excelu z EPPluswe własnym projekcie, dostępna jest bezpłatna 30-dniowa wersja próbna.

Tworzenie pliku Excel za pomocą IronXL

Utworzenie nowego skoroszytu programu Excel za pomocą IronXLzajmuje jedną linię kodu:

// Create a new Excel workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

// Create a new Excel workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

' Create a new Excel workbook in XLSX format
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

IronXL może tworzyć pliki w formatach XLS (wcześniejsza wersja pliku Excel) i XLSX (obecna i nowsza wersja pliku Excel), wykorzystując pełen zakres możliwości programu Excel.

• Ustaw domyślny arkusz roboczy

Jeszcze łatwiej jest skonfigurować domyślny arkusz roboczy:

// Create a worksheet named "2020 Budget" in the workbook
var sheet = workbook.CreateWorkSheet("2020 Budget");

// Create a worksheet named "2020 Budget" in the workbook
var sheet = workbook.CreateWorkSheet("2020 Budget");

' Create a worksheet named "2020 Budget" in the workbook
Dim sheet = workbook.CreateWorkSheet("2020 Budget")

Arkusz roboczy jest reprezentowany przez sheet w powyższym fragmencie kodu i można go używać do ustawiania wartości i stylów komórek i robienia praktycznie wszystkiego, co potrafi Excel. Można również zakodować dokument Excel do pliku tylko do odczytu i wykonywać operacje usuwania. Możesz również łączyć swoje arkusze, tak jak robi to Excel.

Pozwolę sobie wyjaśnić różnicę między skoroszytem a arkuszem, na wypadek gdybyś nie był pewien.

Arkusze robocze znajdują się w skoroszycie. Oznacza to, że w skoroszycie można umieścić dowolną liczbę arkuszy. Wyjaśnię, jak to zrobić w późniejszym artykule. Wiersze i kolumny tworzą arkusz roboczy. Przecięcie wiersza i kolumny nazywane jest komórką i to właśnie z nią będziesz wchodzić w interakcje w programie Excel.

Tworzenie pliku Excel z EPPlusSoftware AB

EPPlus może być używany do tworzenia plików Excel i wykonywania operacji, takich jak tworzenie tabel przestawnych, obszarów przestawnych, a nawet formatowania warunkowego i zmiany czcionek. Bez zbędnych ceregieli, oto cały kod źródłowy do konwersji zwykłego DataTable do pliku XLSX Excel i wysłania go użytkownikowi do pobrania:

public ActionResult ConvertToXLSX()
{
    byte[] fileData = null;

    // Replace the GetDataTable() method with your DBMS-fetching code.
    using (DataTable dt = GetDataTable())
    {
        // Create an empty spreadsheet
        using (var p = new ExcelPackage())
        {
            // Add a worksheet to the spreadsheet
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            // Initialize rows and columns counter: note that they are 1-based!
            var row = 1;
            var col = 1;

            // Create the column names on the first line.
            // In this sample, we'll just use the DataTable column names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows into the XLS file
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r[dc].ToString());
                }

                // Alternate light-gray color for uneven rows (3, 5, 7, 9)...
                if (row % 2 != 0)
                {
                    ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                }
            }

            // Output the XLSX file
            using (var ms = new MemoryStream())
            {
                p.SaveAs(ms);
                ms.Seek(0, SeekOrigin.Begin);
                fileData = ms.ToArray();
            }
        }
    }

    string fileName = "ConvertedFile.xlsx";
    string contentType = System.Web.MimeMapping.GetMimeMapping(fileName);
    Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
    return File(fileData, contentType);
}

public ActionResult ConvertToXLSX()
{
    byte[] fileData = null;

    // Replace the GetDataTable() method with your DBMS-fetching code.
    using (DataTable dt = GetDataTable())
    {
        // Create an empty spreadsheet
        using (var p = new ExcelPackage())
        {
            // Add a worksheet to the spreadsheet
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            // Initialize rows and columns counter: note that they are 1-based!
            var row = 1;
            var col = 1;

            // Create the column names on the first line.
            // In this sample, we'll just use the DataTable column names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows into the XLS file
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r[dc].ToString());
                }

                // Alternate light-gray color for uneven rows (3, 5, 7, 9)...
                if (row % 2 != 0)
                {
                    ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                }
            }

            // Output the XLSX file
            using (var ms = new MemoryStream())
            {
                p.SaveAs(ms);
                ms.Seek(0, SeekOrigin.Begin);
                fileData = ms.ToArray();
            }
        }
    }

    string fileName = "ConvertedFile.xlsx";
    string contentType = System.Web.MimeMapping.GetMimeMapping(fileName);
    Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
    return File(fileData, contentType);
}

Public Function ConvertToXLSX() As ActionResult
	Dim fileData() As Byte = Nothing

	' Replace the GetDataTable() method with your DBMS-fetching code.
	Using dt As DataTable = GetDataTable()
		' Create an empty spreadsheet
		Using p = New ExcelPackage()
			' Add a worksheet to the spreadsheet
			Dim ws As ExcelWorksheet = p.Workbook.Worksheets.Add(dt.TableName)

			' Initialize rows and columns counter: note that they are 1-based!
			Dim row = 1
			Dim col = 1

			' Create the column names on the first line.
			' In this sample, we'll just use the DataTable column names
			row = 1
			col = 0
			For Each dc As DataColumn In dt.Columns
				col += 1
				ws.SetValue(row, col, dc.ColumnName)
			Next dc

			' Insert the DataTable rows into the XLS file
			For Each r As DataRow In dt.Rows
				row += 1
				col = 0
				For Each dc As DataColumn In dt.Columns
					col += 1
					ws.SetValue(row, col, r(dc).ToString())
				Next dc

				' Alternate light-gray color for uneven rows (3, 5, 7, 9)...
				If row Mod 2 <> 0 Then
					ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid
					ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray)
				End If
			Next r

			' Output the XLSX file
			Using ms = New MemoryStream()
				p.SaveAs(ms)
				ms.Seek(0, SeekOrigin.Begin)
				fileData = ms.ToArray()
			End Using
		End Using
	End Using

	Dim fileName As String = "ConvertedFile.xlsx"
	Dim contentType As String = System.Web.MimeMapping.GetMimeMapping(fileName)
	Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName))
	Return File(fileData, contentType)
End Function

Jak widać, jest to metoda ActionResult, która może być używana w dowolnym kontrolerze ASP.NET MVC; jeśli nie korzystasz z ASP.NET MVC, po prostu skopiuj zawartość metody i wklej ją tam, gdzie jej potrzebujesz (np. klasyczna ASP.NET, aplikacja konsolowa, Windows Forms itp.)

Kod jest zrozumiały i zawiera wystarczającą liczbę komentarzy, aby pomóc w zrozumieniu różnych procesów przetwarzania. Najpierw jednak krótkie podsumowanie tego, co tutaj robimy:

• Korzystając z niestandardowej metody dostawcy danych, otrzymujemy obiekt DataTable.
• Tworzymy obiekt ExcelPackage, który jest głównym kontenerem EPPlusdla pliku XLSX.
• Dodajemy ExcelWorksheet do ExcelPackage, który będzie arkuszem, w którym będą wprowadzane dane.
• Aby utworzyć wiersz nagłówka, iterujemy kolumny DataTable, dodając je do pierwszego wiersza naszego arkusza.
• Iterujemy przez wiersze DataTable, dodając każdy z nich do naszego arkusza wiersz po wierszu (zaczynając od wiersza 2), tak aby każdy wiersz DataTable odpowiadał wierszowi arkusza.
• Budujemy MemoryStream do przechowywania danych binarnych ExcelPackage po zakończeniu konwersji DataTable na ExcelPackage, a następnie konwertujemy je na tablicę bajtów.
• Tworzymy odpowiedź HTML i wysyłamy plik XLSX do użytkownika z załącznikiem Content-Disposition, powodując automatyczne pobranie pliku przez przeglądarkę.

Podejście IronXLdo tworzenia skoroszytów wymaga jednej linii kodu w porównaniu do wieloetapowej konfiguracji EPPlusobejmującej ExcelPackage, ExcelWorksheet i ręczną iterację komórek. W przypadku zespołów, dla których priorytetem jest szybkie prototypowanie i prostsze debugowanie, ta różnica może się sumować w całym cyklu życia projektu.

Jak EPPlusSoftware AB zapisuje pliki Excel

EPPlus obsługuje pracę z plikami Excel. Jest to biblioteka .net, która odczytuje i zapisuje pliki Excel.

• Odczytywanie plików Excel

Aby to zrobić, musisz najpierw zainstalować pakiet EPPlus: przejdź do "Narzędzia"-> "Menedżer pakietów NuGet"-> "Zarządzaj NuGet dla tego rozwiązania" -> "Zainstaluj EPPlus" -> "Zainstaluj EPPlus" -> "Zainstaluj EPPlus" -> "Zainstaluj EP" -> "Zainstaluj EP. Wyszukaj "EPPlus" w zakładce "Przeglądaj", a następnie zainstaluj pakiet NuGet.

Poniższy kod można wykorzystać w aplikacji konsolowej "Program.cs" po zainstalowaniu pakietu.

using OfficeOpenXml;
using System;
using System.IO;

namespace ReadExcelInCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Provide file path
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            // Use EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                // Get the first worksheet in the workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets[1];
                int colCount = worksheet.Dimension.End.Column;  // Get Column Count
                int rowCount = worksheet.Dimension.End.Row;     // Get row count
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        // Print data, based on row and columns position
                        Console.WriteLine("Row:" + row + " Column:" + col + " Value:" + worksheet.Cells[row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}

using OfficeOpenXml;
using System;
using System.IO;

namespace ReadExcelInCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Provide file path
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            // Use EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                // Get the first worksheet in the workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets[1];
                int colCount = worksheet.Dimension.End.Column;  // Get Column Count
                int rowCount = worksheet.Dimension.End.Row;     // Get row count
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        // Print data, based on row and columns position
                        Console.WriteLine("Row:" + row + " Column:" + col + " Value:" + worksheet.Cells[row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}

Imports OfficeOpenXml
Imports System
Imports System.IO

Namespace ReadExcelInCsharp
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			' Provide file path
			Dim existingFile As New FileInfo("D:\sample_XLSX.xlsx")
			' Use EPPlus
			Using package As New ExcelPackage(existingFile)
				' Get the first worksheet in the workbook
				Dim worksheet As ExcelWorksheet = package.Workbook.Worksheets(1)
				Dim colCount As Integer = worksheet.Dimension.End.Column ' Get Column Count
				Dim rowCount As Integer = worksheet.Dimension.End.Row ' Get row count
				For row As Integer = 1 To rowCount
					For col As Integer = 1 To colCount
						' Print data, based on row and columns position
						Console.WriteLine("Row:" & row & " Column:" & col & " Value:" & worksheet.Cells(row, col).Value?.ToString().Trim())
					Next col
				Next row
			End Using
		End Sub
	End Class
End Namespace

Oto przykład wyjścia aplikacji konsolowej z przykładowym plikiem Excel (.xlsx), z którym pracujemy. Oto plik xlsx do odczytu w języku C# przy użyciu EPPlus.

Poniższe sposoby ładowania danych z wielu źródeł są dostępne przy użyciu właściwości "cells" (ExcelRange):

• Odczytaj plik tekstowy CSV i załaduj dane do zakresu w arkuszu z @@--CODE-63140--@ i LoadFromTextAsync. IronXLzapewnia również własne operacje eksportu i importu CSV.
• LoadFromDataReaderAsync i LoadFromDataReader - ładuje pola danych z DataReader do zakresu.
• LoadFromDataTable - ładuje dane z DataTable do zakresu. Tłumaczenie może importować dane z różnych źródeł, w tym XML (dostarczono przykład) i baz danych.
• LoadFromCollection - refleksyjnie ładuje dane z IEnumerable do zakresu.
• LoadFromCollection with attributes - refleksyjnie ładuje dane z IEnumerable do zakresu lub tabeli. Style, formaty liczb, formuły i inne właściwości są określane za pomocą atrybutów.
• LoadFromDictionaries - ładuje dane z IEnumerable obiektów ExpandoObject/dynamicznych (poprzez ich IDictionary<string, object> interfejs) do zakresu. Jest to przydatne do importowania danych JSON i zawiera przykład.
• LoadFromArrays - ładuje dane z IEnumerable obiektu [] do zakresu, przy czym każda tablica obiektów odpowiada wierszowi w arkuszu.

Podczas korzystania z tych metod można opcjonalnie podać parametr do wygenerowania tabeli Excel. Próbki 4 i 5 przykładowego projektu Sample-.NET Framework lub Sample-.NET Framework zawierają bardziej rozbudowane przykłady.

• Pisanie plików Excel

Następnie sprawdźmy, czy możemy wyeksportować dane do nowego pliku Excel.

Oto kilka przykładowych danych/obiektów, które chcielibyśmy zapisać jako dokument Excel.

List<UserDetails> persons = new List<UserDetails>()
{
    new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
    new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
    new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
    new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
};

List<UserDetails> persons = new List<UserDetails>()
{
    new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
    new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
    new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
    new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
};

Dim persons As New List(Of UserDetails)() From {
	New UserDetails() With {
		.ID="9999",
		.Name="ABCD",
		.City ="City1",
		.Country="USA"
	},
	New UserDetails() With {
		.ID="8888",
		.Name="PQRS",
		.City ="City2",
		.Country="INDIA"
	},
	New UserDetails() With {
		.ID="7777",
		.Name="XYZZ",
		.City ="City3",
		.Country="CHINA"
	},
	New UserDetails() With {
		.ID="6666",
		.Name="LMNO",
		.City ="City4",
		.Country="UK"
	}
}

Aby utworzyć nowy plik Excel z niezbędnymi informacjami, musimy użyć klasy ExcelPackage. Zapisywanie danych do pliku i tworzenie nowego arkusza kalkulacyjnego Excel zajmuje tylko kilka linijek kodu. Zwróć uwagę na jedną linię poniżej, która wykonuje magię ładowania DataTables do arkusza Excel.

Aby zachować prostotę, generuję nowy plik arkusza kalkulacyjnego w tym samym folderze projektu (plik Excel zostanie utworzony w folderze "bin" projektu). Kod źródłowy znajduje się poniżej:

private static void WriteToExcel(string path)
{
    // Let use below test data for writing it to excel
    List<UserDetails> persons = new List<UserDetails>()
    {
        new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
        new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
        new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
        new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
    };

    // Let's convert our object data to Datatable for a simplified logic.
    // Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
    DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
    FileInfo filePath = new FileInfo(path);
    using (var excelPack = new ExcelPackage(filePath))
    {
        var ws = excelPack.Workbook.Worksheets.Add("WriteTest");
        ws.Cells.LoadFromDataTable(table, true, OfficeOpenXml.Table.TableStyles.Light8);
        excelPack.Save();
    }
}

private static void WriteToExcel(string path)
{
    // Let use below test data for writing it to excel
    List<UserDetails> persons = new List<UserDetails>()
    {
        new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
        new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
        new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
        new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
    };

    // Let's convert our object data to Datatable for a simplified logic.
    // Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
    DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
    FileInfo filePath = new FileInfo(path);
    using (var excelPack = new ExcelPackage(filePath))
    {
        var ws = excelPack.Workbook.Worksheets.Add("WriteTest");
        ws.Cells.LoadFromDataTable(table, true, OfficeOpenXml.Table.TableStyles.Light8);
        excelPack.Save();
    }
}

Private Shared Sub WriteToExcel(ByVal path As String)
	' Let use below test data for writing it to excel
	Dim persons As New List(Of UserDetails)() From {
		New UserDetails() With {
			.ID="9999",
			.Name="ABCD",
			.City ="City1",
			.Country="USA"
		},
		New UserDetails() With {
			.ID="8888",
			.Name="PQRS",
			.City ="City2",
			.Country="INDIA"
		},
		New UserDetails() With {
			.ID="7777",
			.Name="XYZZ",
			.City ="City3",
			.Country="CHINA"
		},
		New UserDetails() With {
			.ID="6666",
			.Name="LMNO",
			.City ="City4",
			.Country="UK"
		}
	}

	' Let's convert our object data to Datatable for a simplified logic.
	' Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
	Dim table As DataTable = CType(JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (GetType(DataTable))), DataTable)
	Dim filePath As New FileInfo(path)
	Using excelPack = New ExcelPackage(filePath)
		Dim ws = excelPack.Workbook.Worksheets.Add("WriteTest")
		ws.Cells.LoadFromDataTable(table, True, OfficeOpenXml.Table.TableStyles.Light8)
		excelPack.Save()
	End Using
End Sub

Po wspomnianym wyżej wywołaniu API w celu sprawdzenia poprawności danych zostanie utworzony nowy plik Excel z powyższą niestandardową transformacją obiektu do odpowiednich kolumn i wierszy programu Excel, aby wyświetlić poniższą wartość.

Powyższy gotowy do użycia interfejs API może być używany w konsoli .NET Core, projekcie testowym lub aplikacji ASP.NET Core, a logikę można zmienić w zależności od potrzeb.

Dostęp do tych technik można uzyskać za pomocą właściwości "cells" (ExcelRange):

• ToText i ToTextAsync - tworzy ciąg CSV z zakresu.
• Zapisywanie zakresu do pliku CSV za pomocą SaveToText i SaveToTextAsync.
• Eksportowanie danych z zakresu do systemu przy użyciu metody ToDataTable. DataTable
• GetValue - pokazuje wartość z opcją typu danych.
• Value - zwraca lub ustawia wartość zakresu.

Metody GetValue i SetValue mogą być również używane bezpośrednio na obiekcie arkusza. (Zapewni to nieco lepsze wyniki niż czytanie/pisanie na bieżąco):

• GetValue - pobiera wartość pojedynczej komórki, z możliwością określenia typu danych.
• SetValue - zmienia wartość pojedynczej komórki.

Linq może być używany do odpytywania danych z arkusza roboczego, ponieważ właściwość komórki implementuje interfejs IEnumerable.

Otwieraj i zapisuj pliki XLSX w formacie Office Open XML za pomocą IronXL

Biblioteka IronXLto biblioteka .NET, która pozwala programistom C# na szybką i łatwą pracę z programem Excel, tabelami przestawnymi i innymi plikami arkuszy kalkulacyjnych.

Nie jest wymagana obsługa Office Interop. Nie ma żadnych szczególnych zależności ani konieczności instalowania pakietu Microsoft Office na platformie Core lub Azure.

IronXL to renomowana biblioteka arkuszy kalkulacyjnych XL dla języków C# i VB.NET, przeznaczona dla platform .NET Core i .NET Framework.

• Odczytywanie plików Excel
• Arkusz roboczy do załadowania

Arkusz programu Excel jest reprezentowany przez klasę WorkBook. Używamy WorkBook do odczytu pliku Excel w C# zawierającego nawet tabele przestawne. Załaduj plik Excel i wybierz jego lokalizację (.xlsx).

/**
 Load WorkBook
 **/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

/**
 Load WorkBook
 **/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

'''
''' Load WorkBook
''' *
Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")

Obiekty arkusza można znaleźć w wielu skoroszytach. Oto arkusze dokumentu Excel. Jeśli arkusz zawiera arkusze robocze, należy użyć nazwy WorkBook, aby znaleźć je za pomocą GetWorkSheet.

var worksheet = workbook.GetWorkSheet("GDPByCountry");

var worksheet = workbook.GetWorkSheet("GDPByCountry");

Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

• Stwórz własny skoroszyt.

Skonstruuj nowy WorkBook z typem arkusza, aby wygenerować nowy WorkBook w pamięci.

/**
 Create WorkBook
 **/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

/**
 Create WorkBook
 **/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

'''
''' Create WorkBook
''' *
Dim workbook As New WorkBook(ExcelFileFormat.XLSX)

W przypadku starych arkuszy kalkulacyjnych Microsoft Excel należy użyć ExcelFileFormat.XLS (95 i wcześniejszych).

Utwórz arkusz roboczy, jeśli jeszcze go nie masz.

W każdym "WorkBook" może znajdować się wiele arkuszy "WorkSheet". "WorkSheet" to pojedynczy arkusz danych, natomiast "WorkBook" to zbiór arkuszy "WorkSheet". W programie Excel tak wygląda jeden skoroszyt z dwoma arkuszami.

WorkBook to nazwa nowego WorkSheet, który można zbudować.

var worksheet = workbook.CreateWorkSheet("Countries");

var worksheet = workbook.CreateWorkSheet("Countries");

Dim worksheet = workbook.CreateWorkSheet("Countries")

Przekaż nazwę arkusza do CreateWorkSheet.

Uzyskaj zasięg sieci komórkowej

Dwuwymiarowa kolekcja obiektów "Cell" jest reprezentowana przez klasę "Range". Oznacza to określony zakres komórek w programie Excel. Korzystając z indeksatora ciągów znaków w obiekcie WorkSheet, można uzyskać zakresy.

var range = worksheet["D2:D101"];

var range = worksheet["D2:D101"];

Dim range = worksheet("D2:D101")

Tekstem argumentu może być współrzędna komórki (na przykład "A1") lub zakres komórek od lewej do prawej, od góry do dołu (np. "B2:E5"). GetRange można również wywołać z arkusza WorkSheet.

• W zakresie, edytuj wartości komórek

Wartości komórek w zakresie można odczytywać lub edytować na wiele sposobów. Użyj pętli For, jeśli znana jest liczba. W tym miejscu można również dostosować styl komórek.

/**
 Edit Cell Values in Range
 **/
 // Iterate through the rows
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{y}:E{y}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string) cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

/**
 Edit Cell Values in Range
 **/
 // Iterate through the rows
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{y}:E{y}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string) cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

'''
''' Edit Cell Values in Range
''' *
 ' Iterate through the rows
For y = 2 To 101
	Dim result = New PersonValidationResult With {.Row = y}
	results.Add(result)

	' Get all cells for the person
	Dim cells = worksheet($"A{y}:E{y}").ToList()

	' Validate the phone number (1 = B)
	Dim phoneNumber = cells(1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	' Validate the email address (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells(3).Value))

	' Get the raw date in the format of Month Day [suffix], Year (4 = E)
	Dim rawDate = CStr(cells(4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next y

Weryfikacja danych w arkuszach kalkulacyjnych

Aby zweryfikować arkusz danych, użyj IronXL. Przykład DataValidation weryfikuje numery telefonów za pomocą libphonenumber-CSharp, a adresy e-mail i daty za pomocą standardowych interfejsów API języka C#.

/**
 Validate Spreadsheet Data
 **/
 // Iterate through the rows
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{i}:E{i}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

/**
 Validate Spreadsheet Data
 **/
 // Iterate through the rows
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{i}:E{i}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

'''
''' Validate Spreadsheet Data
''' *
 ' Iterate through the rows
For i = 2 To 101
	Dim result = New PersonValidationResult With {.Row = i}
	results.Add(result)

	' Get all cells for the person
	Dim cells = worksheet($"A{i}:E{i}").ToList()

	' Validate the phone number (1 = B)
	Dim phoneNumber = cells(1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	' Validate the email address (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells(3).Value))

	' Get the raw date in the format of Month Day [suffix], Year (4 = E)
	Dim rawDate = CStr(cells(4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next i

Powyższy kod przechodzi cyklicznie przez wiersze arkusza kalkulacyjnego, pobierając komórki jako listę. Każda z metod sprawdzających weryfikuje wartość komórki i zwraca błąd, jeśli wartość jest nieprawidłowa.

Ten kod tworzy nowy arkusz, określa nagłówki i generuje wyniki komunikatów o błędach, dzięki czemu można zachować nieprawidłowy dziennik danych.

var resultsSheet = workbook.CreateWorkSheet("Results");

resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

for (var i = 0; i < results.Count; i++)
{
    var result = results[i];
    resultsSheet[$"A{i + 2}"].Value = result.Row;
    resultsSheet[$"B{i + 2}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{i + 2}"].Value = result.PhoneNumberErrorMessage;
    resultsSheet[$"D{i + 2}"].Value = result.EmailErrorMessage;
    resultsSheet[$"E{i + 2}"].Value = result.DateErrorMessage;
}

workbook.SaveAs(@"Spreadsheets\\PeopleValidated.xlsx");

var resultsSheet = workbook.CreateWorkSheet("Results");

resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

for (var i = 0; i < results.Count; i++)
{
    var result = results[i];
    resultsSheet[$"A{i + 2}"].Value = result.Row;
    resultsSheet[$"B{i + 2}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{i + 2}"].Value = result.PhoneNumberErrorMessage;
    resultsSheet[$"D{i + 2}"].Value = result.EmailErrorMessage;
    resultsSheet[$"E{i + 2}"].Value = result.DateErrorMessage;
}

workbook.SaveAs(@"Spreadsheets\\PeopleValidated.xlsx");

Dim resultsSheet = workbook.CreateWorkSheet("Results")

resultsSheet("A1").Value = "Row"
resultsSheet("B1").Value = "Valid"
resultsSheet("C1").Value = "Phone Error"
resultsSheet("D1").Value = "Email Error"
resultsSheet("E1").Value = "Date Error"

For i = 0 To results.Count - 1
	Dim result = results(i)
	resultsSheet($"A{i + 2}").Value = result.Row
	resultsSheet($"B{i + 2}").Value = If(result.IsValid, "Yes", "No")
	resultsSheet($"C{i + 2}").Value = result.PhoneNumberErrorMessage
	resultsSheet($"D{i + 2}").Value = result.EmailErrorMessage
	resultsSheet($"E{i + 2}").Value = result.DateErrorMessage
Next i

workbook.SaveAs("Spreadsheets\\PeopleValidated.xlsx")

Wykorzystanie Entity Framework do eksportu danych

Użyj IronXL, aby przekonwertować arkusz kalkulacyjny Excel na bazę danych lub wyeksportować dane do bazy danych. Próbka ExcelToDB odczytuje arkusz kalkulacyjny zawierający PKB według krajów i eksportuje go do SQLite.

Tworzy bazę danych za pomocą EntityFramework, a następnie eksportuje dane wiersz po wierszu.

Należy zainstalować pakiety NuGet SQLite Entity Framework.

Możesz użyć EntityFramework do skonstruowania obiektu modelu, który może eksportować dane do bazy danych.

public class Country
{
    [Key]
    public Guid Key { get; set; }
    public string Name { get; set; }
    public decimal GDP { get; set; }
}

public class Country
{
    [Key]
    public Guid Key { get; set; }
    public string Name { get; set; }
    public decimal GDP { get; set; }
}

Public Class Country
	<Key>
	Public Property Key() As Guid
	Public Property Name() As String
	Public Property GDP() As Decimal
End Class

Aby użyć innej bazy danych, należy zainstalować odpowiedni pakiet NuGet i wyszukać odpowiednik UseSqLite (UseMySQL, UseSqlServer itd.).

/**
 Export Data using Entity Framework
 **/
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    public CountryContext()
    {
        // TODO: Make async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configure context to use Sqlite
    /// </summary>
    /// <param name="optionsBuilder"></param>
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connection = new SqliteConnection($"Data Source=Country.db");
        connection.Open();

        var command = connection.CreateCommand();

        // Create the database if it doesn't already exist
        command.CommandText = $"PRAGMA foreign_keys = ON;";
        command.ExecuteNonQuery();

        optionsBuilder.UseSqlite(connection);

        base.OnConfiguring(optionsBuilder);
    }
}

/**
 Export Data using Entity Framework
 **/
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    public CountryContext()
    {
        // TODO: Make async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configure context to use Sqlite
    /// </summary>
    /// <param name="optionsBuilder"></param>
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connection = new SqliteConnection($"Data Source=Country.db");
        connection.Open();

        var command = connection.CreateCommand();

        // Create the database if it doesn't already exist
        command.CommandText = $"PRAGMA foreign_keys = ON;";
        command.ExecuteNonQuery();

        optionsBuilder.UseSqlite(connection);

        base.OnConfiguring(optionsBuilder);
    }
}

'''
''' Export Data using Entity Framework
''' *
Public Class CountryContext
	Inherits DbContext

	Public Property Countries() As DbSet(Of Country)

	Public Sub New()
		' TODO: Make async
		Database.EnsureCreated()
	End Sub

	''' <summary>
	''' Configure context to use Sqlite
	''' </summary>
	''' <param name="optionsBuilder"></param>
	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		Dim connection = New SqliteConnection($"Data Source=Country.db")
		connection.Open()

		Dim command = connection.CreateCommand()

		' Create the database if it doesn't already exist
		command.CommandText = $"PRAGMA foreign_keys = ON;"
		command.ExecuteNonQuery()

		optionsBuilder.UseSqlite(connection)

		MyBase.OnConfiguring(optionsBuilder)
	End Sub
End Class

Utwórz CountryContext, a następnie wykonaj iterację przez zakres, aby utworzyć każdy wpis przed zapisaniem danych do bazy danych za pomocą SaveChangesAsync.

public async Task ProcessAsync()
{
    // Get the first worksheet
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    // Create the database connection
    using (var countryContext = new CountryContext())
    {
        // Iterate through all the cells
        for (var i = 2; i <= 213; i++)
        {
            // Get the range from A-B
            var range = worksheet[$"A{i}:B{i}"].ToList();

            // Create a Country entity to be saved to the database
            var country = new Country
            {
                Name = (string)range[0].Value,
                GDP = (decimal)(double)range[1].Value
            };

            // Add the entity
            await countryContext.Countries.AddAsync(country);
        }

        // Commit changes to the database
        await countryContext.SaveChangesAsync();
    }
}

public async Task ProcessAsync()
{
    // Get the first worksheet
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    // Create the database connection
    using (var countryContext = new CountryContext())
    {
        // Iterate through all the cells
        for (var i = 2; i <= 213; i++)
        {
            // Get the range from A-B
            var range = worksheet[$"A{i}:B{i}"].ToList();

            // Create a Country entity to be saved to the database
            var country = new Country
            {
                Name = (string)range[0].Value,
                GDP = (decimal)(double)range[1].Value
            };

            // Add the entity
            await countryContext.Countries.AddAsync(country);
        }

        // Commit changes to the database
        await countryContext.SaveChangesAsync();
    }
}

Public Async Function ProcessAsync() As Task
	' Get the first worksheet
	Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")
	Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

	' Create the database connection
	Using countryContext As New CountryContext()
		' Iterate through all the cells
		For i = 2 To 213
			' Get the range from A-B
			Dim range = worksheet($"A{i}:B{i}").ToList()

			' Create a Country entity to be saved to the database
			Dim country As New Country With {
				.Name = CStr(range(0).Value),
				.GDP = CDec(CDbl(range(1).Value))
			}

			' Add the entity
			Await countryContext.Countries.AddAsync(country)
		Next i

		' Commit changes to the database
		Await countryContext.SaveChangesAsync()
	End Using
End Function

Wstawianie formuły do arkusza kalkulacyjnego

Właściwość Formula może być użyta do ustawienia formuły komórki.

// Iterate through all rows with a value
for (var y = 2; y < i; y++)
{
    // Get the C cell
    var cell = sheet[$"C{y}"].First();

    // Set the formula for the Percentage of Total column
    cell.Formula = $"=B{y}/B{i}";
}

// Iterate through all rows with a value
for (var y = 2; y < i; y++)
{
    // Get the C cell
    var cell = sheet[$"C{y}"].First();

    // Set the formula for the Percentage of Total column
    cell.Formula = $"=B{y}/B{i}";
}

' Iterate through all rows with a value
Dim y = 2
Do While y < i
	' Get the C cell
	Dim cell = sheet($"C{y}").First()

	' Set the formula for the Percentage of Total column
	cell.Formula = $"=B{y}/B{i}"
	y += 1
Loop

Kod w kolumnie C przechodzi przez każdy stan i oblicza procentową sumę.

Dane z interfejsu API można pobrać do arkusza kalkulacyjnego

RestClient.Net jest używany w poniższym wywołaniu do wykonania wywołania REST. Pobiera plik JSON i przekształca go w "Listę" typu RestCountry. Dane z REST API można następnie łatwo zapisać w pliku Excel, iterując po każdym kraju.

/**
 Data API to Spreadsheet
 **/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();

/**
 Data API to Spreadsheet
 **/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();

'''
''' Data API to Spreadsheet
''' *
Dim client As New Client(New Uri("https://restcountries.eu/rest/v2/"))
Dim countries As List(Of RestCountry) = Await client.GetAsync(Of List(Of RestCountry))()

Dane JSON z API wyglądają następująco:

Poniższy kod przechodzi cyklicznie przez kraje i wypełnia arkusz kalkulacyjny danymi: Nazwa, Liczba mieszkańców, Region, Kod numeryczny oraz 3 najpopularniejsze języki.

for (var i = 2; i < countries.Count; i++)
{
    var country = countries[i];

    // Set the basic values
    worksheet[$"A{i}"].Value = country.name;
    worksheet[$"B{i}"].Value = country.population;
    worksheet[$"G{i}"].Value = country.region;
    worksheet[$"H{i}"].Value = country.numericCode;

    // Iterate through languages
    for (var x = 0; x < 3; x++)
    {
        if (x > (country.languages.Count - 1)) break;

        var language = country.languages[x];

        // Get the letter for the column
        var columnLetter = GetColumnLetter(4 + x);

        // Set the language name
        worksheet[$"{columnLetter}{i}"].Value = language.name;
    }
}

for (var i = 2; i < countries.Count; i++)
{
    var country = countries[i];

    // Set the basic values
    worksheet[$"A{i}"].Value = country.name;
    worksheet[$"B{i}"].Value = country.population;
    worksheet[$"G{i}"].Value = country.region;
    worksheet[$"H{i}"].Value = country.numericCode;

    // Iterate through languages
    for (var x = 0; x < 3; x++)
    {
        if (x > (country.languages.Count - 1)) break;

        var language = country.languages[x];

        // Get the letter for the column
        var columnLetter = GetColumnLetter(4 + x);

        // Set the language name
        worksheet[$"{columnLetter}{i}"].Value = language.name;
    }
}

For i = 2 To countries.Count - 1
	Dim country = countries(i)

	' Set the basic values
	worksheet($"A{i}").Value = country.name
	worksheet($"B{i}").Value = country.population
	worksheet($"G{i}").Value = country.region
	worksheet($"H{i}").Value = country.numericCode

	' Iterate through languages
	For x = 0 To 2
		If x > (country.languages.Count - 1) Then
			Exit For
		End If

		Dim language = country.languages(x)

		' Get the letter for the column
		Dim columnLetter = GetColumnLetter(4 + x)

		' Set the language name
		worksheet($"{columnLetter}{i}").Value = language.name
	Next x
Next i

Otwieraj pliki Excel za pomocą IronXL

Po uruchomieniu pliku Excel dodaj kilka pierwszych wierszy, które odczytują pierwszą komórkę w pierwszym arkuszu, a następnie PRINT.

static void Main(string[] args)
{
    var workbook = IronXl.WorkBook.Load($@"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx");
    var sheet = workbook.WorkSheets.First();
    var cell = sheet["A1"].StringValue;
    Console.WriteLine(cell);
}

static void Main(string[] args)
{
    var workbook = IronXl.WorkBook.Load($@"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx");
    var sheet = workbook.WorkSheets.First();
    var cell = sheet["A1"].StringValue;
    Console.WriteLine(cell);
}

Imports System
Imports System.IO
Imports IronXl

Module Program
    Sub Main(args As String())
        Dim workbook = WorkBook.Load($"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx")
        Dim sheet = workbook.WorkSheets.First()
        Dim cell = sheet("A1").StringValue
        Console.WriteLine(cell)
    End Sub
End Module

Za pomocą IronXLutwórz nowy plik Excel.

/**
 Create Excel File
 **/
static void Main(string[] args)
{
    var newXLFile = WorkBook.Create(ExcelFileFormat.XLSX);
    newXLFile.Metadata.Title = "IronXL New File";
    var newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet");
    newWorkSheet["A1"].Value = "Hello World";
    newWorkSheet["A2"].Style.BottomBorder.SetColor("#ff6600");
    newWorkSheet["A2"].Style.BottomBorder.Type = IronXl.Styles.BorderType.Dashed;
}

/**
 Create Excel File
 **/
static void Main(string[] args)
{
    var newXLFile = WorkBook.Create(ExcelFileFormat.XLSX);
    newXLFile.Metadata.Title = "IronXL New File";
    var newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet");
    newWorkSheet["A1"].Value = "Hello World";
    newWorkSheet["A2"].Style.BottomBorder.SetColor("#ff6600");
    newWorkSheet["A2"].Style.BottomBorder.Type = IronXl.Styles.BorderType.Dashed;
}

Option Strict On



Module Program
    ''' <summary>
    ''' Create Excel File
    ''' </summary>
    Sub Main(args As String())
        Dim newXLFile = WorkBook.Create(ExcelFileFormat.XLSX)
        newXLFile.Metadata.Title = "IronXL New File"
        Dim newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet")
        newWorkSheet("A1").Value = "Hello World"
        newWorkSheet("A2").Style.BottomBorder.SetColor("#ff6600")
        newWorkSheet("A2").Style.BottomBorder.Type = IronXl.Styles.BorderType.Dashed
    End Sub
End Module

Następnie można zapisać plik w formacie CSV, JSON lub XML, używając odpowiednich kodów, jak pokazano w przykładach kodu IronXL.

Na przykład, aby zapisać do XML .xml

Aby zapisać w formacie XML, użyj SaveAsXml w następujący sposób:

newXLFile.SaveAsXml($@"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML");

newXLFile.SaveAsXml($@"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML");

newXLFile.SaveAsXml($"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML")

Wynik wygląda następująco:

<?xml version="1.0" standalone="yes"?>
<_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Hello World</Column1>
  </_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" />
  </_x0031_stWorkSheet>
</_x0031_stWorkSheet>

<?xml version="1.0" standalone="yes"?>
<_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Hello World</Column1>
  </_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" />
  </_x0031_stWorkSheet>
</_x0031_stWorkSheet>

IronXL zapewnia bardziej zwięzły interfejs API do odczytu plików Excel — dostęp do kolumn, wierszy i komórek w skoroszycie zazwyczaj wymaga mniejszego nakładu kodu. Natomiast EPPlusudostępnia bardziej szczegółowy interfejs API na poziomie komórek, który wymaga jawnej obsługi kolumn i wierszy, co zapewnia precyzyjną kontrolę, ale zwiększa rozbudowanie kodu.

IronXL oferuje większą elastyczność podczas pracy z dokumentami Excel. Umożliwia tworzenie dodatkowych arkuszy w dowolnym momencie, odczytywanie danych z wielu arkuszy i skoroszytów w ramach jednego przepływu pracy oraz eksportowanie danych ze skoroszytu bezpośrednio do bazy danych. EPPluskoncentruje swoje API na pracy z pojedynczymi arkuszami — podejście to jest proste w przypadku zadań dotyczących pojedynczych arkuszy, ale wymaga dodatkowych kroków integracyjnych dla zespołów potrzebujących operacji obejmujących wiele skoroszytów.

Jak EPPlusi IronXLwypadają w porównaniu pod względem licencji i cen?

Którą bibliotekę wybrać?

EPPlus zapewnia solidne, ugruntowane API do pracy z arkuszami kalkulacyjnymi Office Open XML, a jego szczegółowa kontrola na poziomie komórki pasuje do projektów, które wymagają precyzyjnej manipulacji arkuszami. Dla zespołów, których wymagania obejmują eksport w wielu formatach (XML, HTML, JSON), operacje między skoroszytami i integrację z bazami danych, IronXLdodaje te możliwości jako operacje pierwszej klasy. IronXLprzelicza również formuły za każdym razem, gdy dokument jest edytowany i zapewnia intuicyjną składnię zakresu z WorkSheet[“A1:B10”]. Formaty danych komórek obejmują tekst, liczby, formuły, daty, walutę, wartości procentowe, notację naukową i czas, podczas gdy stylizacja komórek obejmuje czcionki, rozmiary, wzory tła, obramowania i wyrównania. Sortowanie jest dostępne dla zakresów, kolumn i wierszy. Wybór między tymi dwoma narzędziami zależy od tego, czy projekt wymaga obsługi Open XML przez EPPlus, czy też szerszego zakresu funkcji IronXL. Aby zobaczyć, jak IronXLpasuje do Twojego przepływu pracy, pobierz bezpłatną 30-dniową wersję próbną i przetestuj przykłady z tego artykułu we własnym środowisku.