1. IronXL
  2. Tutorials
  3. Wie man Excel-Dateien in C# liest
Wie man Excel-Dateien in C# liest

How to Read Excel Files in C# Without Interop: Complete Developer Guide

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Beherrschen Sie die Bearbeitung von Excel-Dateien in C# mit der leistungsstarken IronXL-Bibliothek – der .NET-Bibliothek, die Tabellenkalkulationsdaten liest, validiert und exportiert, ohne dass Microsoft Office installiert sein muss. Dieses umfassende Tutorial demonstriert praktische Excel-Funktionen, darunter Datenvalidierung, Datenbankkonvertierung und REST-API-Integration.

Schnellstart: Eine Zelle mit IronXL in einer Zeile auslesen

Mit nur einer Zeile können Sie eine Excel-Arbeitsmappe laden und den Wert einer Zelle using IronXL abrufen. Es ist auf Einfachheit ausgelegt – keine Interop, keine komplexe Einrichtung – nur schneller Zugriff auf Ihre Daten.

  1. Installieren Sie IronXL mit NuGet Package Manager

    PM > Install-Package IronXL.Excel

  2. Kopieren Sie diesen Codeausschnitt und führen Sie ihn aus.

    var value = IronXl.WorkBook.Load("file.xlsx").GetWorkSheet(0)["A1"].StringValue;

  3. Bereitstellen zum Testen in Ihrer Live-Umgebung

    Beginnen Sie noch heute, IronXL in Ihrem Projekt zu verwenden, mit einer kostenlosen Testversion

    arrow pointer

Wie richte ich IronXL ein, um Excel-Dateien in C# zu lesen?

Die Einrichtung von IronXL zum Lesen von Excel-Dateien in Ihrem C#-Projekt dauert nur wenige Minuten. Die Bibliothek unterstützt sowohl das .XLS- als auch das .XLSX-Format und ist somit vielseitig für alle Excel-bezogenen Aufgaben einsetzbar.

Befolgen Sie diese Schritte, um loszulegen:

  1. Laden Sie die C#-Bibliothek herunter, um Excel-Dateien zu lesen
  2. Laden und Lesen von Excel-Arbeitsmappen mit WorkBook.Load()
  3. Zugriff auf Arbeitsblätter mit der Methode GetWorkSheet()
  4. Lesen Sie Zellwerte mit einer intuitiven Syntax wie sheet["A1"].Value
  5. Tabellenkalkulationsdaten programmgesteuert validieren und verarbeiten
  6. Exportieren von Daten in Datenbanken mit Entity Framework

IronXL eignet sich hervorragend zum Lesen und Bearbeiten von Microsoft Excel-Dokumenten mit C#. Die Bibliothek arbeitet eigenständig – sie benötigt weder Microsoft Excel noch Interop, um zu funktionieren. Tatsächlich bietet IronXL eine schnellere und intuitivere API als Microsoft.Office.Interop.Excel.

IronXL umfasst:

  • Spezieller Produktsupport durch unsere .NET-Ingenieure
  • Einfache Installation über Microsoft Visual Studio
  • Kostenlose Testversion für die Entwicklung. Lizenzen von liteLicense

Das Lesen und Erstellen von Excel-Dateien in C# und VB.NET wird mit der IronXL-Bibliothek zum Kinderspiel.

Lesen von Excel-Dateien im Format .XLS und .XLSX using IronXL

Hier ist der grundlegende Arbeitsablauf zum Lesen von Excel-Dateien using IronXL:

  1. Installieren Sie die IronXL-Bibliothek für Excel über das NuGet-Paket oder laden Sie die .NET Excel-DLL herunter
  2. Verwenden Sie die Methode WorkBook.Load(), um beliebige XLS-, XLSX- oder CSV-Dokumente zu lesen
  3. Zugriff auf Zellwerte mit intuitiver Syntax: sheet["A11"].DecimalValue
:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-1.cs
using IronXL;
using System;
using System.Linq;

// Load Excel workbook from file path
WorkBook workBook = WorkBook.Load("test.xlsx");

// Access the first worksheet using LINQ
WorkSheet workSheet = workBook.WorkSheets.First();

// Read integer value from cell A2
int cellValue = workSheet["A2"].IntValue;
Console.WriteLine($"Cell A2 value: {cellValue}");

// Iterate through a range of cells
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Advanced Operations with LINQ
// Calculate sum using built_in Sum() method
decimal sum = workSheet["A2:A10"].Sum();

// Find maximum value using LINQ
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

// Output calculated results
Console.WriteLine($"Sum of A2:A10: {sum}");
Console.WriteLine($"Maximum value: {max}");
Imports IronXL
Imports System
Imports System.Linq

' Load Excel workbook from file path
Dim workBook As WorkBook = WorkBook.Load("test.xlsx")

' Access the first worksheet using LINQ
Dim workSheet As WorkSheet = workBook.WorkSheets.First()

' Read integer value from cell A2
Dim cellValue As Integer = workSheet("A2").IntValue
Console.WriteLine($"Cell A2 value: {cellValue}")

' Iterate through a range of cells
For Each cell In workSheet("A2:A10")
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
Next

' Advanced Operations with LINQ
' Calculate sum using built_in Sum() method
Dim sum As Decimal = workSheet("A2:A10").Sum()

' Find maximum value using LINQ
Dim max As Decimal = workSheet("A2:A10").Max(Function(c) c.DecimalValue)

' Output calculated results
Console.WriteLine($"Sum of A2:A10: {sum}")
Console.WriteLine($"Maximum value: {max}")
$vbLabelText   $csharpLabel

Dieser Code veranschaulicht mehrere wichtige Funktionen von IronXL: Laden von Arbeitsmappen, Zugriff auf Zellen über ihre Adresse, Durchlaufen von Bereichen und Durchführen von Berechnungen. Die Methode WorkBook.Load() erkennt Dateiformate auf intelligente Weise, während die Bereichssyntax ["A2:A10"] eine Excel-ähnliche Zellauswahl ermöglicht. Die LINQ-Integration ermöglicht leistungsstarke Datenabfragen und Aggregationen in Zellensammlungen.

Die Code-Beispiele in diesem Tutorial basieren auf drei Beispiel-Excel-Tabellen, die verschiedene Datenszenarien veranschaulichen:

Drei Excel-Tabellen, die im Visual Studio Solution Explorer angezeigt werden Beispiel-Excel-Dateien (GDP.xlsx, People.xlsx und PopulationByState.xlsx), die in diesem Tutorial zur Veranschaulichung verschiedener IronXL-Operationen verwendet werden.

Wie kann ich die IronXL-Bibliothek für C# installieren?

Durch die Installation der IronXl.Excel-Bibliothek erhalten Ihre .NET Framework-Projekte umfassende Excel-Funktionalität. Wählen Sie zwischen einer NuGet-Installation oder einer manuellen DLL-Integration.

Installation des IronXL-NuGet-Pakets

  1. Klicken Sie in Visual Studio mit der rechten Maustaste auf Ihr Projekt und wählen Sie "NuGet-Pakete verwalten..."
  2. Suchen Sie auf der Registerkarte "Durchsuchen" nach IronXl.Excel
  3. Klicken Sie auf die Schaltfläche "Installieren", um IronXL zu Ihrem Projekt hinzuzufügen

NuGet-Paketmanager-Oberfläche mit der Installation des IronXl.Excel-Pakets Die Installation von IronXL über den NuGet-Paket-Manager von Visual Studio ermöglicht eine automatische Abhängigkeitsverwaltung.

Alternativ können Sie IronXL über die Paket-Manager-Konsole installieren:

  1. Öffnen Sie die Paket-Manager-Konsole (Extras → NuGet-Paket-Manager → Paket-Manager-Konsole)
  2. Führen Sie den Installationsbefehl aus:
Install-Package IronXL.Excel

Sie können die Paketdetails auch auf der NuGet-Website einsehen.

Manuelle Installation

Für die manuelle Installation laden Sie die IronXL.Excel .NET DLL herunter und verweisen Sie in Ihrem Visual Studio-Projekt direkt darauf.

Wie lade und lese ich eine Excel-Arbeitsmappe?

Die Klasse WorkBook repräsentiert eine gesamte Excel-Datei. Laden Sie Excel-Dateien mit der Methode WorkBook.Load(), die Dateipfade für die Formate XLS, XLSX, CSV und TSV akzeptiert.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-2.cs
using IronXL;
using System;
using System.Linq;

// Load Excel file from specified path
WorkBook workBook = WorkBook.Load(@"Spreadsheets\GDP.xlsx");

Console.WriteLine("Workbook loaded successfully.");

// Access specific worksheet by name
WorkSheet sheet = workBook.GetWorkSheet("Sheet1");

// Read and display cell value
string cellValue = sheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Perform additional operations
// Count non_empty cells in column A
int rowCount = sheet["A:A"].Count(cell => !cell.IsEmpty);
Console.WriteLine($"Column A has {rowCount} non_empty cells");
Imports IronXL
Imports System
Imports System.Linq

' Load Excel file from specified path
Dim workBook As WorkBook = WorkBook.Load("Spreadsheets\GDP.xlsx")

Console.WriteLine("Workbook loaded successfully.")

' Access specific worksheet by name
Dim sheet As WorkSheet = workBook.GetWorkSheet("Sheet1")

' Read and display cell value
Dim cellValue As String = sheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")

' Perform additional operations
' Count non_empty cells in column A
Dim rowCount As Integer = sheet("A:A").Count(Function(cell) Not cell.IsEmpty)
Console.WriteLine($"Column A has {rowCount} non_empty cells")
$vbLabelText   $csharpLabel

Jedes WorkBook enthält mehrere WorkSheet-Objekte, die einzelne Excel-Blätter darstellen. Greifen Sie über GetWorkSheet() auf Arbeitsblätter anhand ihres Namens zu:

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-3.cs
using IronXL;
using System;

// Get worksheet by name
WorkSheet workSheet = workBook.GetWorkSheet("GDPByCountry");

Console.WriteLine("Worksheet 'GDPByCountry' not found");
// List available worksheets
foreach (var sheet in workBook.WorkSheets)
{
    Console.WriteLine($"Available: {sheet.Name}");
}
Imports IronXL
Imports System

' Get worksheet by name
Dim workSheet As WorkSheet = workBook.GetWorkSheet("GDPByCountry")

Console.WriteLine("Worksheet 'GDPByCountry' not found")
' List available worksheets
For Each sheet In workBook.WorkSheets
    Console.WriteLine($"Available: {sheet.Name}")
Next
$vbLabelText   $csharpLabel

Wie erstelle ich neue Excel-Dokumente in C#?

Erstellen Sie neue Excel-Dokumente, indem Sie ein WorkBook-Objekt mit dem gewünschten Dateiformat erstellen. IronXL unterstützt sowohl das moderne XLSX- als auch das ältere XLS-Format.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-4.cs
using IronXL;

// Create new XLSX workbook (recommended format)
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);

// Set workbook metadata
workBook.Metadata.Author = "Your Application";
workBook.Metadata.Comments = "Generated by IronXL";

// Create new XLS workbook for legacy support
WorkBook legacyWorkBook = WorkBook.Create(ExcelFileFormat.XLS);

// Save the workbook
workBook.SaveAs("NewDocument.xlsx");
Imports IronXL

' Create new XLSX workbook (recommended format)
Private workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

' Set workbook metadata
workBook.Metadata.Author = "Your Application"
workBook.Metadata.Comments = "Generated by IronXL"

' Create new XLS workbook for legacy support
Dim legacyWorkBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLS)

' Save the workbook
workBook.SaveAs("NewDocument.xlsx")
$vbLabelText   $csharpLabel

Hinweis: Verwenden Sie ExcelFileFormat.XLS nur, wenn Kompatibilität mit Excel 2003 und früheren Versionen erforderlich ist.

Wie kann ich Arbeitsblätter zu einem Excel-Dokument hinzufügen?

Ein IronXL WorkBook enthält eine Sammlung von Arbeitsblättern. Das Verständnis dieser Struktur ist hilfreich beim Erstellen von Excel-Dateien mit mehreren Blättern.

Diagramm, das eine Arbeitsmappe mit mehreren Arbeitsblättern zeigt Visuelle Darstellung der WorkBook-Struktur, die mehrere WorkSheet-Objekte in IronXL enthält.

Erstellen Sie neue Arbeitsblätter mit CreateWorkSheet():

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-5.cs
using IronXL;

// Create multiple worksheets with descriptive names
WorkSheet summarySheet = workBook.CreateWorkSheet("Summary");
WorkSheet dataSheet = workBook.CreateWorkSheet("RawData");
WorkSheet chartSheet = workBook.CreateWorkSheet("Charts");

// Set the active worksheet
workBook.SetActiveTab(0); // Makes "Summary" the active sheet

// Access default worksheet (first sheet)
WorkSheet defaultSheet = workBook.DefaultWorkSheet;
Imports IronXL

' Create multiple worksheets with descriptive names
Dim summarySheet As WorkSheet = workBook.CreateWorkSheet("Summary")
Dim dataSheet As WorkSheet = workBook.CreateWorkSheet("RawData")
Dim chartSheet As WorkSheet = workBook.CreateWorkSheet("Charts")

' Set the active worksheet
workBook.SetActiveTab(0) ' Makes "Summary" the active sheet

' Access default worksheet (first sheet)
Dim defaultSheet As WorkSheet = workBook.DefaultWorkSheet
$vbLabelText   $csharpLabel

Wie kann ich Zellwerte lesen und bearbeiten?

Eine einzelne Zelle lesen und bearbeiten

Greifen Sie über die Indexer-Eigenschaft des Arbeitsblatts auf einzelne Zellen zu. Die Klasse Cell von IronXL bietet stark typisierte Werteigenschaften.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-6.cs
using IronXL;
using System;
using System.Linq;

// Load workbook and get worksheet
WorkBook workBook = WorkBook.Load("test.xlsx");
WorkSheet workSheet = workBook.DefaultWorkSheet;

// Access cell B1
IronXL.Cell cell = workSheet["B1"].First();

// Read cell value with type safety
string textValue = cell.StringValue;
int intValue = cell.IntValue;
decimal decimalValue = cell.DecimalValue;
DateTime? dateValue = cell.DateTimeValue;

// Check cell data type
if (cell.IsNumeric)
{
    Console.WriteLine($"Numeric value: {cell.DecimalValue}");
}
else if (cell.IsText)
{
    Console.WriteLine($"Text value: {cell.StringValue}");
}
Imports IronXL
Imports System
Imports System.Linq

' Load workbook and get worksheet
Dim workBook As WorkBook = WorkBook.Load("test.xlsx")
Dim workSheet As WorkSheet = workBook.DefaultWorkSheet

' Access cell B1
Dim cell As IronXL.Cell = workSheet("B1").First()

' Read cell value with type safety
Dim textValue As String = cell.StringValue
Dim intValue As Integer = cell.IntValue
Dim decimalValue As Decimal = cell.DecimalValue
Dim dateValue As DateTime? = cell.DateTimeValue

' Check cell data type
If cell.IsNumeric Then
    Console.WriteLine($"Numeric value: {cell.DecimalValue}")
ElseIf cell.IsText Then
    Console.WriteLine($"Text value: {cell.StringValue}")
End If
$vbLabelText   $csharpLabel

Die Klasse Cell bietet mehrere Eigenschaften für verschiedene Datentypen und konvertiert Werte nach Möglichkeit automatisch. Weitere Informationen zu Zelloperationen finden Sie im Tutorial zur Zellformatierung.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-7.cs
// Write different data types to cells
workSheet["A1"].Value = "Product Name";     // String
workSheet["B1"].Value = 99.95m;             // Decimal
workSheet["C1"].Value = DateTime.Today;     // Date
workSheet["D1"].Formula = "=B1*1.2";        // Formula
                                            // Format cells
workSheet["B1"].FormatString = "$#,##0.00"; // Currency format
workSheet["C1"].FormatString = "yyyy-MM-dd";// Date format
                                            // Save changes
workBook.Save();
' Write different data types to cells
workSheet("A1").Value = "Product Name" ' String
workSheet("B1").Value = 99.95D ' Decimal
workSheet("C1").Value = DateTime.Today ' Date
workSheet("D1").Formula = "=B1*1.2" ' Formula
											' Format cells
workSheet("B1").FormatString = "$#,##0.00" ' Currency format
workSheet("C1").FormatString = "yyyy-MM-dd" ' Date format
											' Save changes
workBook.Save()
$vbLabelText   $csharpLabel

Wie kann ich mit Zellbereichen arbeiten?

Die Klasse Range stellt eine Sammlung von Zellen dar und ermöglicht Massenoperationen mit Excel-Daten.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-8.cs
using IronXL;
using Range = IronXL.Range;

// Select range using Excel notation
Range range = workSheet["D2:D101"];

// Alternative: Use Range class for dynamic selection
Range dynamicRange = workSheet.GetRange("D2:D101"); // Row 2_101, Column D

// Perform bulk operations
range.Value = 0; // Set all cells to 0
Imports IronXL

' Select range using Excel notation
Dim range As Range = workSheet("D2:D101")

' Alternative: Use Range class for dynamic selection
Dim dynamicRange As Range = workSheet.GetRange("D2:D101") ' Row 2_101, Column D

' Perform bulk operations
range.Value = 0 ' Set all cells to 0
$vbLabelText   $csharpLabel

Effiziente Verarbeitung von Bereichen mithilfe von Schleifen, wenn die Zellenanzahl bekannt ist:

// Data validation example
public class ValidationResult
{
    public int Row { get; set; }
    public string PhoneError { get; set; }
    public string EmailError { get; set; }
    public string DateError { get; set; }
    public bool IsValid => string.IsNullOrEmpty(PhoneError) && 
                           string.IsNullOrEmpty(EmailError) && 
                           string.IsNullOrEmpty(DateError);
}

// Validate data in rows 2-101
var results = new List<ValidationResult>();

for (int row = 2; row <= 101; row++)
{
    var result = new ValidationResult { Row = row };

    // Get row data efficiently
    var phoneCell = workSheet[$"B{row}"];
    var emailCell = workSheet[$"D{row}"];
    var dateCell = workSheet[$"E{row}"];

    // Validate phone number
    if (!IsValidPhoneNumber(phoneCell.StringValue))
        result.PhoneError = "Invalid phone format";

    // Validate email
    if (!IsValidEmail(emailCell.StringValue))
        result.EmailError = "Invalid email format";

    // Validate date
    if (!dateCell.IsDateTime)
        result.DateError = "Invalid date format";

    results.Add(result);
}

// Helper methods
bool IsValidPhoneNumber(string phone) => 
    System.Text.RegularExpressions.Regex.IsMatch(phone, @"^\d{3}-\d{3}-\d{4}$");

bool IsValidEmail(string email) => 
    email.Co/ntains("@") && email.Co/ntains(".");
// Data validation example
public class ValidationResult
{
    public int Row { get; set; }
    public string PhoneError { get; set; }
    public string EmailError { get; set; }
    public string DateError { get; set; }
    public bool IsValid => string.IsNullOrEmpty(PhoneError) && 
                           string.IsNullOrEmpty(EmailError) && 
                           string.IsNullOrEmpty(DateError);
}

// Validate data in rows 2-101
var results = new List<ValidationResult>();

for (int row = 2; row <= 101; row++)
{
    var result = new ValidationResult { Row = row };

    // Get row data efficiently
    var phoneCell = workSheet[$"B{row}"];
    var emailCell = workSheet[$"D{row}"];
    var dateCell = workSheet[$"E{row}"];

    // Validate phone number
    if (!IsValidPhoneNumber(phoneCell.StringValue))
        result.PhoneError = "Invalid phone format";

    // Validate email
    if (!IsValidEmail(emailCell.StringValue))
        result.EmailError = "Invalid email format";

    // Validate date
    if (!dateCell.IsDateTime)
        result.DateError = "Invalid date format";

    results.Add(result);
}

// Helper methods
bool IsValidPhoneNumber(string phone) => 
    System.Text.RegularExpressions.Regex.IsMatch(phone, @"^\d{3}-\d{3}-\d{4}$");

bool IsValidEmail(string email) => 
    email.Co/ntains("@") && email.Co/ntains(".");
Imports System.Text.RegularExpressions
Imports System.Collections.Generic

' Data validation example
Public Class ValidationResult
    Public Property Row As Integer
    Public Property PhoneError As String
    Public Property EmailError As String
    Public Property DateError As String
    Public ReadOnly Property IsValid As Boolean
        Get
            Return String.IsNullOrEmpty(PhoneError) AndAlso
                   String.IsNullOrEmpty(EmailError) AndAlso
                   String.IsNullOrEmpty(DateError)
        End Get
    End Property
End Class

' Validate data in rows 2-101
Dim results As New List(Of ValidationResult)()

For row As Integer = 2 To 101
    Dim result As New ValidationResult With {.Row = row}

    ' Get row data efficiently
    Dim phoneCell = workSheet($"B{row}")
    Dim emailCell = workSheet($"D{row}")
    Dim dateCell = workSheet($"E{row}")

    ' Validate phone number
    If Not IsValidPhoneNumber(phoneCell.StringValue) Then
        result.PhoneError = "Invalid phone format"
    End If

    ' Validate email
    If Not IsValidEmail(emailCell.StringValue) Then
        result.EmailError = "Invalid email format"
    End If

    ' Validate date
    If Not dateCell.IsDateTime Then
        result.DateError = "Invalid date format"
    End If

    results.Add(result)
Next

' Helper methods
Private Function IsValidPhoneNumber(phone As String) As Boolean
    Return Regex.IsMatch(phone, "^\d{3}-\d{3}-\d{4}$")
End Function

Private Function IsValidEmail(email As String) As Boolean
    Return email.Contains("@") AndAlso email.Contains(".")
End Function
$vbLabelText   $csharpLabel

Wie füge ich Formeln in Excel-Tabellen ein?

Wenden Sie Excel-Formeln mithilfe der Eigenschaft Formula an. IronXL unterstützt die Standard-Syntax von Excel-Formeln.

:path=/static-assets/excel/content-code-examples/tutorials/how-to-read-excel-file-csharp-9.cs
using IronXL;

// Add formulas to calculate percentages
int lastRow = 50;
for (int row = 2; row < lastRow; row++)
{
    // Calculate percentage: current value / total
    workSheet[$"C{row}"].Formula = $"=B{row}/B{lastRow}";
    // Format as percentage
    workSheet[$"C{row}"].FormatString = "0.00%";
}
// Add summary formulas
workSheet["B52"].Formula = "=SUM(B2:B50)";      // Sum
workSheet["B53"].Formula = "=AVERAGE(B2:B50)";   // Average
workSheet["B54"].Formula = "=MAX(B2:B50)";       // Maximum
workSheet["B55"].Formula = "=MIN(B2:B50)";       // Minimum
                                                 // Force formula evaluation
workBook.EvaluateAll();
Imports IronXL

' Add formulas to calculate percentages
Dim lastRow As Integer = 50
For row As Integer = 2 To lastRow - 1
    ' Calculate percentage: current value / total
    workSheet($"C{row}").Formula = $"=B{row}/B{lastRow}"
    ' Format as percentage
    workSheet($"C{row}").FormatString = "0.00%"
Next
' Add summary formulas
workSheet("B52").Formula = "=SUM(B2:B50)"      ' Sum
workSheet("B53").Formula = "=AVERAGE(B2:B50)"  ' Average
workSheet("B54").Formula = "=MAX(B2:B50)"      ' Maximum
workSheet("B55").Formula = "=MIN(B2:B50)"      ' Minimum
' Force formula evaluation
workBook.EvaluateAll()
$vbLabelText   $csharpLabel

Um vorhandene Formeln zu bearbeiten, sehen Sie sich das Excel-Formel-Tutorial an.

Wie kann ich Tabellenkalkulationsdaten validieren?

IronXL ermöglicht eine umfassende Datenvalidierung für Tabellenkalkulationen. Dieses Beispiel validiert Telefonnummern, E-Mail-Adressen und Datumsangaben mithilfe externer Bibliotheken und integrierter C#-Funktionen.

using System.Text.RegularExpressions;
using IronXL;

// Validation implementation
for (int i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get cells for current person
    var cells = workSheet[$"A{i}:E{i}"].ToList();

    // Validate phone (column B)
    string phone = cells[1].StringValue;
    if (!Regex.IsMatch(phone, @"^\+?1?\d{10,14}$"))
    {
        result.PhoneNumberErrorMessage = "Invalid phone format";
    }

    // Validate email (column D)
    string email = cells[3].StringValue;
    if (!Regex.IsMatch(email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
    {
        result.EmailErrorMessage = "Invalid email address";
    }

    // Validate date (column E)
    if (!cells[4].IsDateTime)
    {
        result.DateErrorMessage = "Invalid date format";
    }
}
using System.Text.RegularExpressions;
using IronXL;

// Validation implementation
for (int i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get cells for current person
    var cells = workSheet[$"A{i}:E{i}"].ToList();

    // Validate phone (column B)
    string phone = cells[1].StringValue;
    if (!Regex.IsMatch(phone, @"^\+?1?\d{10,14}$"))
    {
        result.PhoneNumberErrorMessage = "Invalid phone format";
    }

    // Validate email (column D)
    string email = cells[3].StringValue;
    if (!Regex.IsMatch(email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
    {
        result.EmailErrorMessage = "Invalid email address";
    }

    // Validate date (column E)
    if (!cells[4].IsDateTime)
    {
        result.DateErrorMessage = "Invalid date format";
    }
}
Imports System.Text.RegularExpressions
Imports IronXL

' Validation implementation
For i As Integer = 2 To 101
	Dim result = New PersonValidationResult With {.Row = i}
	results.Add(result)

	' Get cells for current person
	Dim cells = workSheet($"A{i}:E{i}").ToList()

	' Validate phone (column B)
	Dim phone As String = cells(1).StringValue
	If Not Regex.IsMatch(phone, "^\+?1?\d{10,14}$") Then
		result.PhoneNumberErrorMessage = "Invalid phone format"
	End If

	' Validate email (column D)
	Dim email As String = cells(3).StringValue
	If Not Regex.IsMatch(email, "^[^@\s]+@[^@\s]+\.[^@\s]+$") Then
		result.EmailErrorMessage = "Invalid email address"
	End If

	' Validate date (column E)
	If Not cells(4).IsDateTime Then
		result.DateErrorMessage = "Invalid date format"
	End If
Next i
$vbLabelText   $csharpLabel

Speichern Sie die Validierungsergebnisse in einem neuen Arbeitsblatt:

// Create results worksheet
var resultsSheet = workBook.CreateWorkSheet("ValidationResults");

// Add headers
resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

// Style headers
resultsSheet["A1:E1"].Style.Font.Bold = true;
resultsSheet["A1:E1"].Style.SetBackgroundColor("#4472C4");
resultsSheet["A1:E1"].Style.Font.Co/lor = "#FFFFFF";

// Output validation results
for (int i = 0; i < results.Co/unt; i++)
{
    var result = results[i];
    int outputRow = i + 2;

    resultsSheet[$"A{outputRow}"].Value = result.Row;
    resultsSheet[$"B{outputRow}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{outputRow}"].Value = result.PhoneNumberErrorMessage ?? "";
    resultsSheet[$"D{outputRow}"].Value = result.EmailErrorMessage ?? "";
    resultsSheet[$"E{outputRow}"].Value = result.DateErrorMessage ?? "";

    // Highlight invalid rows
    if (!result.IsValid)
    {
        resultsSheet[$"A{outputRow}:E{outputRow}"].Style.SetBackgroundColor("#FFE6E6");
    }
}

// Auto-fit columns
for (int col = 0; col < 5; col++)
{
    resultsSheet.AutoSizeColumn(col);
}

// Save validated workbook
workBook.SaveAs(@"Spreadsheets\PeopleValidated.xlsx");
// Create results worksheet
var resultsSheet = workBook.CreateWorkSheet("ValidationResults");

// Add headers
resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

// Style headers
resultsSheet["A1:E1"].Style.Font.Bold = true;
resultsSheet["A1:E1"].Style.SetBackgroundColor("#4472C4");
resultsSheet["A1:E1"].Style.Font.Co/lor = "#FFFFFF";

// Output validation results
for (int i = 0; i < results.Co/unt; i++)
{
    var result = results[i];
    int outputRow = i + 2;

    resultsSheet[$"A{outputRow}"].Value = result.Row;
    resultsSheet[$"B{outputRow}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{outputRow}"].Value = result.PhoneNumberErrorMessage ?? "";
    resultsSheet[$"D{outputRow}"].Value = result.EmailErrorMessage ?? "";
    resultsSheet[$"E{outputRow}"].Value = result.DateErrorMessage ?? "";

    // Highlight invalid rows
    if (!result.IsValid)
    {
        resultsSheet[$"A{outputRow}:E{outputRow}"].Style.SetBackgroundColor("#FFE6E6");
    }
}

// Auto-fit columns
for (int col = 0; col < 5; col++)
{
    resultsSheet.AutoSizeColumn(col);
}

// Save validated workbook
workBook.SaveAs(@"Spreadsheets\PeopleValidated.xlsx");
Imports System

' Create results worksheet
Dim resultsSheet = workBook.CreateWorkSheet("ValidationResults")

' Add headers
resultsSheet("A1").Value = "Row"
resultsSheet("B1").Value = "Valid"
resultsSheet("C1").Value = "Phone Error"
resultsSheet("D1").Value = "Email Error"
resultsSheet("E1").Value = "Date Error"

' Style headers
resultsSheet("A1:E1").Style.Font.Bold = True
resultsSheet("A1:E1").Style.SetBackgroundColor("#4472C4")
resultsSheet("A1:E1").Style.Font.Color = "#FFFFFF"

' Output validation results
For i As Integer = 0 To results.Count - 1
    Dim result = results(i)
    Dim outputRow As Integer = i + 2

    resultsSheet($"A{outputRow}").Value = result.Row
    resultsSheet($"B{outputRow}").Value = If(result.IsValid, "Yes", "No")
    resultsSheet($"C{outputRow}").Value = If(result.PhoneNumberErrorMessage, "")
    resultsSheet($"D{outputRow}").Value = If(result.EmailErrorMessage, "")
    resultsSheet($"E{outputRow}").Value = If(result.DateErrorMessage, "")

    ' Highlight invalid rows
    If Not result.IsValid Then
        resultsSheet($"A{outputRow}:E{outputRow}").Style.SetBackgroundColor("#FFE6E6")
    End If
Next

' Auto-fit columns
For col As Integer = 0 To 4
    resultsSheet.AutoSizeColumn(col)
Next

' Save validated workbook
workBook.SaveAs("Spreadsheets\PeopleValidated.xlsx")
$vbLabelText   $csharpLabel

Wie exportiere ich Excel-Daten in eine Datenbank?

Verwenden Sie IronXL mit Entity Framework, um Tabellenkalkulationsdaten direkt in Datenbanken zu exportieren. Dieses Beispiel zeigt den Export von BIP-Daten eines Landes nach SQLite.

using System;
using System.Com/ponentModel.DataAnnotations;
using Microsoft.EntityFrameworkCore;
using IronXL;

// Define entity model
public class Country
{
    [Key]
    public Guid Id { get; set; } = Guid.NewGuid();

    [Required]
    [MaxLength(100)]
    public string Name { get; set; }

    [Range(0, double.MaxValue)]
    public decimal GDP { get; set; }

    public DateTime ImportedDate { get; set; } = DateTime.UtcNow;
}
using System;
using System.Com/ponentModel.DataAnnotations;
using Microsoft.EntityFrameworkCore;
using IronXL;

// Define entity model
public class Country
{
    [Key]
    public Guid Id { get; set; } = Guid.NewGuid();

    [Required]
    [MaxLength(100)]
    public string Name { get; set; }

    [Range(0, double.MaxValue)]
    public decimal GDP { get; set; }

    public DateTime ImportedDate { get; set; } = DateTime.UtcNow;
}
Imports System
Imports System.ComponentModel.DataAnnotations
Imports Microsoft.EntityFrameworkCore
Imports IronXL

' Define entity model
Public Class Country
    <Key>
    Public Property Id As Guid = Guid.NewGuid()

    <Required>
    <MaxLength(100)>
    Public Property Name As String

    <Range(0, Double.MaxValue)>
    Public Property GDP As Decimal

    Public Property ImportedDate As DateTime = DateTime.UtcNow
End Class
$vbLabelText   $csharpLabel

Konfigurieren Sie den Entity Framework-Kontext für Datenbankoperationen:

public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // Configure SQLite connection
        optionsBuilder.UseSqlite("Data Source=CountryGDP.db");

        // Enable sensitive data logging in development
        #if DEBUG
        optionsBuilder.EnableSensitiveDataLogging();
        #endif
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Configure decimal precision
        modelBuilder.Entity<Country>()
            .Property(c => c.GDP)
            .HasPrecision(18, 2);
    }
}
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // Configure SQLite connection
        optionsBuilder.UseSqlite("Data Source=CountryGDP.db");

        // Enable sensitive data logging in development
        #if DEBUG
        optionsBuilder.EnableSensitiveDataLogging();
        #endif
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Configure decimal precision
        modelBuilder.Entity<Country>()
            .Property(c => c.GDP)
            .HasPrecision(18, 2);
    }
}
Public Class CountryContext
	Inherits DbContext

	Public Property Countries() As DbSet(Of Country)

	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		' Configure SQLite connection
		optionsBuilder.UseSqlite("Data Source=CountryGDP.db")

		' Enable sensitive data logging in development
		#If DEBUG Then
		optionsBuilder.EnableSensitiveDataLogging()
		#End If
	End Sub

	Protected Overrides Sub OnModelCreating(ByVal modelBuilder As ModelBuilder)
		' Configure decimal precision
		modelBuilder.Entity(Of Country)().Property(Function(c) c.GDP).HasPrecision(18, 2)
	End Sub
End Class
$vbLabelText   $csharpLabel

Hinweis:Hinweis: Um verschiedene Datenbanken zu verwenden, installieren Sie das entsprechende NuGet-Paket (z. B. Microsoft.EntityFrameworkCore.SqlServer für SQL Server) und passen Sie die Verbindungskonfiguration entsprechend an.

Excel-Daten in die Datenbank importieren:

using System.Threading.Tasks;
using IronXL;
using Microsoft.EntityFrameworkCore;

public async Task ImportGDPDataAsync()
{
    try
    {
        // Load Excel file
        var workBook = WorkBook.Load(@"Spreadsheets\GDP.xlsx");
        var workSheet = workBook.GetWorkSheet("GDPByCountry");

        using (var context = new CountryContext())
        {
            // Ensure database exists
            await context.Database.EnsureCreatedAsync();

            // Clear existing data (optional)
            await context.Database.ExecuteSqlRawAsync("DELETE FROM Countries");

            // Import data with progress tracking
            int totalRows = 213;
            for (int row = 2; row <= totalRows; row++)
            {
                // Read country data
                var countryName = workSheet[$"A{row}"].StringValue;
                var gdpValue = workSheet[$"B{row}"].DecimalValue;

                // Skip empty rows
                if (string.IsNullOrWhiteSpace(countryName))
                    continue;

                // Create and add entity
                var country = new Country
                {
                    Name = countryName.Trim(),
                    GDP = gdpValue * 1_000_000 // Convert to actual value if in millions
                };

                await context.Co/untries.AddAsync(country);

                // Save in batches for performance
                if (row % 50 == 0)
                {
                    await context.SaveChangesAsync();
                    Console.WriteLine($"Imported {row - 1} of {totalRows} countries");
                }
            }

            // Save remaining records
            await context.SaveChangesAsync();
            Console.WriteLine($"Successfully imported {await context.Co/untries.CountAsync()} countries");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Import failed: {ex.Message}");
        throw;
    }
}
using System.Threading.Tasks;
using IronXL;
using Microsoft.EntityFrameworkCore;

public async Task ImportGDPDataAsync()
{
    try
    {
        // Load Excel file
        var workBook = WorkBook.Load(@"Spreadsheets\GDP.xlsx");
        var workSheet = workBook.GetWorkSheet("GDPByCountry");

        using (var context = new CountryContext())
        {
            // Ensure database exists
            await context.Database.EnsureCreatedAsync();

            // Clear existing data (optional)
            await context.Database.ExecuteSqlRawAsync("DELETE FROM Countries");

            // Import data with progress tracking
            int totalRows = 213;
            for (int row = 2; row <= totalRows; row++)
            {
                // Read country data
                var countryName = workSheet[$"A{row}"].StringValue;
                var gdpValue = workSheet[$"B{row}"].DecimalValue;

                // Skip empty rows
                if (string.IsNullOrWhiteSpace(countryName))
                    continue;

                // Create and add entity
                var country = new Country
                {
                    Name = countryName.Trim(),
                    GDP = gdpValue * 1_000_000 // Convert to actual value if in millions
                };

                await context.Co/untries.AddAsync(country);

                // Save in batches for performance
                if (row % 50 == 0)
                {
                    await context.SaveChangesAsync();
                    Console.WriteLine($"Imported {row - 1} of {totalRows} countries");
                }
            }

            // Save remaining records
            await context.SaveChangesAsync();
            Console.WriteLine($"Successfully imported {await context.Co/untries.CountAsync()} countries");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Import failed: {ex.Message}");
        throw;
    }
}
Imports System.Threading.Tasks
Imports IronXL
Imports Microsoft.EntityFrameworkCore

Public Async Function ImportGDPDataAsync() As Task
    Try
        ' Load Excel file
        Dim workBook = WorkBook.Load("Spreadsheets\GDP.xlsx")
        Dim workSheet = workBook.GetWorkSheet("GDPByCountry")

        Using context As New CountryContext()
            ' Ensure database exists
            Await context.Database.EnsureCreatedAsync()

            ' Clear existing data (optional)
            Await context.Database.ExecuteSqlRawAsync("DELETE FROM Countries")

            ' Import data with progress tracking
            Dim totalRows As Integer = 213
            For row As Integer = 2 To totalRows
                ' Read country data
                Dim countryName = workSheet($"A{row}").StringValue
                Dim gdpValue = workSheet($"B{row}").DecimalValue

                ' Skip empty rows
                If String.IsNullOrWhiteSpace(countryName) Then
                    Continue For
                End If

                ' Create and add entity
                Dim country As New Country With {
                    .Name = countryName.Trim(),
                    .GDP = gdpValue * 1_000_000 ' Convert to actual value if in millions
                }

                Await context.Countries.AddAsync(country)

                ' Save in batches for performance
                If row Mod 50 = 0 Then
                    Await context.SaveChangesAsync()
                    Console.WriteLine($"Imported {row - 1} of {totalRows} countries")
                End If
            Next

            ' Save remaining records
            Await context.SaveChangesAsync()
            Console.WriteLine($"Successfully imported {Await context.Countries.CountAsync()} countries")
        End Using
    Catch ex As Exception
        Console.WriteLine($"Import failed: {ex.Message}")
        Throw
    End Try
End Function
$vbLabelText   $csharpLabel

Wie kann ich API-Daten in Excel-Tabellen importieren?

Kombinieren Sie IronXL mit HTTP-Clients, um Tabellenkalkulationen mit Live-API-Daten zu füllen. In diesem Beispiel wird RestClient.Net verwendet, um Länderdaten abzurufen.

using System;
using System.Co/llections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;
using IronXL;

// Define data model matching API response
public class RestCountry
{
    public string Name { get; set; }
    public long Population { get; set; }
    public string Region { get; set; }
    public string NumericCode { get; set; }
    public List<Language> Languages { get; set; }
}

public class Language
{
    public string Name { get; set; }
    public string NativeName { get; set; }
}

// Fetch and process API data
public async Task ImportCountryDataAsync()
{
    using var httpClient = new HttpClient();

    try
    {
        // Call REST API
        var response = await httpClient.GetStringAsync("https://restcountries.com/v3.1/all");
        var countries = JsonConvert.DeserializeObject<List<RestCountry>>(response);

        // Create new workbook
        var workBook = WorkBook.Create(ExcelFileFormat.XLSX);
        var workSheet = workBook.CreateWorkSheet("Countries");

        // Add headers with styling
        string[] headers = { "Country", "Population", "Region", "Code", "Language 1", "Language 2", "Language 3" };
        for (int col = 0; col < headers.Length; col++)
        {
            var headerCell = workSheet[0, col];
            headerCell.Value = headers[col];
            headerCell.Style.Font.Bold = true;
            headerCell.Style.SetBackgroundColor("#366092");
            headerCell.Style.Font.Co/lor = "#FFFFFF";
        }

        // Import country data
        await ProcessCountryData(countries, workSheet);

        // Save workbook
        workBook.SaveAs("CountriesFromAPI.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"API import failed: {ex.Message}");
    }
}
using System;
using System.Co/llections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;
using IronXL;

// Define data model matching API response
public class RestCountry
{
    public string Name { get; set; }
    public long Population { get; set; }
    public string Region { get; set; }
    public string NumericCode { get; set; }
    public List<Language> Languages { get; set; }
}

public class Language
{
    public string Name { get; set; }
    public string NativeName { get; set; }
}

// Fetch and process API data
public async Task ImportCountryDataAsync()
{
    using var httpClient = new HttpClient();

    try
    {
        // Call REST API
        var response = await httpClient.GetStringAsync("https://restcountries.com/v3.1/all");
        var countries = JsonConvert.DeserializeObject<List<RestCountry>>(response);

        // Create new workbook
        var workBook = WorkBook.Create(ExcelFileFormat.XLSX);
        var workSheet = workBook.CreateWorkSheet("Countries");

        // Add headers with styling
        string[] headers = { "Country", "Population", "Region", "Code", "Language 1", "Language 2", "Language 3" };
        for (int col = 0; col < headers.Length; col++)
        {
            var headerCell = workSheet[0, col];
            headerCell.Value = headers[col];
            headerCell.Style.Font.Bold = true;
            headerCell.Style.SetBackgroundColor("#366092");
            headerCell.Style.Font.Co/lor = "#FFFFFF";
        }

        // Import country data
        await ProcessCountryData(countries, workSheet);

        // Save workbook
        workBook.SaveAs("CountriesFromAPI.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"API import failed: {ex.Message}");
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Net.Http
Imports System.Threading.Tasks
Imports Newtonsoft.Json
Imports IronXL

' Define data model matching API response
Public Class RestCountry
    Public Property Name As String
    Public Property Population As Long
    Public Property Region As String
    Public Property NumericCode As String
    Public Property Languages As List(Of Language)
End Class

Public Class Language
    Public Property Name As String
    Public Property NativeName As String
End Class

' Fetch and process API data
Public Async Function ImportCountryDataAsync() As Task
    Using httpClient As New HttpClient()

        Try
            ' Call REST API
            Dim response As String = Await httpClient.GetStringAsync("https://restcountries.com/v3.1/all")
            Dim countries As List(Of RestCountry) = JsonConvert.DeserializeObject(Of List(Of RestCountry))(response)

            ' Create new workbook
            Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
            Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Countries")

            ' Add headers with styling
            Dim headers As String() = {"Country", "Population", "Region", "Code", "Language 1", "Language 2", "Language 3"}
            For col As Integer = 0 To headers.Length - 1
                Dim headerCell = workSheet(0, col)
                headerCell.Value = headers(col)
                headerCell.Style.Font.Bold = True
                headerCell.Style.SetBackgroundColor("#366092")
                headerCell.Style.Font.Color = "#FFFFFF"
            Next

            ' Import country data
            Await ProcessCountryData(countries, workSheet)

            ' Save workbook
            workBook.SaveAs("CountriesFromAPI.xlsx")
        Catch ex As Exception
            Console.WriteLine($"API import failed: {ex.Message}")
        End Try
    End Using
End Function
$vbLabelText   $csharpLabel

Die API gibt JSON-Daten in diesem Format zurück:

JSON-Antwortstruktur, die Länderdaten mit verschachtelten Spracharrays anzeigt Beispiel für eine JSON-Antwort der REST Countries API, die hierarchische Länderinformationen anzeigt.

Verarbeiten und schreiben Sie die API-Daten in Excel:

private async Task ProcessCountryData(List<RestCountry> countries, WorkSheet workSheet)
{
    for (int i = 0; i < countries.Co/unt; i++)
    {
        var country = countries[i];
        int row = i + 1; // Start from row 1 (after headers)

        // Write basic country data
        workSheet[$"A{row}"].Value = country.Name;
        workSheet[$"B{row}"].Value = country.Population;
        workSheet[$"C{row}"].Value = country.Region;
        workSheet[$"D{row}"].Value = country.NumericCode;

        // Format population with thousands separator
        workSheet[$"B{row}"].FormatString = "#,##0";

        // Add up to 3 languages
        for (int langIndex = 0; langIndex < Math.Min(3, country.Languages?.Count ?? 0); langIndex++)
        {
            var language = country.Languages[langIndex];
            string columnLetter = ((char)('E' + langIndex)).ToString();
            workSheet[$"{columnLetter}{row}"].Value = language.Name;
        }

        // Add conditional formatting for regions
        if (country.Region == "Europe")
        {
            workSheet[$"C{row}"].Style.SetBackgroundColor("#E6F3FF");
        }
        else if (country.Region == "Asia")
        {
            workSheet[$"C{row}"].Style.SetBackgroundColor("#FFF2E6");
        }

        // Show progress every 50 countries
        if (i % 50 == 0)
        {
            Console.WriteLine($"Processed {i} of {countries.Co/unt} countries");
        }
    }

    // Auto-size all columns
    for (int col = 0; col < 7; col++)
    {
        workSheet.AutoSizeColumn(col);
    }
}
private async Task ProcessCountryData(List<RestCountry> countries, WorkSheet workSheet)
{
    for (int i = 0; i < countries.Co/unt; i++)
    {
        var country = countries[i];
        int row = i + 1; // Start from row 1 (after headers)

        // Write basic country data
        workSheet[$"A{row}"].Value = country.Name;
        workSheet[$"B{row}"].Value = country.Population;
        workSheet[$"C{row}"].Value = country.Region;
        workSheet[$"D{row}"].Value = country.NumericCode;

        // Format population with thousands separator
        workSheet[$"B{row}"].FormatString = "#,##0";

        // Add up to 3 languages
        for (int langIndex = 0; langIndex < Math.Min(3, country.Languages?.Count ?? 0); langIndex++)
        {
            var language = country.Languages[langIndex];
            string columnLetter = ((char)('E' + langIndex)).ToString();
            workSheet[$"{columnLetter}{row}"].Value = language.Name;
        }

        // Add conditional formatting for regions
        if (country.Region == "Europe")
        {
            workSheet[$"C{row}"].Style.SetBackgroundColor("#E6F3FF");
        }
        else if (country.Region == "Asia")
        {
            workSheet[$"C{row}"].Style.SetBackgroundColor("#FFF2E6");
        }

        // Show progress every 50 countries
        if (i % 50 == 0)
        {
            Console.WriteLine($"Processed {i} of {countries.Co/unt} countries");
        }
    }

    // Auto-size all columns
    for (int col = 0; col < 7; col++)
    {
        workSheet.AutoSizeColumn(col);
    }
}
Imports System
Imports System.Threading.Tasks

Private Async Function ProcessCountryData(countries As List(Of RestCountry), workSheet As WorkSheet) As Task
    For i As Integer = 0 To countries.Count - 1
        Dim country = countries(i)
        Dim row As Integer = i + 1 ' Start from row 1 (after headers)

        ' Write basic country data
        workSheet($"A{row}").Value = country.Name
        workSheet($"B{row}").Value = country.Population
        workSheet($"C{row}").Value = country.Region
        workSheet($"D{row}").Value = country.NumericCode

        ' Format population with thousands separator
        workSheet($"B{row}").FormatString = "#,##0"

        ' Add up to 3 languages
        For langIndex As Integer = 0 To Math.Min(3, If(country.Languages?.Count, 0)) - 1
            Dim language = country.Languages(langIndex)
            Dim columnLetter As String = ChrW(AscW("E"c) + langIndex).ToString()
            workSheet($"{columnLetter}{row}").Value = language.Name
        Next

        ' Add conditional formatting for regions
        If country.Region = "Europe" Then
            workSheet($"C{row}").Style.SetBackgroundColor("#E6F3FF")
        ElseIf country.Region = "Asia" Then
            workSheet($"C{row}").Style.SetBackgroundColor("#FFF2E6")
        End If

        ' Show progress every 50 countries
        If i Mod 50 = 0 Then
            Console.WriteLine($"Processed {i} of {countries.Count} countries")
        End If
    Next

    ' Auto-size all columns
    For col As Integer = 0 To 6
        workSheet.AutoSizeColumn(col)
    Next
End Function
$vbLabelText   $csharpLabel

Objektreferenz und Ressourcen

Entdecken Sie die umfassende IronXL-API Referenz für detaillierte Klassendokumentation und erweiterte Funktionen.

Weitere Tutorials für Excel-Funktionen:

Zusammenfassung

IronXl.Excel ist eine umfassende .NET-Bibliothek zum Lesen und Bearbeiten von Excel-Dateien in verschiedenen Formaten. Sie läuft eigenständig, ohne dass Microsoft Excel oder Interop installiert sein muss.

Für die Bearbeitung von Tabellenkalkulationen in der Cloud können Sie auch die Google Sheets API Client Library for .NET in Betracht ziehen, die die lokalen Dateifunktionen von IronXL for .NET ergänzt.

Sind Sie bereit, Excel-Automatisierung in Ihren C#-Projekten zu implementieren? Laden Sie IronXL herunter oder informieren Sie sich über Lizenzoptionen für den produktiven Einsatz.

Häufig gestellte Fragen

Wie kann ich Excel-Dateien in C# lesen, ohne Microsoft Office zu verwenden?

Sie können IronXL verwenden, um Excel-Dateien in C# ohne Microsoft Office zu lesen. IronXL bietet Methoden wie WorkBook.Load(), um Excel-Dateien zu öffnen, und ermöglicht es Ihnen, Daten mit intuitiver Syntax zuzugreifen und zu manipulieren.

Welche Formate von Excel-Dateien können mit C# gelesen werden?

Mit IronXL können Sie die Dateiformate XLS und XLSX in C# lesen. Die Bibliothek erkennt das Dateiformat automatisch und verarbeitet es entsprechend mit der WorkBook.Load()-Methode.

Wie validiere ich Excel-Daten in C#?

IronXL ermöglicht es Ihnen, Excel-Daten programmgesteuert in C# zu validieren, indem Sie durch Zellen iterieren und Logik wie reguläre Ausdrücke für E-Mails oder benutzerdefinierte Validierungsfunktionen anwenden. Sie können Berichte mit CreateWorkSheet() generieren.

Wie kann ich Daten von Excel in eine SQL-Datenbank mit C# exportieren?

Um Daten von Excel in eine SQL-Datenbank zu exportieren, verwenden Sie IronXL, um Excel-Daten mit den Methoden WorkBook.Load() und GetWorkSheet() zu lesen, und iterieren Sie dann durch die Zellen, um Daten mit Entity Framework in Ihre Datenbank zu übertragen.

Kann ich Excel-Funktionalität mit ASP.NET Core-Anwendungen integrieren?

Ja, IronXL unterstützt die Integration mit ASP.NET Core-Anwendungen. Sie können die WorkBook und WorkSheet Klassen in Ihren Controllern verwenden, um Excel-Datei-Uploads zu verarbeiten, Berichte zu erstellen und mehr.

Ist es möglich, Excel-Tabellenkalkulationen mit C# Formeln hinzuzufügen?

IronXL ermöglicht es Ihnen, Excel-Tabellenkalkulationen programmgesteuert Formeln hinzuzufügen. Sie können eine Formel mit der Formula-Eigenschaft festlegen, wie cell.Formula = "=SUM(A1:A10)", und mit workBook.EvaluateAll() Ergebnisse berechnen.

Wie fülle ich Excel-Dateien mit Daten aus einer REST-API?

Um Excel-Dateien mit Daten aus einer REST-API zu füllen, verwenden Sie IronXL zusammen mit einem HTTP-Client, um API-Daten abzurufen, und schreiben Sie diese dann mit Methoden wie sheet["A1"].Value in Excel. IronXL verwaltet das Excel-Format und die Struktur.

Welche Lizenzoptionen gibt es für die Verwendung von Excel-Bibliotheken in Produktionsumgebungen?

IronXL bietet eine kostenlose Testversion für Entwicklungszwecke an, während Produktionslizenzen ab 749 $ beginnen. Diese Lizenzen beinhalten dedizierten technischen Support und erlauben den Einsatz in verschiedenen Umgebungen ohne zusätzliche Office-Lizenzen.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen
Bereit anzufangen?
Nuget Downloads 2,052,917 | Version: 2026.6 just released
Still Scrolling Icon

Scrollst du immer noch?

Sie brauchen schnell einen Beweis? PM > Install-Package IronXL.Excel
Führen Sie ein Beispiel aus und sehen Sie zu, wie Ihre Daten zu einer Tabellenkalkulation werden.