Ein Vergleich zwischen IronXL und Epplus

Was ist EPPlus-Software?

EPPlus ist eine auf NuGet basierende .NET Framework/.NET Core-Bibliothek zur Verwaltung von Office Open XML-Tabellenkalkulationen. Version 5 unterstützt .NET Framework 3.5 und .NET Core 2.0. EPPlus ist unabhängig von anderen Bibliotheken wie Microsoft Excel.

EPPlus bietet eine API, die es ermöglicht, mit Excel-Dokumenten von Office zu arbeiten. EPPlus ist eine .NET-Bibliothek, die Office OpenXML-formatierte Excel-Dateien liest und schreibt. Diese Bibliothek ist als Paket von NuGet verfügbar.

Die Bibliothek wurde für Programmierer entwickelt. Das Ziel war immer, dass ein Entwickler, der mit Excel oder einer anderen Tabellenkalkulationsbibliothek vertraut ist, die API schnell erlernen kann. Alternativ, wie jemand sagte: 'IntelliSense your way to victory!'

EPPlus-Installation

Um EPPlus aus Visual Studio zu installieren, gehen Sie zu Ansicht > Weitere Fenster > Paket-Manager-Konsole und geben Sie folgenden Befehl ein:

Install-Package EPPlus

Wenn Sie lieber die .NET CLI verwenden möchten, führen Sie den folgenden Befehl von einem erhöhten Eingabeaufforderungs- oder PowerShell-Eingabeaufforderungsfenster aus:

dotnet add package EPPlus

EPPlus ist ein .NET-Paket, das Sie zu Ihrem Projekt hinzufügen können.

Was ist IronXL?

IronXL ist eine C#- und VB-Excel-API, mit der Sie Excel-Tabellendateien in .NET lesen, bearbeiten und erstellen können, ohne Microsoft Office installieren oder auf Excel Interop zurückgreifen zu müssen. Die Bibliothek verarbeitet XLS, XLSX, CSV und andere Tabellenformate nativ.

.NET Core, .NET Framework, Xamarin, Mobil, Linux, macOS und Azure werden alle von IronXL unterstützt.

Es gibt verschiedene Möglichkeiten, Daten zu und von Ihrer Tabelle zu lesen und zu schreiben.

Hinzufügen von IronXL mit dem NuGet-Paket

Wir können das IronXL-Paket auf eine von drei Arten zu Ihrem Konto hinzufügen, sodass Sie diejenige auswählen können, die für Sie am besten funktioniert.

• Verwenden Sie die Paket-Manager-Konsole, um IronXL zu installieren

Verwenden Sie den folgenden Befehl, um die Paket-Manager-Konsole in Ihrem Projekt zu öffnen:

Um auf die Paket-Manager-Konsole zuzugreifen, wählen Sie Tools => NuGet-Paket-Manager => Paket-Manager-Konsole.

Dadurch gelangen Sie zur Paket-Manager-Konsole. Geben Sie dann im Paket-Manager-Terminal den folgenden Befehl ein:

Install-Package IronXL.Excel

• Verwenden Sie den NuGet-Paket-Manager, um IronXL zu installieren

Dies ist ein anderer Ansatz, um den NuGet-Paket-Manager zu installieren. Sie müssen diesen Ansatz nicht nutzen, wenn Sie die Installation bereits mit der vorherigen Methode abgeschlossen haben.

Um auf den NuGet-Paket-Manager zuzugreifen, wählen Sie Tools > NuGet-Paket-Manager => Verwalten von NuGet-Paketen für die Lösung aus dem Dropdown-Menü.

Dadurch wird die NuGet-Lösung geöffnet; wählen Sie "Durchsuchen" und suchen Sie nach IronXL.

Geben Sie im Suchfeld Excel ein:

IronXL wird für Sie installiert, wenn Sie auf die Schaltfläche "Installieren" klicken. Nach der Installation von IronXL können Sie zu Ihrem Formular gehen und es entwickeln.

Bevor wir uns mit Codebeispielen befassen, hier ein direkter Vergleich von EPPlus und IronXL in den wichtigsten, in diesem Artikel besprochenen Bereichen:

Feature	EPPlus	IronXL
XLSX-Dateien lesen	Ja	Ja
XLSX-Dateien erstellen	Ja	Ja
Unterstützung für das XLS-Format	Nein	Ja
Export nach CSV, JSON, XML	Nur CSV	CSV, JSON, XML
Datenbankexport (Entity Framework)	Nicht enthalten	Ja
Hilfsfunktionen zur Datenvalidierung	Nicht enthalten	Ja
Operationen mit mehreren Arbeitsmappen	Fokus auf ein einzelnes Arbeitsblatt	Mehrere Arbeitsblätter und mehrere Arbeitshefte
Lizenzierung	Kommerziell oder Polyform Nichtkommerziell	Kommerziell (dauerhaft)

Um die Excel-Operationen von IronXL im Vergleich zu EPPlus in Ihrem eigenen Projekt zu testen, ist eine kostenlose 30-Tage-Testversion verfügbar.

Erstellen einer Excel-Datei mit IronXL

Das Erstellen einer neuen Excel-Arbeitsmappe mit IronXL erfordert nur eine einzige Codezeile:

// 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 kann Dateien im XLS-Format (ältere Excel-Dateiversion) und im XLSX-Format (aktuelle und neuere Excel-Dateiversion) erstellen und dabei den vollen Funktionsumfang von Excel nutzen.

• Standardarbeitsblatt festlegen

Es ist sogar einfacher, ein Standardarbeitsblatt einzurichten:

// 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")

Das Arbeitsblatt wird durch sheet im obigen Code-Snippet dargestellt, und Sie können es verwenden, um Zellenwerte und -stile festzulegen und praktisch alles zu tun, was Excel kann. Sie können Ihr Excel-Dokument auch in eine schreibgeschützte Datei kodieren und Löschvorgänge ausführen. Sie können Ihre Arbeitsblätter auch verknüpfen, genau wie Excel.

Lassen Sie mich den Unterschied zwischen einem Arbeitsbuch und einem Arbeitsblatt klären, falls Sie sich nicht sicher sind.

Arbeitsblätter sind in einem Arbeitsbuch enthalten. Das bedeutet, dass Sie so viele Arbeitsblätter in einem Arbeitsbuch haben können, wie Sie möchten. Ich werde in einem späteren Artikel erklären, wie Sie dies tun können. Ein Arbeitsblatt besteht aus Zeilen und Spalten. Der Schnittpunkt einer Zeile und einer Spalte wird als Zelle bezeichnet, und dies ist es, mit dem Sie in Excel interagieren.

Erstellen einer Excel-Datei mit EPPlus Software AB

EPPlus kann verwendet werden, um Excel-Dateien zu erstellen und Vorgänge wie das Erstellen von Pivot-Tabellen, Pivot-Bereichen und sogar bedingte Formatierungen und das Ändern von Schriftarten auszuführen. Ohne weitere Verzögerung finden Sie hier den gesamten Quellcode zum Konvertieren eines normalen DataTable in eine XLSX Excel-Datei und zum Senden an den Benutzer zum Herunterladen:

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

Wie Sie sehen, ist dies eine ActionResult-Methode, die auf jedem ASP.NET MVC-Controller verwendet werden kann; wenn Sie kein ASP.NET MVC verwenden, kopieren Sie einfach den Methodeninhalt und fügen Sie ihn an der gewünschten Stelle ein (z. B. klassisches ASP.NET, Konsolenanwendung, Windows Forms usw.).

Der Code ist selbsterklärend, mit genügend Kommentaren, um Ihnen beim Verständnis der verschiedenen Verarbeitungsprozesse zu helfen. Aber zuerst eine kurze Zusammenfassung dessen, was wir hier machen:

• Mit einer benutzerdefinierten Data-Provider-Methode erhalten wir ein DataTable-Objekt.
• Wir erstellen ein ExcelPackage-Objekt, das der primäre Container für die XLSX-Datei von EPPlus ist.
• Wir fügen ein ExcelWorksheet dem ExcelPackage hinzu, das das Arbeitsblatt sein wird, in das die Daten eingegeben werden.
• Um unsere Kopfzeile zu erstellen, iterieren wir die DataTable-Spalten und fügen sie in die erste Zeile unseres Arbeitsblatts ein.
• Wir iterieren durch die DataTable-Zeilen und fügen jede Zeile in unser Arbeitsblatt Zeile für Zeile ein (beginnend mit Zeile 2), sodass jede DataTable-Zeile einer Arbeitsblattzeile entspricht.
• Wir erstellen ein MemoryStream, um die ExcelPackage-Binärdaten zu speichern, wenn die DataTable- zu ExcelPackage-Konvertierung abgeschlossen ist, und konvertieren es dann in ein Byte-Array.
• Wir erstellen die HTML-Antwort und senden die XLSX-Datei mit einem Content-Disposition-Anhang an den Benutzer, sodass der Browser die Datei automatisch herunterlädt.

Der Ansatz von IronXL zur Erstellung von Arbeitsmappen erfordert eine einzige Codezeile im Vergleich zum mehrstufigen Setup von EPPlus, das ExcelPackage, ExcelWorksheet und manuelles Zelliteration beinhaltet. Für Teams, die Wert auf schnelles Prototyping und einfacheres Debugging legen, kann sich dieser Unterschied im Boilerplate-Code im Laufe des Projektlebenszyklus summieren.

Wie EPPlus Software AB Excel-Dateien schreibt

EPPlus unterstützt die Arbeit mit Excel-Dateien. Es ist eine .NET Bibliothek, die Excel-Dateien liest und schreibt.

• Lesen von Excel-Dateien

Um dies zu tun, müssen Sie zuerst das Paket EPPlus installieren: gehen Sie zu "Tools"-> "NuGet-Paket-Manager"-> "NuGet für diese Lösung verwalten" -> "EPPlus installieren" -> "EPPlus installieren" -> "EPPlus installieren" -> "EPPlus installieren" -> "EPPlus installieren" -> "EP installieren". Suchen Sie im Tab "Durchsuchen" nach "EPPlus" und installieren Sie dann das NuGet-Paket.

Sobald Sie das Paket installiert haben, können Sie den folgenden Code in Ihrer Konsolenanwendung "Program.cs" verwenden.

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

Hier ist ein Beispiel für eine Konsolenanwendungsausgabe mit einer Beispieldatei (.xlsx), mit der wir arbeiten. Hier ist eine xlsx-Datei zum Lesen in C# mit EPPlus.

Die folgenden Möglichkeiten zum Laden von Daten aus verschiedenen Quellen können mit der Eigenschaft "cells" (ExcelRange) aufgerufen werden:

• Lesen Sie eine CSV-Textdatei und laden Sie die Daten mit LoadFromText und LoadFromTextAsync in einen Bereich auf einem Arbeitsblatt. IronXL bietet außerdem eigene CSV-Export- und Importfunktionen .
• LoadFromDataReaderAsync und LoadFromDataReader laden Datenfelder aus einem DataReader in einen Bereich.
• LoadFromDataTable lädt Daten aus einem DataTable in einen Bereich. Es können Daten aus verschiedenen Quellen, einschließlich XML (ein Beispiel wird geliefert) und Datenbanken, importiert werden.
• LoadFromCollection lädt Daten reflexiv aus einem IEnumerable in einen Bereich.
• LoadFromCollection mit Attributen lädt Daten reflexiv aus einem IEnumerable in einen Bereich oder eine Tabelle. Stile, Zahlenformate, Formeln und andere Eigenschaften werden über Attribute definiert.
• LoadFromDictionaries lädt Daten aus einem IEnumerable von ExpandoObject/dynamischen Objekten (über ihre IDictionary<string, object>-Schnittstelle) in einen Bereich. Dies ist nützlich für den Import von JSON-Daten, und ein Beispiel ist enthalten.
• LoadFromArrays lädt Daten aus einem IEnumerable von Objekt-[] in einen Bereich, wobei jedes Objektarray einer Zeile im Arbeitsblatt entspricht.

Bei der Nutzung dieser Methoden können Sie optional einen Parameter angeben, um eine Excel-Tabelle zu erstellen. Die Proben 4 und 5 des Beispielprojekts Sample-.NET Framework oder Sample-.NET Framework enthalten umfangreichere Beispiele.

• Schreiben von Excel-Dateien

Lassen Sie uns als Nächstes sehen, ob wir Daten in eine neue Excel-Datei exportieren können.

Hier sind einige Beispieldaten/-objekte, die wir als Excel-Dokument speichern möchten.

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"
	}
}

Um eine neue Excel-Datei mit den wesentlichen Informationen zu erstellen, müssen wir die ExcelPackage-Klasse verwenden. Das Schreiben von Daten in eine Datei und das Erstellen eines neuen Excel-Arbeitsblatts kostet nur ein paar Codezeilen. Beachten Sie bitte die folgende Zeile, die den magischen Trick des Ladens von DataTables in ein Excel-Blatt vollzieht.

Um die Dinge einfach zu halten, erstelle ich eine neue Tabellendatei im gleichen Projektordner (die Excel-Datei wird im 'bin'-Ordner des Projekts erstellt). Der Quellcode ist unten:

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

Nach dem oben erwähnten API-Aufruf zur Datenvalidierung wird eine neue Excel-Datei erstellt, indem das obige benutzerdefinierte Objekt in die entsprechenden Excel-Spalten und -Reihen umgewandelt wird, um den untenstehenden Wert anzuzeigen.

Die oben bereitgestellte API kann in der .NET Core-Konsole, einem Testprojekt oder einer ASP.NET Core-Anwendung verwendet werden, und die Logik kann angepasst werden, um Ihren Anforderungen gerecht zu werden.

Diese Techniken können mit der Eigenschaft "cells" (ExcelRange) aufgerufen werden:

• ToText und ToTextAsync - erstellt eine CSV-Zeichenfolge aus einem Bereich.
• Schreiben Sie einen Bereich in eine CSV-Datei mit SaveToText und SaveToTextAsync.
• Exportieren von Daten aus einem Bereich in ein System mit der Methode ToDataTable. DataTable
• GetValue - zeigt einen Wert mit der Option eines Datentyps an.
• Value - gibt den Wert des Bereichs zurück oder setzt ihn.

Die GetValue- und SetValue-Methoden können auch direkt auf dem Arbeitsblattobjekt verwendet werden. (Dies wird etwas bessere Ergebnisse liefern als das Lesen/Schreiben im Bereich):

• GetValue - erhält den Wert einer einzelnen Zelle, mit der Option, einen Datentyp anzugeben.
• SetValue - ändert den Wert einer einzelnen Zelle.

Linq kann verwendet werden, um Daten aus einem Arbeitsblatt abzufragen, da die Zelleneigenschaft die IEnumerable-Schnittstelle implementiert.

Öffnen und Schreiben von Office Open XML Format XLSX mit IronXL

IronXL ist eine .NET-Bibliothek, die es C#-Entwicklern ermöglicht, schnell und einfach mit Excel-, Pivot-Tabellen und anderen Tabellenkalkulationsdateien zu arbeiten.

Office Interop ist nicht erforderlich. Es gibt keine speziellen Abhängigkeiten oder die Notwendigkeit, Microsoft Office auf Core oder Azure zu installieren.

IronXL ist eine renommierte C#- und VB.NET-XL-Tabellenkalkulationsbibliothek für .NET Core und .NET Framework.

• Lesen von Excel-Dateien
• Arbeitsblatt zu laden

Ein Excel-Blatt wird durch die WorkBook-Klasse dargestellt. Wir verwenden WorkBook, um eine Excel-Datei in C# zu lesen, die sogar Pivot-Tabellen enthält. Laden Sie die Excel-Datei und wählen Sie ihren Speicherort (.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")

WorkSheet-Objekte können in zahlreichen WorkBooks gefunden werden. Dies sind die Arbeitsblätter des Excel-Dokuments. Wenn das Blatt Arbeitsblätter enthält, verwenden Sie den Namen WorkBook, um sie mit GetWorkSheet zu finden.

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

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

Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

• Erstellen Sie Ihr eigenes Workbook.

Erstellen Sie ein neues WorkBook mit dem Blatt-Typ, um ein neues Arbeitsbuch im Speicher zu generieren.

/**
 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)

Für alte Microsoft Excel-Tabellen, verwenden Sie ExcelFileFormat.XLS (95 und älter).

Erstellen Sie ein WorkSheet, wenn Sie noch keines haben.

Es kann zahlreiche WorkSheets in jedem "WorkBook" geben. Ein "WorkSheet" ist ein einzelnes Datenblatt, während ein "WorkBook" eine Sammlung von WorkSheets ist. So sieht ein Arbeitsbuch mit zwei Arbeitsblättern in Excel aus.

Die WorkBook ist der Name eines neuen WorkSheet, das Sie erstellen können.

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

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

Dim worksheet = workbook.CreateWorkSheet("Countries")

Geben Sie den Namen des Arbeitsblatts an CreateWorkSheet weiter.

Erhalten Sie den zellularen Bereich

Eine zweidimensionale Sammlung von "Cell"-Objekten wird durch die "Range"-Klasse dargestellt. Es bezeichnet einen bestimmten Bereich von Excel-Zellen. Sie können Bereiche mithilfe des Zeichenkettenindexers auf ein WorkSheet-Objekt beziehen.

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

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

Dim range = worksheet("D2:D101")

Der Argumenttext kann eine Zellenkoordinate sein (z. B. "A1") oder ein Bereich von Zellen von links nach rechts, oben nach unten (z. B. "B2:E5"). GetRange kann auch aus einem Arbeitsblatt aufgerufen werden.

• Werte innerhalb eines Bereichs bearbeiten

Die Werte von Zellen innerhalb eines Bereichs können auf verschiedene Weise gelesen oder bearbeitet werden. Verwenden Sie eine For-Schleife, wenn die Anzahl bekannt ist. Sie können das Zellenstyling auch von hier aus durchführen.

/**
 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

Daten in Tabellenkalkulationen validieren

Um ein Datenblatt zu validieren, verwenden Sie IronXL. Das DataValidation-Beispiel validiert Telefonnummern mit libphonenumber-C# und E-Mail-Adressen sowie Daten mit herkömmlichen C# APIs.

/**
 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

Der obige Code durchläuft die Zeilen des Tabellenblatts und erfasst die Zellen als Liste. Jede validierte Methode überprüft den Wert einer Zelle und gibt einen Fehler zurück, wenn der Wert unrichtig ist.

Dieser Code erstellt ein neues Blatt, definiert Header und erzeugt die Fehlermeldungsergebnisse, sodass ein Protokoll von fehlerhaften Daten geführt werden kann.

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")

Verwenden des Entity Frameworks zum Exportieren von Daten

Verwenden Sie IronXL, um eine Excel-Tabelle in eine Datenbank zu konvertieren oder Daten in eine Datenbank zu exportieren. Das ExcelToDB-Beispiel liest eine Tabelle mit BIP nach Nation und exportiert sie nach SQLite.

Es erstellt die Datenbank mit EntityFramework und exportiert dann die Daten zeilenweise.

Die SQLite Entity Framework NuGet-Pakete sollten installiert werden.

Sie können mit EntityFramework ein Modellobjekt erstellen, das Daten in eine Datenbank exportieren kann.

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

Um eine andere Datenbank zu verwenden, installieren Sie das entsprechende NuGet-Paket und suchen Sie nach dem UseSqLite-Äquivalent (UseMySQL, UseSqlServer, usw.).

/**
 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

Erzeugen Sie ein CountryContext, dann iterieren Sie durch den Bereich, um jeden Eintrag zu erstellen, bevor Sie die Daten mit SaveChangesAsync in die Datenbank speichern.

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

Eine Formel in eine Tabelle einfügen

Die Formula-Eigenschaft kann verwendet werden, um die Formel einer Zelle festzulegen.

// 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

Der Code in Spalte C durchläuft jeden Zustand und berechnet einen prozentualen Gesamtwert.

Daten von einer API können in eine Tabelle heruntergeladen werden

In dem folgenden Aufruf wird RestClient.Net verwendet, um einen REST-Aufruf durchzuführen. Es lädt JSON herunter und wandelt es in eine RestCountry-Typ-"Liste" um. Die Daten aus der REST-API können dann durch Iteration durch jedes Land einfach in einer Excel-Datei gespeichert werden.

/**
 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))()

Die JSON-Daten aus der API sehen so aus:

Der folgende Code durchläuft die Länder und füllt das Tabellenblatt mit Name, Bevölkerung, Region, numerischem Code und den Top-3-Sprachen.

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

Öffnen von Excel-Dateien mit IronXL

Nachdem Sie die Excel-Datei gestartet haben, fügen Sie die ersten Zeilen hinzu, die die erste Zelle im ersten Blatt lesen und ausdrucken.

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);
}

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

Verwenden Sie IronXL, um eine neue Excel-Datei zu erstellen.

/**
 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;
}

'''
''' Create Excel File
''' *
Shared Sub Main(ByVal 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

Anschließend können Sie die Daten entweder im CSV-, JSON- oder XML-Format speichern, indem Sie die entsprechenden Codes verwenden, wie in den IronXL -Codebeispielen gezeigt.

Beispielsweise, um nach XML zu speichern .xml

Um nach XML zu speichern, verwenden Sie SaveAsXml wie folgt:

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

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

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

Das Ergebnis sieht so aus:

<?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 bietet eine kompaktere API zum Lesen von Excel-Dateien – der Zugriff auf Spalten, Zeilen und Zellen in einer Arbeitsmappe erfordert in der Regel weniger Codezeilen. EPPlus hingegen bietet eine detailliertere API auf Zellenebene, die eine explizite Spalten- und Zeilenbehandlung erfordert, was zwar eine feinere Steuerung ermöglicht, aber die Ausführlichkeit erhöht.

IronXL bietet mehr Flexibilität bei der Bearbeitung von Excel-Dokumenten. Es unterstützt das Erstellen zusätzlicher Tabellenblätter zu jedem beliebigen Zeitpunkt, das Einlesen von Daten aus mehreren Tabellenblättern und Arbeitsmappen in einem einzigen Arbeitsablauf sowie den direkten Export von Arbeitsmappendaten in eine Datenbank. EPPlus konzentriert sich bei seiner API auf die Arbeit mit einzelnen Arbeitsblättern – ein Ansatz, der für Aufgaben mit nur einem Arbeitsblatt unkompliziert ist, aber zusätzliche Integrationsschritte für Teams erfordert, die arbeitsmappenübergreifende Operationen benötigen.

Wie schneiden EPPlus und IronXL im Hinblick auf Lizenzierung und Preisgestaltung im Vergleich ab?

Welche Bibliothek sollten Sie wählen?

EPPlus bietet eine solide, etablierte API für die Arbeit mit Office Open XML-Tabellenkalkulationen, und seine detaillierte Steuerung auf Zellenebene eignet sich für Projekte, die eine präzise Bearbeitung der Tabellenblätter erfordern. Für Teams, deren Anforderungen sich auf den Export in verschiedene Formate (XML, HTML, JSON), arbeitsmappenübergreifende Operationen und die Datenbankintegration erstrecken, bietet IronXL diese Funktionen als erstklassige Operationen an. IronXL berechnet auch bei jeder Bearbeitung des Dokuments die Formeln neu und bietet eine intuitive Bereichssyntax mit WorkSheet[“A1:B10”]. Zelldatenformate umfassen Text, Zahlen, Formeln, Datumsangaben, Währungen, Prozentsätze, wissenschaftliche Notation und Zeitangaben, während die Zellformatierung Schriftarten, Größen, Hintergrundmuster, Rahmen und Ausrichtungen umfasst. Sortierung ist über Bereiche, Spalten und Zeilen möglich. Die Wahl zwischen den beiden hängt letztendlich davon ab, ob Ihr Projekt die fokussierte Open-XML-Verarbeitung von EPPlus oder den breiteren Funktionsumfang von IronXL benötigt. Um zu sehen, wie IronXL in Ihren Arbeitsablauf passt, laden Sie eine kostenlose 30-Tage-Testversion herunter und testen Sie die Beispiele aus diesem Artikel in Ihrer eigenen Umgebung.