1. IronXL
2. Anleitungen
3. Excel-Dateien in C# erstellen

C# Excel-Datei erstellen Tutorial

von Jonas Schmidt

Dieses Tutorial zeigt Ihnen Schritt für Schritt, wie Sie eine Excel-Arbeitsmappe auf jeder Plattform erstellen können, die .NET-Framework 4.5 oder .NET Core unterstützt. Die Erstellung von Excel-Dateien in C# kann einfach sein, auch ohne Abhängigkeit von der Legacy-Bibliothek Microsoft.Office.Interop.Excel. Mit IronXL können Sie Arbeitsblatteigenschaften wie das Einfrieren von Fenstern und den Schutz einstellen, Druckeigenschaften festlegen und vieles mehr.

Übersicht

IronXL erstellt C# Excel-Dateien in .NET

IronXL ist eine intuitive C# & VB Excel API das Ihnen das Lesen, Bearbeiten und Erstellen von Excel-Tabellendateien in .NET mit blitzschneller Leistung ermöglicht. Es ist nicht erforderlich, MS Office oder gar Excel Interop zu installieren.

IronXL unterstützt vollständig .NET Core, .NET-Framework, Xamarin, Mobile, Linux, macOS und Azure.

IronXL Merkmale:

• Menschliche Unterstützung direkt von unserem .NET-Entwicklungsteam
• Schnelle Installation mit Microsoft Visual Studio
• KOSTENLOS für die Entwicklung. Lizenzen von $749.

  Erstellen und Speichern einer Excel-Datei: Quick Code

https://www.nuget.org/packages/IronXL.Excel/ Als Alternative kann die IronXL.dll kann heruntergeladen werden und zu Ihrem Projekt hinzugefügt.

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-1.cs

using IronXL;

// Default file format is XLSX, we can override it using CreatingOptions
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
var workSheet = workBook.CreateWorkSheet("example_sheet");
workSheet["A1"].Value = "Example";

// Set value to multiple cells
workSheet["A2:A4"].Value = 5;
workSheet["A5"].Style.SetBackgroundColor("#f0f0f0");

// Set style to multiple cells
workSheet["A5:A6"].Style.Font.Bold = true;

// Set formula
workSheet["A6"].Value = "=SUM(A2:A4)";
if (workSheet["A6"].IntValue == workSheet["A2:A4"].IntValue)
{
    Console.WriteLine("Basic test passed");
}
workBook.SaveAs("example_workbook.xlsx");

Imports IronXL

' Default file format is XLSX, we can override it using CreatingOptions
Private workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Private workSheet = workBook.CreateWorkSheet("example_sheet")
Private workSheet("A1").Value = "Example"

' Set value to multiple cells
Private workSheet("A2:A4").Value = 5
workSheet("A5").Style.SetBackgroundColor("#f0f0f0")

' Set style to multiple cells
workSheet("A5:A6").Style.Font.Bold = True

' Set formula
workSheet("A6").Value = "=SUM(A2:A4)"
If workSheet("A6").IntValue = workSheet("A2:A4").IntValue Then
	Console.WriteLine("Basic test passed")
End If
workBook.SaveAs("example_workbook.xlsx")

Schritt 1

1. Laden Sie die kostenlose IronXL C# Bibliothek herunter

Beginnen Sie noch heute mit der Verwendung von IronXL in Ihrem Projekt mit einer kostenlosen Testversion.

Erster Schritt:

Kostenloser Start

Installation mit NuGet

Es gibt drei verschiedene Möglichkeiten, das IronXL NuGet-Paket zu installieren:

1. Visual Studio

2. Entwickler-Eingabeaufforderung

3. Laden Sie das NuGet-Paket direkt herunter

   Visual Studio

   Visual Studio stellt Ihnen den NuGet Package Manager zur Verfügung, mit dem Sie NuGet-Pakete in Ihren Projekten installieren können. Sie können über das Projektmenü darauf zugreifen, oder indem Sie mit der rechten Maustaste auf Ihr Projekt im Projektmappen-Explorer klicken. Diese beiden Optionen sind in den Abbildungen 3 und 4 dargestellt.

   

   Abbildung 3 - Menü Projekt

Abbildung 4 - Rechtsklick auf Solution Explorer

Nachdem Sie in einer der beiden Optionen auf NuGet-Pakete verwalten geklickt haben, suchen Sie nach dem IronXL.Excel-Paket und installieren es wie in Abbildung 5 dargestellt.

Abbildung 5 - IronXL.Excel NuGet-Paket installieren

Entwickler-Eingabeaufforderung

Öffnen Sie die Eingabeaufforderung für Entwickler, und führen Sie die folgenden Schritte aus, um das IronXL.Excel-NuGet-Paket zu installieren:

1. Suchen Sie nach der Eingabeaufforderung für Entwickler - sie befindet sich in der Regel in Ihrem Visual Studio-Ordner

2. Geben Sie den folgenden Befehl ein:

3. PM > Installieren-Paket IronXL.Excel

4. Eingabe drücken

5. Das Paket wird installiert.

6. Laden Sie Ihr Visual Studio-Projekt neu

   Laden Sie das NuGet-Paket direkt herunter

   Um das NuGet-Paket herunterzuladen, führen Sie die folgenden Schritte aus:

7. Rufen Sie die folgende URL auf: https://www.nuget.org/packages/ironxl.excel/

8. Klicken Sie auf Paket herunterladen

9. Nachdem das Paket heruntergeladen wurde, doppelklicken Sie es

10. Laden Sie Ihr Visual Studio-Projekt neu

    Installieren Sie IronXL durch direkten Download der Bibliothek

    Die zweite Möglichkeit, IronXL zu installieren, besteht darin, es direkt von der folgenden URL herunterzuladen: https://ironsoftware.com/csharp/excel/

    

    Abbildung 6 - IronXL-Bibliothek herunterladen

    Verweisen Sie auf die Bibliothek in Ihrem Projekt, indem Sie die folgenden Schritte ausführen:

11. Klicken Sie mit der rechten Maustaste auf die Lösung im Projektmappen-Explorer

12. Referenzen auswählen

13. Suchen Sie nach der IronXL.dll-Bibliothek

14. OK anklicken

    Los geht's!

    Nun, da Sie eingerichtet sind, können wir mit den großartigen Funktionen der IronXL-Bibliothek spielen!

    ---

Anleitungen Tutorials

2. Ein ASP.NET-Projekt erstellen

• Rufen Sie die folgende URL auf:
• https://www.nuget.org/packages/ironxl.excel/
• Klicken Sie auf Paket herunterladen
• Nachdem das Paket heruntergeladen wurde, doppelklicken Sie es
• Laden Sie Ihr Visual Studio-Projekt neu

Führen Sie die folgenden Schritte aus, um eine ASP.NET-Website zu erstellen

1. Visual Studio öffnen

2. Klicken Sie auf Datei > Neues Projekt

3. Wählen Sie Web unter Visual C#; im Listenfeld Projekttyp

4. Wählen Sie ASP.NET Web Application, wie nachfolgend gezeigt
   

   

   Abbildung 1 - Neues Projekt

5. OK anklicken

6. Wählen Sie auf dem nächsten Bildschirm Webformulare aus, wie in Abbildung 2 unten dargestellt
   

Abbildung 2 - Webformulare

7. OK anklicken

   Jetzt haben wir etwas, womit wir arbeiten können. Installieren Sie IronXL, um mit der Anpassung Ihrer Datei zu beginnen.

   ---

3. Eine Excel-Arbeitsmappe erstellen

Einfacher kann es nicht sein, eine neue Excel-Arbeitsmappe mit IronXL zu erstellen! Es ist eine Zeile Code! Ja, wirklich:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-2.cs

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

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

Beide XLS(ältere Excel-Datei-Version) und XLSX(aktuelle und neuere Dateiversion) dateiformate können mit IronXL erstellt werden.

3.1. Ein Standard-Arbeitsblatt festlegen

Und noch einfacher ist es, ein Standard-Arbeitsblatt zu erstellen:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-3.cs

WorkSheet workSheet = workBook.CreateWorkSheet("2020 Budget");

Dim workSheet As WorkSheet = workBook.CreateWorkSheet("2020 Budget")

"Sheet" im obigen Codeschnipsel steht für das Arbeitsblatt, und Sie können damit Zellwerte festlegen und fast alles tun, was Excel kann.

Falls Sie sich über den Unterschied zwischen einer Arbeitsmappe und einem Arbeitsblatt nicht im Klaren sind, lassen Sie mich das erklären:

Ein Workbook enthält Arbeitsblätter. Das bedeutet, dass Sie beliebig viele Arbeitsblätter in eine Arbeitsmappe einfügen können. In einem späteren Artikel werde ich erklären, wie das geht. Ein Arbeitsblatt enthält Zeilen und Spalten. Der Schnittpunkt zwischen einer Zeile und einer Spalte wird als Zelle bezeichnet, die Sie bei der Arbeit mit Excel bearbeiten werden.

4. Zellenwerte setzen

4.1. Zellenwerte manuell einstellen

Zum manuellen Festlegen von Zellwerten geben Sie einfach an, mit welcher Zelle Sie arbeiten, und legen deren Wert fest, wie im folgenden Beispiel:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-4.cs

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

workSheet("A1").Value = "January"
workSheet("B1").Value = "February"
workSheet("C1").Value = "March"
workSheet("D1").Value = "April"
workSheet("E1").Value = "May"
workSheet("F1").Value = "June"
workSheet("G1").Value = "July"
workSheet("H1").Value = "August"
workSheet("I1").Value = "September"
workSheet("J1").Value = "October"
workSheet("K1").Value = "November"
workSheet("L1").Value = "December"

Hier habe ich die Spalten A bis L und die erste Zeile jeder Spalte mit dem Namen eines anderen Monats gefüllt.

4.2. Zellenwerte dynamisch einstellen

Das dynamische Setzen von Werten ist dem vorherigen Codesegment sehr ähnlich. Das Schöne daran ist, dass Sie den Standort der Zelle nicht hart kodieren müssen. Im nächsten Codebeispiel werden Sie ein neues Random-Objekt erstellen, um Zufallszahlen zu erzeugen, und dann eine for-Schleife verwenden, um den Bereich der Zellen zu durchlaufen, die Sie mit Werten füllen möchten.

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-5.cs

Random r = new Random();
for (int i = 2 ; i <= 11 ; i++)
{
    workSheet["A" + i].Value = r.Next(1, 1000);
    workSheet["B" + i].Value = r.Next(1000, 2000);
    workSheet["C" + i].Value = r.Next(2000, 3000);
    workSheet["D" + i].Value = r.Next(3000, 4000);
    workSheet["E" + i].Value = r.Next(4000, 5000);
    workSheet["F" + i].Value = r.Next(5000, 6000);
    workSheet["G" + i].Value = r.Next(6000, 7000);
    workSheet["H" + i].Value = r.Next(7000, 8000);
    workSheet["I" + i].Value = r.Next(8000, 9000);
    workSheet["J" + i].Value = r.Next(9000, 10000);
    workSheet["K" + i].Value = r.Next(10000, 11000);
    workSheet["L" + i].Value = r.Next(11000, 12000);
}

Dim r As New Random()
For i As Integer = 2 To 11
	workSheet("A" & i).Value = r.Next(1, 1000)
	workSheet("B" & i).Value = r.Next(1000, 2000)
	workSheet("C" & i).Value = r.Next(2000, 3000)
	workSheet("D" & i).Value = r.Next(3000, 4000)
	workSheet("E" & i).Value = r.Next(4000, 5000)
	workSheet("F" & i).Value = r.Next(5000, 6000)
	workSheet("G" & i).Value = r.Next(6000, 7000)
	workSheet("H" & i).Value = r.Next(7000, 8000)
	workSheet("I" & i).Value = r.Next(8000, 9000)
	workSheet("J" & i).Value = r.Next(9000, 10000)
	workSheet("K" & i).Value = r.Next(10000, 11000)
	workSheet("L" & i).Value = r.Next(11000, 12000)
Next i

Jede Zelle von A2 bis L11 enthält einen eindeutigen Wert, der nach dem Zufallsprinzip erzeugt wurde.

Apropos dynamische Werte: Wie wäre es, wenn Sie lernen, wie man Daten direkt aus einer Datenbank dynamisch in Zellen einfügt? Das nächste Codeschnipsel zeigt, wie das geht, vorausgesetzt, Sie haben Ihre Datenbankverbindungen korrekt eingerichtet.

4.3. Direktes Hinzufügen aus einer Datenbank

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-6.cs

// Create database objects to populate data from database
string contring;
string sql;
DataSet ds = new DataSet("DataSetName");
SqlConnection con;
SqlDataAdapter da;

// Set Database Connection string
contring = @"Data Source=Server_Name;Initial Catalog=Database_Name;User ID=User_ID;Password=Password";

// SQL Query to obtain data
sql = "SELECT Field_Names FROM Table_Name";

// Open Connection & Fill DataSet
con = new SqlConnection(contring);
da = new SqlDataAdapter(sql, con);
con.Open();
da.Fill(ds);

// Loop through contents of dataset
foreach (DataTable table in ds.Tables)
{
    int Count = table.Rows.Count - 1;
    for (int j = 12; j <= 21; j++)
    {
        workSheet["A" + j].Value = table.Rows[Count]["Field_Name_1"].ToString();
        workSheet["B" + j].Value = table.Rows[Count]["Field_Name_2"].ToString();
        workSheet["C" + j].Value = table.Rows[Count]["Field_Name_3"].ToString();
        workSheet["D" + j].Value = table.Rows[Count]["Field_Name_4"].ToString();
        workSheet["E" + j].Value = table.Rows[Count]["Field_Name_5"].ToString();
        workSheet["F" + j].Value = table.Rows[Count]["Field_Name_6"].ToString();
        workSheet["G" + j].Value = table.Rows[Count]["Field_Name_7"].ToString();
        workSheet["H" + j].Value = table.Rows[Count]["Field_Name_8"].ToString();
        workSheet["I" + j].Value = table.Rows[Count]["Field_Name_9"].ToString();
        workSheet["J" + j].Value = table.Rows[Count]["Field_Name_10"].ToString();
        workSheet["K" + j].Value = table.Rows[Count]["Field_Name_11"].ToString();
        workSheet["L" + j].Value = table.Rows[Count]["Field_Name_12"].ToString();
    }
    Count++;
}

' Create database objects to populate data from database
Dim contring As String
Dim sql As String
Dim ds As New DataSet("DataSetName")
Dim con As SqlConnection
Dim da As SqlDataAdapter

' Set Database Connection string
contring = "Data Source=Server_Name;Initial Catalog=Database_Name;User ID=User_ID;Password=Password"

' SQL Query to obtain data
sql = "SELECT Field_Names FROM Table_Name"

' Open Connection & Fill DataSet
con = New SqlConnection(contring)
da = New SqlDataAdapter(sql, con)
con.Open()
da.Fill(ds)

' Loop through contents of dataset
For Each table As DataTable In ds.Tables
	Dim Count As Integer = table.Rows.Count - 1
	For j As Integer = 12 To 21
		workSheet("A" & j).Value = table.Rows(Count)("Field_Name_1").ToString()
		workSheet("B" & j).Value = table.Rows(Count)("Field_Name_2").ToString()
		workSheet("C" & j).Value = table.Rows(Count)("Field_Name_3").ToString()
		workSheet("D" & j).Value = table.Rows(Count)("Field_Name_4").ToString()
		workSheet("E" & j).Value = table.Rows(Count)("Field_Name_5").ToString()
		workSheet("F" & j).Value = table.Rows(Count)("Field_Name_6").ToString()
		workSheet("G" & j).Value = table.Rows(Count)("Field_Name_7").ToString()
		workSheet("H" & j).Value = table.Rows(Count)("Field_Name_8").ToString()
		workSheet("I" & j).Value = table.Rows(Count)("Field_Name_9").ToString()
		workSheet("J" & j).Value = table.Rows(Count)("Field_Name_10").ToString()
		workSheet("K" & j).Value = table.Rows(Count)("Field_Name_11").ToString()
		workSheet("L" & j).Value = table.Rows(Count)("Field_Name_12").ToString()
	Next j
	Count += 1
Next table

Sie müssen lediglich die Eigenschaft Wert der betreffenden Zelle auf den Feldnamen setzen, der in die Zelle eingegeben werden soll.

5. Formatierung anwenden

5.1. Hintergrundfarben der Zellen einstellen

Um die Hintergrundfarbe einer Zelle oder eines Bereichs von Zellen festzulegen, benötigen Sie lediglich eine Codezeile, die wie folgt aussieht:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-7.cs

workSheet["A1:L1"].Style.SetBackgroundColor("#d3d3d3");

workSheet("A1:L1").Style.SetBackgroundColor("#d3d3d3")

Dadurch wird die Hintergrundfarbe des Zellenbereichs auf grau gesetzt. Die Farbe ist in RGB(Rot, Grün, Blau) format, wobei die ersten beiden Zeichen für Rot, die nächsten beiden für Grün und die letzten beiden für Blau stehen. Die Werte reichen von 0 bis 9, dann A bis F(Hexidezimal).

5.2. Ränder erstellen

Das Erstellen von Rahmen mit IronXL ist sehr einfach, wie im Folgenden gezeigt wird:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-8.cs

workSheet["A1:L1"].Style.TopBorder.SetColor("#000000");
workSheet["A1:L1"].Style.BottomBorder.SetColor("#000000");
workSheet["L2:L11"].Style.RightBorder.SetColor("#000000");
workSheet["L2:L11"].Style.RightBorder.Type = IronXL.Styles.BorderType.Medium;
workSheet["A11:L11"].Style.BottomBorder.SetColor("#000000");
workSheet["A11:L11"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Medium;

workSheet("A1:L1").Style.TopBorder.SetColor("#000000")
workSheet("A1:L1").Style.BottomBorder.SetColor("#000000")
workSheet("L2:L11").Style.RightBorder.SetColor("#000000")
workSheet("L2:L11").Style.RightBorder.Type = IronXL.Styles.BorderType.Medium
workSheet("A11:L11").Style.BottomBorder.SetColor("#000000")
workSheet("A11:L11").Style.BottomBorder.Type = IronXL.Styles.BorderType.Medium

Im obigen Code habe ich schwarze obere und untere Ränder für die Zellen A1 bis L1 festgelegt, dann habe ich den rechten Rand für die Zellen L2 bis L11 festgelegt, und der Stil des Rahmens ist auf Medium festgelegt. Zum Schluss habe ich den unteren Rand für die Zellen A11 bis L11 festgelegt

6. Formeln in Zellen verwenden

Ich sage immer wieder, dass IronXL alles so einfach macht, aber es ist wirklich so, und ich kann es nicht genug hervorheben! Mit dem folgenden Code können Sie Formeln verwenden:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-9.cs

// Use IronXL built-in aggregations
decimal sum = workSheet["A2:A11"].Sum();
decimal avg = workSheet["B2:B11"].Avg();
decimal max = workSheet["C2:C11"].Max();
decimal min = workSheet["D2:D11"].Min();

// Assign value to cells
workSheet["A12"].Value = sum;
workSheet["B12"].Value = avg;
workSheet["C12"].Value = max;
workSheet["D12"].Value = min;

' Use IronXL built-in aggregations
Dim sum As Decimal = workSheet("A2:A11").Sum()
Dim avg As Decimal = workSheet("B2:B11").Avg()
Dim max As Decimal = workSheet("C2:C11").Max()
Dim min As Decimal = workSheet("D2:D11").Min()

' Assign value to cells
workSheet("A12").Value = sum
workSheet("B12").Value = avg
workSheet("C12").Value = max
workSheet("D12").Value = min

Das Schöne daran ist, dass Sie den Datentyp der Zelle und damit das Ergebnis der Formel festlegen können. Der obige Code zeigt, wie man die SUMME verwendet(summenwerte), AVG(durchschnittswerte), MAX(erhält den höchsten Wert) und MIN(erhält den niedrigsten Wert) formeln.

7. Arbeitsblatt- und Druckeigenschaften festlegen

7.1. Arbeitsblatteigenschaften einstellen

Zu den Arbeitsblatteigenschaften gehören das Einfrieren von Zeilen und Spalten und der Schutz des Arbeitsblatts mit einem Kennwort. Dies wird im Folgenden gezeigt:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-10.cs

workSheet.ProtectSheet("Password");
workSheet.CreateFreezePane(0, 1);

workSheet.ProtectSheet("Password")
workSheet.CreateFreezePane(0, 1)

Die erste Zeile ist eingefroren und lässt sich nicht mit dem Rest des Arbeitsblatts verschieben. Das Arbeitsblatt ist außerdem durch ein Kennwort vor Bearbeitungen geschützt. Die Abbildungen 7 und 8 zeigen dies in der Praxis.

Abbildung 7 - Scheiben einfrieren

Abbildung 8 - Geschütztes Arbeitsblatt

7.2. Seiten- und Druckeigenschaften einstellen

Sie können Seiteneigenschaften wie die Ausrichtung der Seite, die Größe der Seite und den Druckbereich festlegen, um nur einige zu nennen.

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-11.cs

workSheet.SetPrintArea("A1:L12");
workSheet.PrintSetup.PrintOrientation = IronXL.Printing.PrintOrientation.Landscape;
workSheet.PrintSetup.PaperSize = IronXL.Printing.PaperSize.A4;

workSheet.SetPrintArea("A1:L12")
workSheet.PrintSetup.PrintOrientation = IronXL.Printing.PrintOrientation.Landscape
workSheet.PrintSetup.PaperSize = IronXL.Printing.PaperSize.A4

Der Druckbereich wird auf A1 bis L12 eingestellt. Die Ausrichtung wird auf Querformat und das Papierformat auf A4 eingestellt

Abbildung 9 - Druckeinstellungen

8. Arbeitsmappe speichern

Um die Arbeitsmappe zu speichern, verwenden Sie den folgenden Code:

:path=/static-assets/excel/content-code-examples/tutorials/create-excel-file-net-12.cs

workBook.SaveAs("Budget.xlsx");

workBook.SaveAs("Budget.xlsx")

Tutorial Schnellzugriff

Dieses Tutorial als C# Quellcode herunterladen

Der vollständige kostenlose C# for Excel Source Code für dieses Tutorial steht als gezippte Visual Studio 2017 Projektdatei zum Download bereit.

Herunterladen

Erkunden Sie dieses Tutorial auf GitHub

Der Quellcode für dieses Projekt ist in C# und VB.NET auf GitHub verfügbar.

Verwenden Sie diesen Code als einfache Möglichkeit, um in nur wenigen Minuten loszulegen. Das Projekt wird als Microsoft Visual Studio 2017 Projekt gespeichert, ist aber mit jeder .NET IDE kompatibel.

Erstellen einer Excel-Datei in C# auf GitHub

Lesen Sie die XL API-Referenz

Entdecken Sie die API-Referenz für IronXL, die Details zu allen Funktionen, Namespaces, Klassen, Methoden, Feldern und Enums von IronXL enthält.

Ansicht der API-Referenz

Jonas Schmidt

C# Entwickler

Jonas ist ein leitender Entwickler bei einem Münchner .NET Softwarehaus. Jonas benutzt IronXL, um den Datenaustausch zwischen den Excel-Dokumenten der Buchhaltung und der Vertriebspipeline eines Kunden zu steuern. IronXL wird zu einem gängigen Tool in vielen von Jonas' Kundenbuchhaltungssystemen.