Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronXL
  2. IronXL Blog
  3. IronXL verwenden
  4. C# DataGridView mit Spaltenüberschriften nach Excel exportieren
IRONXL VERWENDEN

C# DataGridView mit Spaltenüberschriften nach Excel exportieren

Jordi Bardia
Jordi Bardia
Aktualisiert:

Wie exportiert man in C# ein DataGridView mit Spaltenüberschriften nach Excel?

Das Exportieren von Daten aus einem Windows Forms DataGridView-Steuerelement in das Excel-Format ist eine häufige Anforderung, doch Entwickler stoßen oft auf ein frustrierendes Problem: In der exportierten Datei fehlen die Spaltenüberschriften. Wenn Sie ein DataGridView mit Spaltenüberschriften nach Excel exportieren müssen, muss die Lösung alle Ihre Daten und Formatierungen zuverlässig erhalten. Herkömmliche Ansätze mit Microsoft Office Interop können langsam und fehleranfällig sein und erfordern die Installation von MS Excel auf jedem Rechner, auf dem der Code ausgeführt wird.

IronXL löst dieses Problem elegant. Es handelt sich um eine .NET Excel-Bibliothek, die Excel-Dateien ohne Office-Abhängigkeit lesen, erstellen und schreiben kann. Dieses Tutorial führt Sie durch eine vollständige Exportlösung – eine Lösung, die Spaltenüberschriften, Datentypen, leere Zellen und benutzerfreundliches Speichern von Dateien mit nur wenigen Codezeilen ermöglicht.

Am Ende verfügen Sie über einen funktionierenden Windows Forms-Button-Handler, der ein DataGridView in eine XLSX-Datei exportiert, wobei alle Spaltenüberschriften erhalten bleiben.

Was Sie vor dem Start benötigen

Bevor Sie mit dem Programmieren beginnen, stellen Sie sicher, dass Folgendes gegeben ist:

  • Visual Studio 2022 oder höher (beliebige Edition)
  • .NET 10 SDK installiert
  • Ein Windows Forms-Anwendungsprojekt, das auf .NET 10 abzielt
  • NuGet Zugriff zum Installieren von IronXL

Die folgenden Beispiele verwenden durchgehend Top-Level-Anweisungen und die moderne .NET 10-Projektstruktur.

Wie installiert man die Bibliothek in einem .NET -Projekt?

Öffnen Sie die NuGet Paket-Manager-Konsole in Visual Studio und führen Sie einen der folgenden Befehle aus. Das Paket ist in der NuGet Gallery gelistet und zielt auf .NET Standard 2.0 und höher ab, sodass es mit jedem modernen .NET Projekt funktioniert.

Install-Package IronXL
Install-Package IronXL
SHELL 
dotnet add package IronXL
dotnet add package IronXL
SHELL

Fügen Sie nach der Installation die erforderlichen Namespaces am Anfang Ihrer Formulardatei hinzu:

using IronXL;
using System;
using System.Data;
using System.Windows.Forms;
using IronXL;
using System;
using System.Data;
using System.Windows.Forms;
$vbLabelText   $csharpLabel

Diese Importe ermöglichen den Zugriff auf die Excel-Funktionalität von IronXL , die DataTable-Operationen und die für den Exportprozess benötigten Windows Forms-Steuerelemente.

Wie richtet man ein DataGridView mit Beispieldaten ein?

Erstellen Sie zunächst eine Windows Forms-Anwendung in Visual Studio. Fügen Sie über den Designer ein DataGridView mit dem Namen dataGridView1 und eine Schaltfläche mit dem Namen btnExport zum Hauptformular hinzu. Anschließend wird das Raster beim Laden des Formulars befüllt:

using System;
using System.Data;
using System.Windows.Forms;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        DataTable dt = new DataTable();

        // Define columns -- these names become Excel headers
        dt.Columns.Add("Product ID", typeof(int));
        dt.Columns.Add("Product Name", typeof(string));
        dt.Columns.Add("Price", typeof(decimal));
        dt.Columns.Add("Stock Quantity", typeof(int));

        // Add sample rows
        dt.Rows.Add(1001, "Laptop", 999.99m, 15);
        dt.Rows.Add(1002, "Mouse", 29.99m, 50);
        dt.Rows.Add(1003, "Keyboard", 79.99m, 30);
        dt.Rows.Add(1004, "Monitor", 299.99m, 12);
        dt.Rows.Add(1005, "Headphones", 89.99m, 25);

        // Bind data to the grid
        dataGridView1.DataSource = dt;
    }
}
using System;
using System.Data;
using System.Windows.Forms;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        DataTable dt = new DataTable();

        // Define columns -- these names become Excel headers
        dt.Columns.Add("Product ID", typeof(int));
        dt.Columns.Add("Product Name", typeof(string));
        dt.Columns.Add("Price", typeof(decimal));
        dt.Columns.Add("Stock Quantity", typeof(int));

        // Add sample rows
        dt.Rows.Add(1001, "Laptop", 999.99m, 15);
        dt.Rows.Add(1002, "Mouse", 29.99m, 50);
        dt.Rows.Add(1003, "Keyboard", 79.99m, 30);
        dt.Rows.Add(1004, "Monitor", 299.99m, 12);
        dt.Rows.Add(1005, "Headphones", 89.99m, 25);

        // Bind data to the grid
        dataGridView1.DataSource = dt;
    }
}
$vbLabelText   $csharpLabel

Die in den dt.Columns.Add(...)-Aufrufen definierten Spaltennamen werden zur Kopfzeile der exportierten Excel-Datei. Sie können hier jede beliebige Datenquelle verwenden – ein Datenbankabfrageergebnis, ein CSV-Import oder eine als DataTable gespeicherte API-Antwort funktionieren alle identisch mit dem später gezeigten Exportcode. Der DataTable-Ansatz ist besonders praktisch, da DataGridView eine DataSource-Eigenschaft bereitstellt, die beliebige IList- oder IBindingList-Werte akzeptiert. Das bedeutet, dass derselbe Exportcode ohne Änderungen auf alle Bindungsszenarien verallgemeinert werden kann.

Wenn Ihr DataGridView mithilfe von SqlDataAdapter aus einer Datenbank befüllt wird, enthält die DataTable bereits typisierte Spalten. Indem man diese typisierten Werte an SetCellValue übergibt, anstatt ToString() aufzurufen, bleiben numerische Spalten in der Excel-Ausgabe numerisch, was für alle nachfolgenden Berichte oder Pivot-Tabellen wichtig ist.

Dadurch wird ein DataGridView erstellt, das mit allen Daten gefüllt ist:

C# DataGridView mit Spaltenüberschriften mithilfe von IronXL nach Excel exportieren: Bild 1 - Beispieldaten in einem DataGridView

Für komplexere Datenbindungsszenarien bietet die Dokumentation von Microsoft zur DataGridView-Datenbindung zusätzliche Beispiele.

Wie exportiert man ein DataGridView nach Excel, wobei die Spaltenüberschriften erhalten bleiben?

Die Exportmethode liest die Spaltenüberschriften aus der HeaderText-Eigenschaft jeder DataGridView-Spalte und schreibt sie in Zeile 0 des Arbeitsblatts. Die Datenzeilen folgen ab Zeile 1. Verknüpfen Sie diese Methodee mit dem Klickereignis btnExport:

private void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Exported Data");

        // Write column headers to row 0
        for (int col = 0; col < dataGridView1.Columns.Count; col++)
        {
            worksheet.SetCellValue(0, col, dataGridView1.Columns[col].HeaderText);
        }

        // Write data rows starting at row 1
        for (int row = 0; row < dataGridView1.Rows.Count; row++)
        {
            // Skip the placeholder new-row at the bottom of the grid
            if (dataGridView1.AllowUserToAddRows && row == dataGridView1.Rows.Count - 1)
                continue;

            for (int col = 0; col < dataGridView1.Columns.Count; col++)
            {
                var cellValue = dataGridView1.Rows[row].Cells[col].Value;
                if (cellValue != null)
                {
                    worksheet.SetCellValue(row + 1, col, cellValue.ToString());
                }
            }
        }

        // Prompt the user to choose a save location
        using SaveFileDialog saveFileDialog = new SaveFileDialog
        {
            Filter = "Excel Files|*.xlsx",
            FileName = "DataGridView_Export.xlsx"
        };

        if (saveFileDialog.ShowDialog() == DialogResult.OK)
        {
            workbook.SaveAs(saveFileDialog.FileName);
            MessageBox.Show("Export completed successfully!", "Success",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Export failed: {ex.Message}", "Error",
                       MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}
private void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Exported Data");

        // Write column headers to row 0
        for (int col = 0; col < dataGridView1.Columns.Count; col++)
        {
            worksheet.SetCellValue(0, col, dataGridView1.Columns[col].HeaderText);
        }

        // Write data rows starting at row 1
        for (int row = 0; row < dataGridView1.Rows.Count; row++)
        {
            // Skip the placeholder new-row at the bottom of the grid
            if (dataGridView1.AllowUserToAddRows && row == dataGridView1.Rows.Count - 1)
                continue;

            for (int col = 0; col < dataGridView1.Columns.Count; col++)
            {
                var cellValue = dataGridView1.Rows[row].Cells[col].Value;
                if (cellValue != null)
                {
                    worksheet.SetCellValue(row + 1, col, cellValue.ToString());
                }
            }
        }

        // Prompt the user to choose a save location
        using SaveFileDialog saveFileDialog = new SaveFileDialog
        {
            Filter = "Excel Files|*.xlsx",
            FileName = "DataGridView_Export.xlsx"
        };

        if (saveFileDialog.ShowDialog() == DialogResult.OK)
        {
            workbook.SaveAs(saveFileDialog.FileName);
            MessageBox.Show("Export completed successfully!", "Success",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Export failed: {ex.Message}", "Error",
                       MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}
$vbLabelText   $csharpLabel

Aufschlüsselung der Export-Schritte

Jeder Schritt der Methodee dient einem bestimmten Zweck:

  • WorkBook.Create : Initialisiert eine neue Excel-Datei im Speicher unter Verwendung des XLSX-Formats. Es wird keine Datei auf die Festplatte geschrieben, bis SaveAs aufgerufen wird.
  • CreateWorkSheet : Fügt ein benanntes Tabellenblatt hinzu, um die exportierten Daten aufzunehmen. Der Name "Exportierte Daten" wird in Excel als Registerkartenbezeichnung angezeigt.
  • Spaltenkopf-Schleife : Liest dataGridView1.Columns[col].HeaderText für jede Spalte und schreibt es in Zeile 0. Dies ist der entscheidende Schritt, der die Überschriften beibehält.
  • Datenzeilenschleifen : Verschachtelte Schleifen durchlaufen jede Zeile und Spalte und verwenden dabei row + 1 als Excel-Zeilenindex, sodass die Daten immer unterhalb der Kopfzeile beginnen.
  • Nullprüfung : Verhindert Ausnahmen, wenn eine Zelle keinen Wert enthält, was bei realen Daten häufig vorkommt.
  • SaveFileDialog : Ermöglicht es Benutzern, Dateinamen und Speicherort zur Laufzeit auszuwählen, anstatt einen Pfad fest zu codieren.

Die exportierte Datei sieht folgendermaßen aus:

C# DataGridView mit Spaltenüberschriften mit IronXL nach Excel exportieren: Bild 2 - Excel-Ausgabedatei mit den exportierten Beispieldaten

Wie gehen Sie mit häufig auftretenden Sonderfällen beim Export um?

Daten aus der realen Welt sehen selten so sauber aus wie ein Beispieldatensatz. Hier sind die Szenarien, denen Sie am ehesten begegnen werden, und wie Sie damit umgehen können.

Leere Zellen

Die Nullprüfung (if (cellValue != null)) in der Datenschleife behandelt leere Zellen, ohne eine Ausnahme auszulösen. Leere Zellen bleiben in der Excel-Ausgabe leer, wodurch die Rasterstruktur erhalten bleibt.

Gemischte Datentypen

IronXL verarbeitet verschiedene Datenformate automatisch. Wenn Sie eine Zahl als Zeichenkette über ToString() übergeben, erkennt Excel sie je nach Wert möglicherweise trotzdem als numerisch. Für eine präzise Typkontrolle wandeln Sie den Zellenwert vor dem Schreiben in den richtigen Typ um:

if (cellValue is int intVal)
    worksheet.SetCellValue(row + 1, col, intVal);
else if (cellValue is decimal decVal)
    worksheet.SetCellValue(row + 1, col, (double)decVal);
else
    worksheet.SetCellValue(row + 1, col, cellValue?.ToString() ?? string.Empty);
if (cellValue is int intVal)
    worksheet.SetCellValue(row + 1, col, intVal);
else if (cellValue is decimal decVal)
    worksheet.SetCellValue(row + 1, col, (double)decVal);
else
    worksheet.SetCellValue(row + 1, col, cellValue?.ToString() ?? string.Empty);
$vbLabelText   $csharpLabel

Durch diese Vorgehensweise bleiben numerische Spalten in Excel numerisch, sodass Formeln und Sortierungen im weiteren Verlauf korrekt funktionieren.

Sonderzeichen in Kopfzeilen

Spaltenüberschriften mit Sonderzeichen wie &, <, > und Akzentbuchstaben werden korrekt exportiert. IronXL übernimmt die Kodierung automatisch und erfordert keine Maskierung Ihrerseits.

Große Datensätze

Bei Tabellen mit Zehntausenden von Zeilen empfiehlt es sich, die Exportlogik in einen Hintergrundthread auszulagern, um die Reaktionsfähigkeit der Benutzeroberfläche zu gewährleisten. Schließen Sie die WorkBook.Create- und Schleifenlogik in einen Task.Run-Aufruf ein und aktualisieren Sie die Benutzeroberfläche anhand des abgeschlossenen Rückrufs. Die Dokumentation von Microsoft zur asynchronen Programmierung mit Task erläutert das Muster im Detail.

Weitere Anwendungsfälle wie Zellstyling , Formelerhaltung und Passwortschutz werden in der IronXL Dokumentation ausführlich beschrieben.

Wie schneiden die wichtigsten Exportansätze im Vergleich ab?

Bevor man sich für eine Bibliothek entscheidet, ist es hilfreich, die Vor- und Nachteile der gängigsten Methodeen zu verstehen.

Vergleich der DataGridView-zu-Excel-Exportmethoden in C#
Methode Büro erforderlich Spaltenüberschriften Leistung Serversicher
Microsoft Office Interop Ja Handbuch Langsam Nein
OpenXML SDK Nein Handbuch Schnell Ja
ClosedXML Nein Handbuch Gut Ja
IronXL Nein Automatisch Schnell Ja

Interop-basierte Lösungen erfordern die Installation von Excel auf dem Server, was sowohl ein Lizenzproblem als auch eine Komplexität bei der Bereitstellung darstellt. Das OpenXML SDK ist leistungsstark, aber Low-Level – das Schreiben einer Kopfzeile erfordert das manuelle Erstellen von XML-Strukturen. Sowohl IronXL als auch ClosedXML bieten APIs auf höherer Ebene, aber das WorkBook- und WorkSheet-Modell von IronXL entspricht weitgehend der Art und Weise, wie Entwickler bereits über Tabellenkalkulationen denken.

Wie exportiert man nach CSV anstatt nach XLSX?

Das gleiche Exportmuster gilt, wenn Sie eine CSV-Datei anstelle einer Excel-Arbeitsmappe benötigen. Ändern Sie das Dateiformat und die Dateierweiterung:

WorkBook csvWorkbook = WorkBook.Create(ExcelFileFormat.CSV);
WorkSheet csvSheet = csvWorkbook.CreateWorkSheet("Data");

// Headers and data loops remain identical

using SaveFileDialog dialog = new SaveFileDialog
{
    Filter = "CSV Files|*.csv",
    FileName = "DataGridView_Export.csv"
};

if (dialog.ShowDialog() == DialogResult.OK)
    csvWorkbook.SaveAs(dialog.FileName);
WorkBook csvWorkbook = WorkBook.Create(ExcelFileFormat.CSV);
WorkSheet csvSheet = csvWorkbook.CreateWorkSheet("Data");

// Headers and data loops remain identical

using SaveFileDialog dialog = new SaveFileDialog
{
    Filter = "CSV Files|*.csv",
    FileName = "DataGridView_Export.csv"
};

if (dialog.ShowDialog() == DialogResult.OK)
    csvWorkbook.SaveAs(dialog.FileName);
$vbLabelText   $csharpLabel

Der CSV-Export ist nützlich, wenn das verarbeitende System XLSX nicht unterstützt oder wenn die Dateigröße bei sehr großen Datensätzen ein Problem darstellt.

Wie formatiert man die Kopfzeile in der exportierten Datei?

Die exportierten Daten sind besser lesbar, wenn die Kopfzeile optisch deutlich erkennbar ist. IronXL bietet Optionen zur Zellenformatierung , mit denen Sie nach dem Schreiben der Überschriftenwerte Fettdruck, Hintergrundfarbe und Schriftgröße anwenden können:

// Write headers and apply bold styling
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
    string cellAddress = worksheet.GetCellAddress(0, col);
    worksheet[cellAddress].Value = dataGridView1.Columns[col].HeaderText;
    worksheet[cellAddress].Style.Font.Bold = true;
    worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
    worksheet[cellAddress].Style.Font.FontColor = "#FFFFFF";
}
// Write headers and apply bold styling
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
    string cellAddress = worksheet.GetCellAddress(0, col);
    worksheet[cellAddress].Value = dataGridView1.Columns[col].HeaderText;
    worksheet[cellAddress].Style.Font.Bold = true;
    worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
    worksheet[cellAddress].Style.Font.FontColor = "#FFFFFF";
}
$vbLabelText   $csharpLabel

Eine formatierte Kopfzeile sorgt dafür, dass die exportierte Datei sofort für die Berichterstellung verwendet werden kann, ohne dass der Empfänger die Formatierung manuell vornehmen muss. Eine vollständige Liste der Stileigenschaften finden Sie in der IronXL -Zellenstyling-Referenz .

Wie starte ich eine kostenlose Testphase?

IronXL bietet eine kostenlose Testversion an, mit der Sie alle Funktionen testen können, einschließlich der in diesem Artikel gezeigten Export-Workflows. Installieren Sie das Paket entweder mit dem oben gezeigten NuGet -Befehl oder generieren Sie einen Testschlüssel auf der IronXL -Lizenzierungsseite und legen Sie diesen in Ihrer Anwendung vor dem ersten Bibliotheksaufruf fest:

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
$vbLabelText   $csharpLabel

Die Testversion erstellt voll funktionsfähige Excel-Dateien und schränkt die verfügbaren Funktionen nicht ein. Für den Produktionseinsatz umfassen die Lizenzoptionen einzelne Entwickler, Teams und die lizenzgebührenfreie Weiterverbreitung.

Weitere Informationen zu verwandten Exportszenarien finden Sie in der Dokumentation zu IronXL : Wie exportiert man DataTables direkt nach Excel ? Wie liest man Excel-Dateien in DataGridViews ein ? Wie erstellt man Diagramme aus exportierten Daten ?

Die richtige Exportstrategie für Ihren Anwendungsfall auswählen

Die in diesem Tutorial gezeigte einfache Methodee des zellenweisen Exports eignet sich für die meisten Windows Forms-Anwendungen. Wenn Ihr DataGridView an eine DataTable gebunden ist, können Sie die DataTable auch direkt an den DataTable-zu-Arbeitsblatt-Konverter von IronXL übergeben, der die Kopfzeile automatisch verarbeitet. Wählen Sie den direkten DataTable-Ansatz, wenn Ihr Spaltenlayout feststeht und Sie den kürzestmöglichen Codepfad wünschen. Wählen Sie die manuelle Vorgehensweise Zelle für Zelle, wenn Sie bedingte Logik pro Zelle benötigen – zum Beispiel, um Zellen hervorzuheben, deren Wert außerhalb eines zulässigen Bereichs liegt, oder um Nullable-Typen vor dem Schreiben explizit zuzuordnen.

Für serverseitige Szenarien wie ASP.NET Core Controller, die herunterladbare Excel-Berichte generieren, gilt dieselbe IronXL API. Der einzige Unterschied besteht im Speicherziel: Anstatt SaveAs(filePath) wird workbook.ToByteArray() aufgerufen und die Bytes werden mit dem Inhaltstyp application/vnd.openxmlformats-officedocument.spreadsheetml.sheet in die HTTP-Antwort geschrieben. Spaltenüberschriften werden unabhängig davon, ob die Ausgabe in eine Datei oder einen Datenstrom erfolgt, identisch übertragen.

Häufig gestellte Fragen

Wie kann ich DataGridView-Daten in C# nach Excel exportieren?

Erstellen Sie mithilfe der IronXL -Bibliothek eine Excel-Arbeitsmappe, durchlaufen Sie die Spalten des DataGridView, um die Überschriften in Zeile 0 zu schreiben, und anschließend die Datenzeilen, um die Zellwerte ab Zeile 1 zu schreiben. Speichern Sie die Arbeitsmappe mit „Speichern unter“.

Welche Vorteile bietet IronXL für den Export von Daten?

IronXL bietet eine leistungsstarke API für Excel-Operationen, die keine Installation von Microsoft Office erfordert. Es verarbeitet Header, Datentypen und Dateiformate ohne manuelle XML-Manipulation.

Ist es möglich, beim Exportieren von DataGridView nach Excel die Spaltenüberschriften beizubehalten?

Ja. Lesen Sie die HeaderText-Eigenschaft jeder DataGridView-Spalte und schreiben Sie sie in Zeile 0 des IronXL -Arbeitsblatts, bevor Sie Datenzeilen schreiben.

Benötige ich eine Testversion, um IronXL für den Export nach Excel zu verwenden?

Es ist eine kostenlose Testversion verfügbar, die Zugriff auf alle Funktionen bietet. Installieren Sie das NuGet Paket, generieren Sie einen Testschlüssel und setzen Sie IronXL, bevor Sie Bibliotheksaufrufe tätigen.

Kann IronXL große DataGridView-Datensätze beim Exportieren nach Excel verarbeiten?

Ja. Bei sehr großen Datentabellen empfiehlt es sich, den Export in einem Hintergrundthread mithilfe von Task.Run auszuführen, um die Benutzeroberfläche während des Datenschreibvorgangs durch IronXL reaktionsfähig zu halten.

Was sind die Schritte, um DataGridView mit IronXL nach Excel zu exportieren?

Installieren Sie IronXL, erstellen Sie eine WorkBook und ein WorkSheet, durchlaufen Sie die DataGridView-Spalten, um Überschriften in Zeile 0 zu schreiben, durchlaufen Sie die Zeilen, um Daten ab Zeile 1 zu schreiben, und rufen Sie dann SaveAs auf, um die Datei zu speichern.

Warum IronXL gegenüber anderen Bibliotheken für den Export nach Excel bevorzugen?

IronXL benötigt keine Office-Installation, läuft auf Servern und bietet eine übersichtliche WorkBook/WorkSheet-API, die sich intuitiv an die Arbeitsweise von Entwicklern mit Tabellenkalkulationen anpasst – mit umfassender Dokumentation und aktivem Support.

Gibt es Unterstützung bei der Behebung von Problemen mit IronXL?

Ja. IronXL bietet lizenzierten Kunden eine detaillierte API-Dokumentation, Codebeispiele und direkten technischen Support.

Kann ich den Excel-Exportprozess mit IronXL anpassen?

Ja. Nach dem Schreiben der Daten können Sie mithilfe der Style-API von IronXL beliebige Zellbereiche mit Fettdruck, Hintergrundfarben, Rahmen und Zahlenformaten versehen.

Unterstützt IronXL den Export von Daten in andere Formate als Excel?

Ja. IronXL unterstützt die Formate XLSX, XLS, CSV und TSV. Zum Umschalten des Formats muss lediglich der Wert des Enumerationswerts ExcelFileFormat geändert werden, der an WorkBook.Create übergeben wird.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me