StreamReader kann keine Excel-Dateien lesen, da XLSX/XLS-Formate komplexe binäre oder komprimierte XML-Strukturen und kein einfacher Text sind. Verwenden Sie stattdessen die IronXL-Bibliothek, die WorkBook.Load() für das Lesen von Dateien und FromStream() für die Verarbeitung von Memory Streams ohne Excel Interop-Abhängigkeiten bietet.

Viele C#-Entwickler stehen vor einer häufigen Herausforderung beim Versuch, Excel-Tabellenblattdateien zu lesen: ihr zuverlässiger StreamReader, der für Textdateien perfekt funktioniert, versagt unerklärlich bei Excel-Dokumenten. Wenn Sie versucht haben, Excel-Dateien mit StreamReader in C# zu lesen, und dabei unlesbare Zeichen oder Ausnahmen gesehen haben, sind Sie nicht allein. Dieses Tutorial erklärt, warum StreamReader Excel-Dateien nicht direkt handhaben kann und zeigt die richtige Lösung mithilfe von IronXL ohne Excel Interop auf.

Die Verwirrung entsteht oft, weil CSV-Dateien, die Excel öffnen kann, mit StreamReader gut funktionieren. Echte Excel-Dateien (XLSX, XLS) erfordern jedoch einen grundlegend anderen Ansatz. Dieses Verständnis wird Ihnen Stunden der Fehlersuche ersparen und Sie zum richtigen Werkzeug für die Aufgabe führen. Für DevOps-Ingenieure, die Anwendungen in Docker-Containern oder Kubernetes-Umgebungen bereitstellen, wird dies besonders kritisch, da native Abhängigkeiten die Containerisierung verkomplizieren können.

Warum kann StreamReader keine Excel-Dateien lesen?

StreamReader ist für einfache Textdateien konzipiert und liest Zeichen-Daten Zeile für Zeile mit einer bestimmten Kodierung. Excel-Dateien, trotz ihrer tabellarischen Darstellung, sind tatsächlich komplexe binäre oder ZIP-komprimierte XML-Strukturen, die StreamReader nicht interpretieren kann. Moderne XLSX-Dateien folgen dem Office Open XML-Standard, während ältere XLS-Dateien ein proprietäres Binärformat verwenden.

static void Main(string[] args)
{
 // This code will NOT work - demonstrates the problem
 using (StreamReader reader = new StreamReader("ProductData.xlsx"))
 {
    string content = reader.ReadLine(); // Attempts to read Excel as text
    Console.WriteLine(content); // Outputs garbled binary data
 }
}

static void Main(string[] args)
{
 // This code will NOT work - demonstrates the problem
 using (StreamReader reader = new StreamReader("ProductData.xlsx"))
 {
    string content = reader.ReadLine(); // Attempts to read Excel as text
    Console.WriteLine(content); // Outputs garbled binary data
 }
}

Sub Main(ByVal args As String())
    ' This code will NOT work - demonstrates the problem
    Using reader As New StreamReader("ProductData.xlsx")
        Dim content As String = reader.ReadLine() ' Attempts to read Excel as text
        Console.WriteLine(content) ' Outputs garbled binary data
    End Using
End Sub

Sub Main(ByVal args As String())
    ' This code will NOT work - demonstrates the problem
    Using reader As New StreamReader("ProductData.xlsx")
        Dim content As String = reader.ReadLine() ' Attempts to read Excel as text
        Console.WriteLine(content) ' Outputs garbled binary data
    End Using
End Sub

Wenn Sie diesen Codeausschnitt ausführen, werden Ihnen anstelle Ihrer Tabellendaten Binärdaten wie "PK♥♦" oder ähnliche Zeichen angezeigt. Dies geschieht, weil XLSX-Dateien ZIP-Archive sind, die mehrere XML-Dateien enthalten, während XLS-Dateien ein proprietäres binäres Format verwenden. StreamReader erwartet einfachen Text und versucht, diese komplexen Strukturen als Zeichen zu interpretieren, was zu bedeutungslosem Output führt. Bei containerisierten Anwendungen würde der Versuch, native Excel-Bibliotheken oder COM Interop zu verwenden, die Installation von Microsoft Office im Container erfordern, was die Imagegröße und -komplexität drastisch erhöhen würde.

Was passiert, wenn StreamReader versucht, Excel-Dateien zu verarbeiten?

Das folgende Beispiel zeigt eine typische Excel-Datei mit Produktdaten, die wir verarbeiten möchten. Beachten Sie, wie übersichtlich und organisiert die strukturierten Tabellendaten in Excel dargestellt werden:

Warum werden in der Ausgabe verstümmelte Zeichen angezeigt?

Wenn StreamReader versucht, diese Excel-Datei zu verarbeiten, zeigt die Konsolenausgabe das zugrunde liegende Problem auf. Anstelle von lesbaren Daten sehen Sie Binärdaten, da die Dateistruktur nicht als Text interpretiert werden kann:

Moderne Excel-Dateien (XLSX) enthalten mehrere Komponenten: Arbeitsblätter, Stile, gemeinsame Zeichenfolgen und Beziehungen, die alle zusammen verpackt sind. Diese Komplexität erfordert spezialisierte Bibliotheken, die die Excel-Dateistruktur verstehen, und genau hier kommt IronXL ins Spiel. Die Bibliothek bewältigt all diese Komplexitäten intern und bietet gleichzeitig eine einfache API, wodurch sie sich ideal für automatisierte Bereitstellungspipelines eignet, bei denen ein manuelles Eingreifen nicht möglich ist.

Wie liest man Excel-Dateien mit IronXL?

IronXL bietet eine unkomplizierte Lösung zum Lesen von Excel-Dateien in C#. Im Gegensatz zu StreamReader versteht IronXL die interne Struktur von Excel und bietet intuitive Methoden, um auf Ihre Daten zuzugreifen. Die Bibliothek unterstützt Windows, Linux, macOS und Docker-Container und eignet sich daher perfekt für moderne, plattformübergreifende Anwendungen. Für DevOps-Teams bedeutet die Architektur von IronXL ohne Abhängigkeiten, dass keine nativen Bibliotheken oder COM-Komponenten während der Bereitstellung verwaltet werden müssen.

Zuerst installieren Sie IronXL über den NuGet-Paketmanager:

Install-Package IronXL.Excel

So lesen Sie eine Excel-Datei richtig:

using IronXL;
// Load the Excel file
WorkBook workbook = WorkBook.Load("sample.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Read specific cell values
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");
// Read a range of cells
foreach (var cell in worksheet["A1:C5"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

using IronXL;
// Load the Excel file
WorkBook workbook = WorkBook.Load("sample.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Read specific cell values
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");
// Read a range of cells
foreach (var cell in worksheet["A1:C5"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

Imports IronXL

' Load the Excel file
Dim workbook As WorkBook = WorkBook.Load("sample.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Read specific cell values
Dim cellValue As String = worksheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")
' Read a range of cells
For Each cell In worksheet("A1:C5")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

Imports IronXL

' Load the Excel file
Dim workbook As WorkBook = WorkBook.Load("sample.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Read specific cell values
Dim cellValue As String = worksheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")
' Read a range of cells
For Each cell In worksheet("A1:C5")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

Dieser Code lädt Ihre Excel-Datei erfolgreich und ermöglicht einen einfachen Zugriff auf die Zellwerte . Die WorkBook.Load-Methode erkennt automatisch das Dateiformat ( XLSX , XLS , XLSM, CSV ) und übernimmt die gesamte komplexe Datenanalyse intern. Sie können auf Zellen mit der gewohnten Excel-Notation wie "A1" oder auf Bereiche wie "A1:C5" zugreifen, wodurch der Code für jeden, der mit Excel vertraut ist, intuitiv verständlich wird.

Bei containerisierten Bereitstellungen können Sie problemlos Integritätsprüfungs-Endpunkte einbinden, die die Excel-Verarbeitungsfähigkeiten überprüfen:

// Health check endpoint for containerized apps
public async Task<IActionResult> HealthCheck()
{
    try
    {
        // Test Excel functionality
        using var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var sheet = workbook.CreateWorkSheet("HealthCheck");
        sheet["A1"].Value = DateTime.UtcNow;
        
        // Convert to byte array for validation
        var bytes = workbook.ToByteArray();
        return Ok(new { 
            status = "healthy", 
            excelSupport = true,
            timestamp = DateTime.UtcNow 
        });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { 
            status = "unhealthy", 
            error = ex.Message 
        });
    }
}

// Health check endpoint for containerized apps
public async Task<IActionResult> HealthCheck()
{
    try
    {
        // Test Excel functionality
        using var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var sheet = workbook.CreateWorkSheet("HealthCheck");
        sheet["A1"].Value = DateTime.UtcNow;
        
        // Convert to byte array for validation
        var bytes = workbook.ToByteArray();
        return Ok(new { 
            status = "healthy", 
            excelSupport = true,
            timestamp = DateTime.UtcNow 
        });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { 
            status = "unhealthy", 
            error = ex.Message 
        });
    }
}

' Health check endpoint for containerized apps
Public Async Function HealthCheck() As Task(Of IActionResult)
    Try
        ' Test Excel functionality
        Using workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            Dim sheet = workbook.CreateWorkSheet("HealthCheck")
            sheet("A1").Value = DateTime.UtcNow

            ' Convert to byte array for validation
            Dim bytes = workbook.ToByteArray()
            Return Ok(New With {
                .status = "healthy",
                .excelSupport = True,
                .timestamp = DateTime.UtcNow
            })
        End Using
    Catch ex As Exception
        Return StatusCode(503, New With {
            .status = "unhealthy",
            .error = ex.Message
        })
    End Try
End Function

' Health check endpoint for containerized apps
Public Async Function HealthCheck() As Task(Of IActionResult)
    Try
        ' Test Excel functionality
        Using workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            Dim sheet = workbook.CreateWorkSheet("HealthCheck")
            sheet("A1").Value = DateTime.UtcNow

            ' Convert to byte array for validation
            Dim bytes = workbook.ToByteArray()
            Return Ok(New With {
                .status = "healthy",
                .excelSupport = True,
                .timestamp = DateTime.UtcNow
            })
        End Using
    Catch ex As Exception
        Return StatusCode(503, New With {
            .status = "unhealthy",
            .error = ex.Message
        })
    End Try
End Function

Wie liest man Excel aus Memory Streams?

In realen Anwendungen müssen Excel-Dateien oft aus Streams und nicht von Datenträgern verarbeitet werden. Typische Anwendungsfälle sind beispielsweise das Hochladen von Webseiten, das Abrufen von Dateien aus Datenbanken oder die Verarbeitung von Daten aus Cloud-Speichern wie AWS S3 oder Azure Blob Storage . IronXL bewältigt diese Situationen reibungslos:

using IronXL;
using System.IO;
// Read Excel from a memory stream
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");
using (MemoryStream stream = new MemoryStream(fileBytes))
{
    WorkBook workbook = WorkBook.FromStream(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;
    // Process the data
    int rowCount = worksheet.RowCount;
    Console.WriteLine($"The worksheet has {rowCount} rows");
    // Read all data into a DataTable
    var dataTable = worksheet.ToDataTable(false);
    // Display DataTable row count 
    Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");
}

using IronXL;
using System.IO;
// Read Excel from a memory stream
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");
using (MemoryStream stream = new MemoryStream(fileBytes))
{
    WorkBook workbook = WorkBook.FromStream(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;
    // Process the data
    int rowCount = worksheet.RowCount;
    Console.WriteLine($"The worksheet has {rowCount} rows");
    // Read all data into a DataTable
    var dataTable = worksheet.ToDataTable(false);
    // Display DataTable row count 
    Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");
}

Imports IronXL
Imports System.IO

' Read Excel from a memory stream
Dim fileBytes As Byte() = File.ReadAllBytes("ProductData.xlsx")
Using stream As New MemoryStream(fileBytes)
    Dim workbook As WorkBook = WorkBook.FromStream(stream)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
    ' Process the data
    Dim rowCount As Integer = worksheet.RowCount
    Console.WriteLine($"The worksheet has {rowCount} rows")
    ' Read all data into a DataTable
    Dim dataTable = worksheet.ToDataTable(False)
    ' Display DataTable row count 
    Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows")
End Using

Imports IronXL
Imports System.IO

' Read Excel from a memory stream
Dim fileBytes As Byte() = File.ReadAllBytes("ProductData.xlsx")
Using stream As New MemoryStream(fileBytes)
    Dim workbook As WorkBook = WorkBook.FromStream(stream)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
    ' Process the data
    Dim rowCount As Integer = worksheet.RowCount
    Console.WriteLine($"The worksheet has {rowCount} rows")
    ' Read all data into a DataTable
    Dim dataTable = worksheet.ToDataTable(False)
    ' Display DataTable row count 
    Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows")
End Using

Die FromStream-Methode akzeptiert jeden Stream-Typ, sei es ein MemoryStream, FileStream oder Netzwerkstream. Diese Flexibilität ermöglicht die Verarbeitung von Excel-Dateien aus verschiedenen Quellen, ohne sie vorher auf der Festplatte speichern zu müssen. Das Beispiel zeigt außerdem die Konvertierung von Tabellenblattdaten in eine DataTable , die sich nahtlos in Datenbanken und Datenbindungsszenarien integrieren lässt. Bei Microservices-Architekturen minimiert dieser stream-basierte Ansatz die Festplatten-E/A und verbessert die Leistung.

Welche Ergebnisse liefert die Verarbeitung von Speicherströmen?

Wann sollte ich den Objektsender in Excel-Leseszenarien verwenden?

In Fällen, in denen dieser Code im ereignisgesteuerten Programmieren verwendet wird (zum Beispiel beim Umgang mit einem Datei-Upload-Button in Windows Forms oder ASP.NET), beinhaltet die Methodensignatur oft Parameter wie Objekt sender und EventArgs e. Alt-Text zum Bild hinzufügen. Bei containerisierten APIs können Sie Uploads direkt über HTTP-Anfragen verarbeiten:

[HttpPost("upload")]
public async Task<IActionResult> ProcessExcelUpload(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");
    
    using var stream = new MemoryStream();
    await file.CopyToAsync(stream);
    stream.Position = 0;
    
    var workbook = WorkBook.FromStream(stream);
    var worksheet = workbook.DefaultWorkSheet;
    
    // Process and return results
    var data = worksheet.ToDataSet();
    return Ok(new { 
        sheets = workbook.WorkSheets.Count,
        rows = worksheet.RowCount,
        processed = DateTime.UtcNow
    });
}

[HttpPost("upload")]
public async Task<IActionResult> ProcessExcelUpload(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");
    
    using var stream = new MemoryStream();
    await file.CopyToAsync(stream);
    stream.Position = 0;
    
    var workbook = WorkBook.FromStream(stream);
    var worksheet = workbook.DefaultWorkSheet;
    
    // Process and return results
    var data = worksheet.ToDataSet();
    return Ok(new { 
        sheets = workbook.WorkSheets.Count,
        rows = worksheet.RowCount,
        processed = DateTime.UtcNow
    });
}

<HttpPost("upload")>
Public Async Function ProcessExcelUpload(file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file uploaded")
    End If

    Using stream As New MemoryStream()
        Await file.CopyToAsync(stream)
        stream.Position = 0

        Dim workbook = WorkBook.FromStream(stream)
        Dim worksheet = workbook.DefaultWorkSheet

        ' Process and return results
        Dim data = worksheet.ToDataSet()
        Return Ok(New With {
            .sheets = workbook.WorkSheets.Count,
            .rows = worksheet.RowCount,
            .processed = DateTime.UtcNow
        })
    End Using
End Function

<HttpPost("upload")>
Public Async Function ProcessExcelUpload(file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file uploaded")
    End If

    Using stream As New MemoryStream()
        Await file.CopyToAsync(stream)
        stream.Position = 0

        Dim workbook = WorkBook.FromStream(stream)
        Dim worksheet = workbook.DefaultWorkSheet

        ' Process and return results
        Dim data = worksheet.ToDataSet()
        Return Ok(New With {
            .sheets = workbook.WorkSheets.Count,
            .rows = worksheet.RowCount,
            .processed = DateTime.UtcNow
        })
    End Using
End Function

Wie konvertiert man zwischen Excel und CSV?

Während StreamReader CSV-Dateien verarbeiten kann, müssen Sie oft zwischen Excel- und CSV-Formaten konvertieren. IronXL vereinfacht diese Konvertierung, was besonders nützlich für ETL-Pipelines und Datenintegrationsszenarien ist, die in DevOps-Workflows häufig vorkommen:

using IronXL;
// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("data.xlsx");
workbook.SaveAsCsv("output.csv");
// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("input.csv");
csvWorkbook.SaveAs("output.xlsx");
// Export specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("worksheet1.csv");

using IronXL;
// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("data.xlsx");
workbook.SaveAsCsv("output.csv");
// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("input.csv");
csvWorkbook.SaveAs("output.xlsx");
// Export specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("worksheet1.csv");

Imports IronXL

' Load an Excel file and save as CSV
Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
workbook.SaveAsCsv("output.csv")

' Load a CSV file and save as Excel
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("input.csv")
csvWorkbook.SaveAs("output.xlsx")

' Export specific worksheet to CSV
Dim worksheet As WorkSheet = workbook.WorkSheets(0)
worksheet.SaveAsCsv("worksheet1.csv")

Imports IronXL

' Load an Excel file and save as CSV
Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
workbook.SaveAsCsv("output.csv")

' Load a CSV file and save as Excel
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("input.csv")
csvWorkbook.SaveAs("output.xlsx")

' Export specific worksheet to CSV
Dim worksheet As WorkSheet = workbook.WorkSheets(0)
worksheet.SaveAsCsv("worksheet1.csv")

Diese Konvertierungen erhalten Ihre Daten bei gleichzeitiger Änderung des Dateiformats. Beim Konvertieren von Excel in CSV reduziert IronXL standardmäßig die erste Tabellenblattstruktur. Sie können jedoch angeben, welches Tabellenblatt exportiert werden soll. Die Konvertierung von CSV nach Excel erzeugt eine korrekt formatierte Tabelle, die die Datentypen beibehält und zukünftige Formatierungen und Formelergänzungen ermöglicht.

Für automatisierte Datenpipelines können Sie auch in die Formate JSON oder XML exportieren:

// Export Excel to multiple formats for data pipelines
var workbook = WorkBook.Load("report.xlsx");

// Export to JSON for API responses
string jsonData = workbook.ToJson();

// Export to HTML for web display
workbook.SaveAsHtml("report.html");

// Export to XML for integration systems
workbook.SaveAsXml("report.xml");

// Export specific range to DataTable for database insertion
var dataTable = workbook.DefaultWorkSheet["A1:D10"].ToDataTable();

// Export Excel to multiple formats for data pipelines
var workbook = WorkBook.Load("report.xlsx");

// Export to JSON for API responses
string jsonData = workbook.ToJson();

// Export to HTML for web display
workbook.SaveAsHtml("report.html");

// Export to XML for integration systems
workbook.SaveAsXml("report.xml");

// Export specific range to DataTable for database insertion
var dataTable = workbook.DefaultWorkSheet["A1:D10"].ToDataTable();

' Export Excel to multiple formats for data pipelines
Dim workbook = WorkBook.Load("report.xlsx")

' Export to JSON for API responses
Dim jsonData As String = workbook.ToJson()

' Export to HTML for web display
workbook.SaveAsHtml("report.html")

' Export to XML for integration systems
workbook.SaveAsXml("report.xml")

' Export specific range to DataTable for database insertion
Dim dataTable = workbook.DefaultWorkSheet("A1:D10").ToDataTable()

' Export Excel to multiple formats for data pipelines
Dim workbook = WorkBook.Load("report.xlsx")

' Export to JSON for API responses
Dim jsonData As String = workbook.ToJson()

' Export to HTML for web display
workbook.SaveAsHtml("report.html")

' Export to XML for integration systems
workbook.SaveAsXml("report.xml")

' Export specific range to DataTable for database insertion
Dim dataTable = workbook.DefaultWorkSheet("A1:D10").ToDataTable()

Bewährte Verfahren für die Containerbereitstellung

Für DevOps-Ingenieure, die Anwendungen zur Excel-Verarbeitung bereitstellen, bietet IronXL mehrere Vorteile. Hier ist ein produktionsreifes Dockerfile, optimiert für die Excel-Verarbeitung:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

# Install any required system fonts for Excel rendering
RUN apt-get update && apt-get install -y \
    fontconfig \
    libfreetype6 \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["YourApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build

FROM build AS publish
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .

# Set environment variables for IronXL
ENV IRONXL_LICENSE_KEY=${IRONXL_LICENSE_KEY}
ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=false

ENTRYPOINT ["dotnet", "YourApp.dll"]

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

# Install any required system fonts for Excel rendering
RUN apt-get update && apt-get install -y \
    fontconfig \
    libfreetype6 \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["YourApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build

FROM build AS publish
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .

# Set environment variables for IronXL
ENV IRONXL_LICENSE_KEY=${IRONXL_LICENSE_KEY}
ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=false

ENTRYPOINT ["dotnet", "YourApp.dll"]

Dieses Dockerfile stellt sicher, dass Ihre Excel-Verarbeitungsanwendung reibungslos in Containern mit minimalen Abhängigkeiten läuft. Die Lizenzierung erfolgt über Umgebungsvariablen, was die Verwaltung in verschiedenen Bereitstellungsumgebungen vereinfacht.

Was sind die nächsten Schritte für die Excel-Verarbeitung in C#?

Die Unfähigkeit von StreamReader, Excel-Dateien zu verarbeiten, resultiert aus dem grundlegenden Unterschied zwischen einfachem Text und der komplexen Dateistruktur von Excel. Während StreamReader für CSV- und andere Textformate perfekt funktioniert, erfordern echte Excel-Dateien eine spezialisierte Bibliothek wie IronXL, die die binären und XML-Strukturen darin versteht.

IronXL bietet mit seiner intuitiven API, der umfassenden Formatunterstützung und den nahtlosen Stream-Verarbeitungsfunktionen eine Komplettlösung. Egal ob Sie Webanwendungen , Desktop-Software oder Cloud-Dienste entwickeln, IronXL verarbeitet Excel-Dateien zuverlässig auf allen Plattformen. Die Unterstützung der Bibliothek für bedingte Formatierung , Diagramme , Formeln und erweiterte Excel-Funktionen macht sie zu einer Komplettlösung für Enterprise .

Für DevOps-Teams machen die containerfreundliche Architektur von IronXL, die minimalen Systemabhängigkeiten und die soliden Leistungseigenschaften es zu einer idealen Wahl für moderne cloud-native Anwendungen. Die Bibliothek unterstützt horizontale Skalierung , funktioniert nahtlos in Kubernetes-Pods und lässt sich gut in CI/CD-Pipelines integrieren.

Bereit, um mit Excel-Dateien richtig zu arbeiten? Laden Sie die kostenlose Testversion von IronXL herunter , die am besten zu den Anforderungen Ihres Projekts passt. Die Bibliothek bietet flexible Lizenzierungsoptionen, darunter Entwicklungs-, Staging- und Produktionsbereitstellungen, mit Optionen für containerisierte Umgebungen und Cloud-native Anwendungen.