Ein Vergleich zwischen IronXL und Epplus

In diesem Artikel werden die Gemeinsamkeiten und Unterschiede zwischen der IronXL- und der EPPlus-Software untersucht.

Für die meisten Unternehmen hat sich Microsoft Excel als äußerst nützliches Werkzeug erwiesen. Excel-Dateien, wie z. B. Datenbanken, enthalten Daten in Zellen, was die Verwaltung von Daten, die gespeichert werden müssen, vereinfacht.

Die Dateiformate.xls und.xlsx werden auch von Excel verwendet. Die Sprache C# kann es schwierig machen, Excel-Dateien zu verwalten. IronXL und die EPPlus-Software erleichtern jedoch die Abwicklung dieser Prozesse.

Microsoft Office ist für die Verwendung dieser Software nicht erforderlich.

Bitte beachten Sie, dass Sie Excel-Dateien in C# lesen und erstellen können, ohne Microsoft Office installieren zu müssen. Heute schauen wir uns einige verschiedene Optionen an, die einfach zu implementieren sind.

Was ist die EPPlus-Software?

EPPlus ist eine NuGet-basierte .NET-Framework/.NET Core-Bibliothek zur Bearbeitung von Office Open XML-Tabellenblättern. Die Version 5 unterstützt das .NET-Framework 3.5 und .NET Core 2.0. EPPlus ist nicht auf andere Bibliotheken angewiesen, wie z. B. Microsoft Excel.

EPPlus verfügt über eine API, mit der Sie mit Office Excel-Dokumenten arbeiten können. EPPlus ist eine .NET-Bibliothek, die Office OpenXML-formatierte Excel-Dateien liest und schreibt. Diese Bibliothek ist als Paket von NuGet erhältlich.

Die Bibliothek wurde mit Blick auf Programmierer entwickelt. Das Ziel war immer, dass ein Entwickler, der mit Excel oder einer anderen Tabellenkalkulationsbibliothek vertraut ist, die API schnell erlernen kann. Oder, wie es jemand ausdrückte: "Mit IntelliSense zum Sieg!"

EPPlus-Einrichtung

Um EPPlus von Visual Studio aus zu installieren, gehen Sie zu Ansicht > Andere Fenster > Paketmanager-Konsole und geben Sie den folgenden Befehl ein:

pM> Installieren-Paket EPPlus

Wenn Sie lieber die .NET CLI verwenden möchten, führen Sie den folgenden Befehl über eine erweiterte Eingabeaufforderung oder eine PowerShell-Eingabeaufforderung aus:

pM> dotnet add Paket EPPlus"

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

Was ist IronXL?

IronXL ist eine einfache C#- und VB-Excel-API, mit der Sie Excel-Tabellendateien in .NET blitzschnell lesen, bearbeiten und erstellen können. Es ist nicht notwendig, Microsoft Office oder sogar Excel Interop zu installieren. Diese Bibliothek kann auch für die Arbeit mit Excel-Dateien verwendet werden.

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

Es gibt eine Reihe von Möglichkeiten, Daten in Ihre Tabellenkalkulation zu lesen und zu schreiben.

Hinzufügen von IronXL mit NuGet-Paket

Wir können das IronXL-Paket auf drei verschiedene Arten zu Ihrem Konto hinzufügen, so dass Sie die für Sie günstigste Variante wählen können.

• Verwendung der Paketmanager-Konsole zur Installation von IronXL

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

  Um auf die Paketmanager-Konsole zuzugreifen, gehen Sie zu Tools => NuGet Package Manager => Paketmanager-Konsole.

  

  Dies bringt Sie zur Paketmanager-Konsole. Geben Sie dann im Terminal des Paketmanagers den folgenden Befehl ein:

pM > Installieren-Paket IronXL.Excel"

• Installation von IronXL mit dem NuGet Package Manager

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

  Um auf den NuGet-Paketmanager zuzugreifen, gehen Sie zu Extras > NuGet-Paketmanager => Wählen Sie im Dropdown-Menü NuGet-Pakete für die Lösung verwalten.

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

  Geben Sie in der Suchleiste 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 mit dessen Entwicklung beginnen.

Erstellen einer Excel-Datei mit IronXL

Die Erstellung einer neuen Excel-Arbeitsmappe mit IronXL könnte nicht einfacher sein! Es ist nur eine einzige Codezeile! Ja, das ist wahr:

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

IronXL kann Dateien im XLS-Format erstellen (die frühere Version der Excel-Datei) und XLSX (aktuelle und neuere Version der Excel-Datei) formate.

• Ein Standard-Arbeitsblatt festlegen

  Noch einfacher ist es, ein Standard-Arbeitsblatt einzurichten:

  var sheet = workbook.CreateWorkSheet("Haushalt 2020");

  Das Arbeitsblatt wird im obigen Codeschnipsel durch "Sheet" dargestellt, und Sie können damit Zellwerte festlegen und praktisch alles tun, was Excel tun kann. Sie können Ihr Excel-Dokument auch als schreibgeschützte Datei kodieren und Löschvorgänge durchführen. Sie können Ihre Arbeitsblätter auch miteinander verknüpfen, genau wie in Excel.

  Lassen Sie mich den Unterschied zwischen einer Arbeitsmappe und einem Arbeitsblatt erklären, falls Sie sich nicht sicher sind.

  Die Arbeitsblätter sind in einer Arbeitsmappe enthalten. Das bedeutet, dass Sie so viele Arbeitsblätter in eine Arbeitsmappe einfügen können, wie Sie möchten. Wie man das macht, erkläre ich in einem späteren Artikel. Zeilen und Spalten bilden ein Arbeitsblatt. Der Schnittpunkt zwischen einer Zeile und einer Spalte wird als Zelle bezeichnet, und mit dieser Zelle werden Sie in Excel interagieren.

Erstellen einer Excel-Datei mit Epplus Software AB

Mit EPPlus können Sie Excel-Dateien erstellen und Operationen wie die Erstellung von Pivot-Tabellen, Pivot-Bereichen und sogar bedingte Formatierungen und das Ändern von Schriftarten durchführen. Hier ist der gesamte Quellcode, um eine normale DataTable in eine XLSX-Excel-Datei zu konvertieren und diese an den Benutzer zum Download zu senden:

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 cols 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 colum names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows to 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 cols 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 colum names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows to 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 cols 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 colum 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 to 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, handelt es sich um eine ActionResult-Methode, die auf jedem ASP.NET MVC-Controller verwendet werden kann; wenn Sie nicht mit ASP.NET MVC arbeiten, kopieren Sie einfach den Inhalt der Methode und fügen Sie ihn dort ein, wo Sie ihn benötigen (klassisches ASP.NET, Konsolenanwendung, Windows Forms und so weiter).

Der Code ist selbsterklärend, mit genügend Kommentaren, um die verschiedenen Verarbeitungsprozesse zu verstehen. Doch zunächst eine kurze Zusammenfassung dessen, was wir hier tun:

• Mit einer benutzerdefinierten Data Provider-Methode erhalten wir ein DataTable-Objekt.
• Wir erstellen ein ExcelPackage-Objekt, das der primäre Container von EPPlus für die XLSX-Datei ist.
• Wir fügen dem ExcelPackage ein ExcelWorksheet 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 sie zeilenweise zu unserem Arbeitsblatt hinzu (beginnend mit Zeile 2) so dass jede DataTable-Zeile einer Arbeitsblattzeile entspricht.
• Wir erstellen einen MemoryStream, um die ExcelPackage-Binärdaten 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 einer Content-Disposition-Anlage an den Benutzer, so dass der Browser die Datei automatisch herunterlädt.

  IronXL gewinnt in diesem Fall, weil der Erstellungsprozess sehr einfach ist - Sie brauchen nur eine Zeile Code und schon sind Sie dabei; dies hilft, Zeit zu sparen und bei der Fehlersuche, während EPPlus Zeilen von Code bietet, die langweilig zu gehen und schwierig zu debuggen sind.

Wie EPPlus Software AB Excel-Dateien schreibt

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

• Lesen von Excel-Dateien

  Dazu müssen Sie zunächst das Paket EPPlus installieren: Gehen Sie zu "Tools"-> "NuGet package manager"-> "Manage NuGet for this solution" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EP Suchen Sie auf der Registerkarte "Browse" nach "EPPlus" und installieren Sie dann das NuGet-Paket.

  

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

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 ein Beispiel für die Ausgabe einer Konsolenanwendung mit einer Beispiel-Excel-Datei (.xlsx) mit denen wir arbeiten. Hier ist eine xlsx-Datei zum Lesen in C# mit EPPlus.

Die folgenden Möglichkeiten zum Laden von Daten aus mehreren Quellen können über die Eigenschaft "Zellen" aufgerufen werden (ExcelRange):

• Lesen einer CSV-Textdatei und Laden der Daten in einen Bereich auf einem Arbeitsblatt mit LoadFromText und LoadFromTextAsync.
• LoadFromDataReaderAsync und LoadFromDataReader - lädt Datenfelder aus einem DataReader in einen Bereich.
• LoadFromDataTable - lädt Daten aus einer DataTable in einen Bereich. Es kann Daten aus einer Vielzahl von Quellen importieren, einschließlich XML (ein Beispiel wird mitgeliefert) und Datenbanken.
• LoadFromCollection - lädt reflexiv Daten aus einer IEnumerable in einen Bereich.
• LoadFromCollection mit Attributen - lädt reflexiv Daten aus einer IEnumerable in einen Bereich oder eine Tabelle. Stile, Zahlenformate, Formeln und andere Eigenschaften werden über Attribute festgelegt.
• LoadFromDictionaries - lädt Daten aus einer IEnumerable von ExpandoObject/dynamischen Objekten (über ihre IDictionarystring, object>-Schnittstelle) in einen Bereich. Dies ist nützlich für den Import von JSON-Daten, und es ist ein Beispiel enthalten.

• LoadFromArrays - lädt Daten aus einer IEnumerable von Objekt [] in einen Bereich, wobei jedes Objektfeld einer Zeile im Arbeitsblatt entspricht.

  Wenn Sie diese Methoden verwenden, können Sie optional einen Parameter angeben, um eine Excel-Tabelle zu erstellen. Die Beispiele 4 und 5 des Beispielprojekts Sample-.NET-Framework bzw. Sample-.NET-Framework enthalten umfangreichere Beispiele.

• Schreiben von Excel-Dateien

  Als nächstes wollen wir sehen, ob wir die 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 wichtigsten Informationen zu erstellen, müssen wir die ExcelPackage-Klasse verwenden. Das Schreiben von Daten in eine Datei und das Erstellen eines neuen Excel-Tabellenblatts erfordert nur wenige Codezeilen. Bitte beachten Sie die folgende Zeile, die das Laden von DataTables in ein Excel-Blatt ermöglicht.

Der Einfachheit halber erstelle ich eine neue Tabellenkalkulationsdatei im gleichen Projektordner (die Excel-Datei wird im Ordner "bin" des Projekts erstellt). Der Quellcode ist weiter unten zu finden:

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 mit der oben genannten benutzerdefinierten Objekttransformation in die entsprechenden Excel-Spalten und -Zeilen erstellt, um den unten stehenden Wert anzuzeigen.

Die obige gebrauchsfertige API kann in der .NET Core-Konsole, einem Testprojekt oder einer ASP.NET Core-Anwendung verwendet werden, und die Logik kann entsprechend Ihren Anforderungen geändert werden.

Auf diese Techniken kann über die Eigenschaft "Zellen" zugegriffen werden (ExcelRange):

• 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.Data. DataTable
• GetValueT> - zeigt einen Wert mit der Option eines Datentyps an.

• Wert - gibt den Wert des Bereichs zurück oder legt ihn fest.

  Die Methoden GetValue und SetValue können auch direkt auf das Arbeitsblattobjekt angewendet werden. (Damit werden etwas bessere Ergebnisse erzielt als beim Lesen/Schreiben auf dem Schießstand):

• GetValueT> - ruft den Wert einer einzelnen Zelle ab, mit der Möglichkeit, einen Datentyp anzugeben.

• SetValue - ändert den Wert einer einzelnen Zelle.

  Linq kann zur Abfrage von Daten aus einem Arbeitsblatt verwendet werden, da die Zelleigenschaft die Schnittstelle IEnumerable 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 besonderen 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 muss geladen werden

  Ein Excel-Blatt wird durch die Klasse WorkBook 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
anchor-load-a-workbook
**/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

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

'''
'''Load WorkBook
'''anchor-load-a-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 zu finden. GetWorkSheet.

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

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

Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

• **Erstellen Sie Ihr eigenes Arbeitsbuch

  Konstruieren Sie ein neues WorkBook mit dem Blatttyp, um ein neues WorkBook im Speicher zu erzeugen.

/**
Create WorkBook
anchor-create-a-workbook
**/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

/**
Create WorkBook
anchor-create-a-workbook
**/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

'''
'''Create WorkBook
'''anchor-create-a-workbook
'''*
Dim workbook As New WorkBook(ExcelFileFormat.XLSX)

Für alte Microsoft Excel-Tabellenblätter verwenden Sie ExcelFileFormat.XLS (95 und früher).

**Erstellen Sie ein Arbeitsblatt, wenn Sie noch keins haben

In jedem "WorkBook" kann es zahlreiche WorkSheets geben Ein "WorkSheet" ist ein einzelnes Datenblatt, während ein "WorkBook" eine Sammlung von WorkSheets ist. In Excel sieht eine Arbeitsmappe mit zwei Arbeitsblättern folgendermaßen aus.

Das WorkBook ist der Name eines neuen WorkSheets, 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.

Erreichen der Zellreichweite

Eine zweidimensionale Sammlung von "Cell"-Objekten wird durch die "Range"-Klasse dargestellt. Sie kennzeichnet einen bestimmten Bereich von Excel-Zellen. Mit dem String-Indexer auf einem WorkSheet-Objekt können Sie Bereiche abrufen.

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

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

Dim range = worksheet ("D2:D101")

Das Argument text kann die Koordinate einer Zelle sein (zum Beispiel "A1") oder ein Bereich von Zellen von links nach rechts, von oben nach unten (z.B. "B2:E5"). GetRange kann auch von einem WorkSheet aus aufgerufen werden.

• Innerhalb eines Bereichs, Zellwerte 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 von hier aus auch die Zellengestaltung vornehmen.

/**
Edit Cell Values in Range
anchor-edit-cell-values-within-a-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
anchor-edit-cell-values-within-a-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
'''anchor-edit-cell-values-within-a-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

Validierung von Daten in Tabellenkalkulationen

Verwenden Sie IronXL, um ein Blatt mit Daten zu validieren. Das DataValidation-Beispiel validiert Telefonnummern mit libphonenumber-CSharp und E-Mail-Adressen und Daten mit herkömmlichen C#-APIs.

/**
Validate Spreadsheet Data
anchor-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
anchor-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
'''anchor-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 der Kalkulationstabelle und erfasst die Zellen als Liste. Jede validierte Methode überprüft den Wert einer Zelle und gibt einen Fehler zurück, wenn der Wert falsch ist.

Dieser Code erstellt ein neues Blatt, gibt Kopfzeilen an und erzeugt die Ergebnisse der Fehlermeldung, so dass ein fehlerhaftes Datenprotokoll 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")

Verwendung von Entity Framework zum Exportieren von Daten

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

Es erstellt die Datenbank mit EntityFramework und exportiert dann die Daten Zeile für Zeile.

Die SQLite Entity Framework NuGet-Pakete sollten installiert werden.

Sie können EntityFramework verwenden, um ein Modellobjekt zu konstruieren, 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 ().

/**
Export Data using Entity Framework
anchor-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
anchor-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
'''anchor-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 einen CountryContext, durchlaufen Sie dann den Bereich, um jeden Eintrag zu erstellen, bevor Sie die Daten mit SaveAsync in der 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

Einfügen einer Formel in eine Tabellenkalkulation

Mit der Eigenschaft Formel können Sie die Formel einer Zelle festlegen.

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

Daten aus einer API können in eine Tabellenkalkulation heruntergeladen werden

RestClient.Net wird im folgenden Aufruf verwendet, um einen REST-Aufruf zu tätigen. Es lädt JSON herunter und wandelt es in eine RestCountry-artige "Liste" um Die Daten aus der REST-API können dann einfach in einer Excel-Datei gespeichert werden, indem die einzelnen Länder durchlaufen werden.

/**
Data API to Spreadsheet
anchor-download-data-from-an-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
anchor-download-data-from-an-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
'''anchor-download-data-from-an-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 wie folgt aus:

Der folgende Code durchläuft die Länder in einer Schleife und füllt das Arbeitsblatt mit Name, Bevölkerung, Region, NumericCode und den 3 wichtigsten 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

Nach dem Starten der Excel-Datei fügen Sie die ersten Zeilen hinzu, die die erste Zelle im ersten Blatt lesen, und drucken Sie sie aus.

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

Erstellen Sie mit IronXL eine neue Excel-Datei.

/**
Create Excel File
anchor-create-a-new-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
anchor-create-a-new-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
'''anchor-create-a-new-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 die Daten entweder in CSV, JSON oder XML speichern, indem Sie die entsprechenden Codes verwenden.

Beispiel: Speichern in XML ".xml"

Zum Speichern in XML 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 wie folgt 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 verfügt über kürzere Codes, die alles umfassen, was für den Zugriff auf alle Spalten, Zeilen und Zellen in einer Arbeitsmappe erforderlich ist, während Sie bei EPPlus eine bestimmte Codezeile benötigen, um Spalten und Zeilen zu lesen.

IronXL ist intelligenter, wenn es um die Bearbeitung von Excel-Dokumenten geht. Mit IronXL haben Sie die Möglichkeit, jederzeit weitere Blätter zu erstellen und Daten aus mehreren Arbeitsblättern und Arbeitsmappen zu lesen, während EPPlus jeweils nur ein Arbeitsblatt bearbeitet. Mit IronXL können Sie auch eine Datenbank mit den Daten in Ihrer Excel-Arbeitsmappe füllen.

EPPlus- und IronXL-Lizenzierung und Preisgestaltung

EPPlus Lizenzmodell und Preis

EPPlus kann im Rahmen von zwei Lizenzmodellen genutzt werden, entweder im Rahmen eines nicht-kommerziellen Lizenzmodells oder eines kommerziellen Lizenzmodells von Polyform.

Gewerbliche Lizenzen

Diese sind sowohl als unbefristete als auch als Abonnements mit Laufzeiten von einem Monat bis zu zwei Jahren erhältlich.

Für alle Lizenzkategorien sind der Support über das Support Center und Upgrades über NuGet während der Lizenzdauer inbegriffen.

EPPlus erfordert eine Lizenz pro Entwickler. Lizenzen werden auf eine einzelne Person ausgestellt und können nicht geteilt werden. Als allgemeine Richtlinie gilt, dass jeder, der Code produziert oder debuggen muss, der EPPlus direkt verwendet, eine kommerzielle Lizenz haben sollte.

Wenn Sie EPPlus intern als Dienstleistung anbieten (zum Beispiel, indem sie ihre Fähigkeiten über eine API offenlegt)muss Ihr Unternehmen ein Abonnement erwerben, das die Anzahl der internen Nutzer abdeckt (entwickler) die den Dienst nutzen werden.

Abonnements

Mit einem Abonnement können Sie immer die neueste Version verwenden, aber Sie müssen eine gültige Lizenz haben, solange Sie EPPlus für die Entwicklung verwenden. Am Ende des Lizenzzeitraums wird die Lizenz automatisch in Rechnung gestellt und verlängert, sobald die Zahlung erfolgt ist. Sie können Ihr Abonnement zum Ende des Lizenzzeitraums kündigen und ein neues beginnen, wann immer Sie wollen. Abonnements können nur über das Internet erworben werden.

EPPlus kann in einem kommerziellen Umfeld eingesetzt werden. Die Lizenz gilt für einen Entwickler pro Unternehmen, mit einer unbegrenzten Anzahl von Einsatzorten. Die Anzahl der Lizenzen, die jedes Jahr erworben werden können, kann erhöht oder verringert werden, und die Lizenz kann am Ende eines jeden Jahres ausgesetzt oder gekündigt werden.

Eine 32-tägige Testphase ist optional erhältlich.

Preise: Beginnt bei 299 $ pro Jahr.

Sie können bezahlen, wie Sie wollen

Preis pro Entwickler innerhalb einer Organisation, mit unbegrenzten Einsatzorten und Stripe-Rechnungsstellung. Die Anzahl der monatlich verfügbaren Lizenzen kann erhöht oder gesenkt werden, und die Lizenz kann zum Ende eines jeden Monats ausgesetzt oder gekündigt werden.

Preise: Beginnt bei $29 pro Monat.

Unbefristete Lizenz

Eine unbefristete Lizenz ermöglicht es Ihnen, für einen bestimmten Zeitraum auf neue Versionen zu aktualisieren und Support zu erhalten. Sie können dann weiterhin Software mit den in dieser Zeit veröffentlichten Versionen entwickeln, ohne Ihre Lizenz erneuern zu müssen.

Innerhalb desselben Unternehmens, Preis pro Entwickler mit unbegrenzten Einsatzorten. Nutzung aller EPPlus-Versionen, die im Rahmen des Supports/Upgrades veröffentlicht werden, auf unbestimmte Zeit.

Eine 32-tägige Testphase ist optional erhältlich.

Preisgestaltung: Ab 599 $ pro Jahr.

Pakete

Es sind unbefristete Lizenzoptionen mit einer anfänglichen Dauer für Upgrades und Support erhältlich. Sie können dann weiterhin Software mit den in diesem Zeitraum veröffentlichten Versionen entwickeln, ohne Ihre Lizenz erneuern zu müssen.

Preise: Beginnt bei 4295 $ pro Jahr.

Nichtkommerzielle Lizenz für Polyform

EPPlus ist ab Version 5 unter der Polyform Noncommercial-Lizenz lizenziert, die besagt, dass der Code quelloffen ist und für nicht-kommerzielle Zwecke verwendet werden kann. Weitere Einzelheiten finden Sie auf ihrer Website.

IronXL Lizenzmodell und Preis

Dauerlizenzierung: Jede Lizenz wird einmal erworben und muss nicht erneuert werden.

Kostenloser Support und Produkt-Updates: Jede Lizenz beinhaltet ein Jahr lang kostenlose Produkt-Updates und Support durch das Team, das das Produkt entwickelt hat. Es ist jederzeit möglich, Erweiterungen zu erwerben. Erweiterungen können eingesehen werden.

Sofortige Lizenzen: Registrierte Lizenzschlüssel werden sofort nach Zahlungseingang verschickt.

Bei Fragen zur Lizenzierung von IronXL for .NET wenden Sie sich bitte an unsere Lizenzierungsspezialisten von Iron Software.

Alle Lizenzen sind unbefristet und gelten für Entwicklung, Staging und Produktion.

Lite - Ermöglicht es einem einzelnen Softwareentwickler in einem Unternehmen, die Iron Software an einem einzigen Ort zu nutzen. Iron Software kann in einer einzelnen Webanwendung, einer Intranetanwendung oder einem Desktop-Softwareprogramm verwendet werden. Lizenzen sind nicht übertragbar und können nicht außerhalb einer Organisation oder einer Agentur-/Kundenbeziehung weitergegeben werden. Dieser Lizenztyp, wie auch alle anderen Lizenztypen, schließt ausdrücklich alle Rechte aus, die nicht ausdrücklich im Rahmen der Vereinbarung gewährt werden, einschließlich der OEM-Weitergabe und der Nutzung der Iron Software als SaaS ohne Erwerb einer zusätzlichen Abdeckung.

Preisgestaltung: Ab 489 $ pro Jahr.

Professional License - Erlaubt einer bestimmten Anzahl von Softwareentwicklern in einem Unternehmen die Nutzung von Iron Software an einem einzigen Standort, maximal jedoch zehn. Die Iron Software kann in beliebig vielen Websites, Intranetanwendungen oder Desktop-Softwareanwendungen verwendet werden. Die Lizenzen sind nicht übertragbar und können nicht außerhalb einer Organisation oder einer Agentur-/Kundenbeziehung weitergegeben werden. Dieser Lizenztyp schließt, wie alle anderen Lizenztypen, ausdrücklich alle Rechte aus, die nicht ausdrücklich im Rahmen der Vereinbarung gewährt werden, einschließlich der OEM-Weitergabe und der Nutzung der Iron Software als SaaS ohne den Erwerb einer zusätzlichen Abdeckung.

Preise: Beginnt bei 976 $ pro Jahr.

Unbegrenzte Lizenz - Erlaubt einer unbegrenzten Anzahl von Software-Entwicklern in einem Unternehmen, Iron Software an einer unbegrenzten Anzahl von Standorten zu nutzen. Die Iron Software kann in beliebig vielen Websites, Intranetanwendungen oder Desktop-Softwareanwendungen verwendet werden. Die Lizenzen sind nicht übertragbar und können nicht außerhalb einer Organisation oder einer Agentur-/Kundenbeziehung weitergegeben werden. Dieser Lizenztyp schließt, wie alle anderen Lizenztypen, ausdrücklich alle Rechte aus, die nicht ausdrücklich im Rahmen der Vereinbarung gewährt werden, einschließlich der OEM-Weitergabe und der Nutzung der Iron Software als SaaS ohne den Erwerb einer zusätzlichen Abdeckung.

Lizenzfreier Weitervertrieb - Erlaubt Ihnen, die Iron Software als Teil einer Reihe von verschiedenen kommerziellen Produkten zu vertreiben (ohne Lizenzgebühren zahlen zu müssen) basierend auf der Anzahl der Projekte, die von der Basislizenz abgedeckt werden. Ermöglicht die Bereitstellung von Iron Software im Rahmen von SaaS-Software-Services, basierend auf der Anzahl der von der Basislizenz abgedeckten Projekte.

Preise: Beginnt bei 2939 $ pro Jahr.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass IronXL praktischer ist als EPPlus, weil es Ihnen die Flexibilität bietet, nach Belieben in der Excel-Tabelle 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 Arbeitsmappendaten in eine Datenbank zu integrieren. Außerdem verfügt es über ein intuitives System, das Formeln bei jeder Bearbeitung des Dokuments neu berechnet, und es bietet eine Einstellung für intuitive Bereiche mit einem WorkSheet ["A1:B10"] syntax. Die Blattfunktionen enthalten Formeln, die mit Excel arbeiten und bei jeder Bearbeitung eines Blattes neu berechnet werden. Die Zelldatenformate enthalten mehrere Texte, Zahlen, Formeln, Daten, Währungen, Prozentsätze, wissenschaftliche Notation und Zeit. Ihre benutzerdefinierten Formate haben verschiedene Sortiermethoden wie Bereiche, Spalten und Zeilen. Die Zellengestaltung umfasst eine Vielzahl von Schriftarten, Größen, Hintergrundmustern, Rahmen und Ausrichtungen.