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 dotnet-Paket, das Sie Ihrem Projekt hinzufügen können.

Was ist IronXL?

IronXL ist eine einfache C#- und VB-Excel-API, die es ermöglicht, Excel-Tabellenkalkulationsdateien in .NET blitzschnell zu lesen, zu bearbeiten und zu erstellen. Es ist nicht notwendig, Microsoft Office oder sogar Excel Interop zu installieren. Diese Bibliothek kann auch verwendet werden, um mit Excel-Dateien zu arbeiten.

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

class="content-img-align-center">

class="center-image-wrapper">

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

Install-Package IronXL.Excel

class="content-img-align-center">

class="center-image-wrapper">

• 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:

class="content-img-align-center">

class="center-image-wrapper">

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.

Erstellen einer Excel-Datei mit IronXL

Ein neues Excel-Arbeitsbuch mit IronXL zu erstellen, könnte nicht einfacher sein! Es ist nur eine einzige Codezeile! Ja, das ist wahr:

// 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- (älterer Excel-Dateiversion) und XLSX-Format (aktuelle und neue Excel-Dateiversion) erstellen.

• 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 im obigen Code-Snippet durch sheet dargestellt und Sie können es verwenden, um Zellenwerte festzulegen und praktisch alles auszuführen, 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 weiteres können Sie hier den gesamten Quellcode sehen, um eine normale DataTable in eine XLSX-Excel-Datei zu konvertieren und sie dem Benutzer zum Download bereitzustellen:

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 können, ist dies eine ActionResult-Methode, die in 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 Datenanbieter-Methode erhalten wir ein DataTable-Objekt.
• Wir erstellen ein ExcelPackage-Objekt, was der Hauptcontainer der XLSX-Datei in EPPlus ist.
• Wir fügen ein ExcelWorksheet zum ExcelPackage hinzu, das das Arbeitsblatt sein wird, in das die Daten eingegeben werden.
• Um unsere Kopfzeile zu erstellen, durchlaufen wir die DataTable-Spalten und fügen sie der ersten Zeile unseres Arbeitsblatts hinzu.
• Wir durchlaufen die DataTable-Zeilen und fügen jede Zeile unseres Arbeitsblatts zeilenweise hinzu (beginnend mit Zeile 2), sodass jede DataTable-Zeile einer Arbeitsblattzeile entspricht.
• Wir erstellen einen MemoryStream, um die Binärdaten des ExcelPackage zu speichern, wenn die Konvertierung von DataTable zu ExcelPackage abgeschlossen ist, und konvertieren sie 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.

IronXL gewinnt in diesem Fall, da der Erstellungsprozess sehr einfach ist - Sie benötigen nur eine Codezeile und sind dabei; Dies hilft, Zeit zu sparen und beim Debugging, während EPPlus Zeilen von Code anbietet, die langweilig durchzugehen und schwierig zu debuggen sind.

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

Dazu müssen Sie zuerst das Paket EPPlus installieren: "Tools" -> "NuGet-Paket-Manager" -> "NuGet für diese Lösung verwalten" -> "EPPlus installieren" -> "EPPlus installieren" -> "EPInstallPlus...". Suchen Sie im Tab "Durchsuchen" nach "EPPlus" und installieren Sie dann das NuGet-Paket.

class="content-img-align-center">

class="center-image-wrapper">

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.

class="content-img-align-center">

class="center-image-wrapper">

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

• Eine CSV-Textdatei lesen und die Daten mit LoadFromText und LoadFromTextAsync in einen Bereich eines Arbeitsblatts laden.
• LoadFromDataReaderAsync und LoadFromDataReader - lädt Datenfelder von einem DataReader in einen Bereich.
• LoadFromDataTable - lädt Daten aus einer 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 von einem IEnumerable in einen Bereich.
• LoadFromCollection mit Attributen - lädt Daten reflexiv von einem IEnumerable in einen Bereich oder eine Tabelle. Stile, Zahlenformate, Formeln und andere Eigenschaften werden über Attribute definiert.
• LoadFromDictionaries - lädt Daten von einer 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 von einer 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. Beispiele 4 und 5 des Beispielprojekts Sample-.NET Framework oder Sample-.NET Framework enthalten ausführlichere 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. Bitte beachten Sie die eine Zeile darunter, die die Magie des Ladens von DataTables in ein Excel-Blatt ausführt.

class="content-img-align-center">

class="center-image-wrapper">

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.

class="content-img-align-center">

class="center-image-wrapper">

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 eines Bereichs 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 Methoden GetValue und SetValue 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 Zelleigenschaft das IEnumerable-Interface 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 öffnen, 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.

Konstruiere ein neues WorkBook mit dem Typ des Blattes, um ein neues Workbook 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-Tabellenkalkulationen verwenden Sie ExcelFileFormat.XLS (95 und früher).

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.

class="content-img-align-center">

class="center-image-wrapper">

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

Übergeben Sie den Namen des Arbeitsblatts an CreateWorkSheet.

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 von einem WorkSheet 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-CSharp sowie E-Mail-Adressen und 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 Beispiel ExcelToDB liest eine Tabelle, die das BIP nach Land enthält, 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.

class="content-img-align-center">

class="center-image-wrapper">

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

Erstellen Sie ein CountryContext, durchlaufen Sie dann 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:

class="content-img-align-center">

class="center-image-wrapper">

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

Danach können Sie entweder in CSV, JSON oder XML mit deren jeweiligen Codes speichern.

Zum Beispiel, um in XML zu speichern .xml

Um in 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>

Das Lesen von Excel-Dateien ist mit IronXL einfacher als mit EPPlus. IronXL hat mehr verkürzte Codes, die alles umfassen, was benötigt wird, um auf alle Spalten, Zeilen und Zellen in einem Arbeitsbuch zuzugreifen, während Sie bei EPPlus eine spezielle Codezeile benötigen, um Spalten und Zeilen zu lesen.

IronXL ist intelligenter, wenn es um die Manipulation von Excel-Dokumenten geht. Es verschafft Ihnen den Vorteil, jederzeit mehr Blätter zu erstellen sowie Daten aus mehreren Arbeitsblättern und Arbeitsbüchern zu lesen, während sich EPPlus jeweils mit einem Arbeitsblatt befasst. Mit IronXL können Sie Ihr Excel-Arbeitsbuch auch mit der Datenbank füllen.

EPPlus- und IronXL Lizenzierung und Preise

Abschluss

Zusammenfassend lässt sich sagen, dass IronXL praktischer ist als EPPlus, da es Ihnen die Flexibilität gibt, in der Excel-Tabelle nach Bedarf zu navigieren, mit kürzeren Codezeilen und mehr Möglichkeiten zum Exportieren, einschließlich XML, HTML und JSON. IronXL ermöglicht es Ihnen auch, Ihre Arbeitsbuchdaten in eine Datenbank zu integrieren. Darüber hinaus verfügt es über ein intuitives System, das Formeln jedes Mal neu berechnet, wenn das Dokument bearbeitet wird, und es bietet eine Intuitive Ranges-Einstellung mit einer WorkSheet["A1:B10"]-Syntax. Die Blattfunktionen umfassen Formeln, die mit Excel funktionieren, und werden jedes Mal neu berechnet, wenn ein Blatt bearbeitet wird. Die Zellenformate haben mehrere Texte, Zahlen, Formeln, Daten, Währung, Prozentsätze, wissenschaftliche Notationen und Zeiten. Ihre benutzerdefinierten Formate haben verschiedene Sortiermethoden wie Bereiche, Spalten und Zeilen. Das Zellenstyling umfasst eine Vielzahl von Schriftarten, Größen, Hintergrundmustern, Rahmen und Ausrichtungen.