StreamReader nie może odczytywać plików Excel, ponieważ formaty XLSX/XLS to skomplikowane struktury binarne lub skompresowane struktury XML, a nie zwykły tekst. Użyj zamiast tego biblioteki IronXL, która udostępnia WorkBook.Load() do odczytu plików oraz FromStream() do przetwarzania strumieni pamięci bez zależności od Excel Interop.

Wielu programistów C# napotyka wspólny problem podczas próby odczytu arkuszy Excel: ich niezawodny StreamReader, który działa idealnie dla plików tekstowych, tajemniczo zawodzi w przypadku dokumentów Excel. Jeśli próbowałeś odczytać pliki Excel w C# za pomocą StreamReader tylko po to, by zobaczyć nieczytelne znaki lub wyjątki, nie jesteś sam. Ten tutorial wyjaśnia, dlaczego StreamReader nie radzi sobie z plikami Excel bezpośrednio i pokazuje właściwe rozwiązanie z użyciem IronXL bez Excel Interop.

Zamieszanie często wynika z tego, że pliki CSV, które Excel może otworzyć, działają poprawnie z StreamReader. Jednak prawdziwe pliki Excel (XLSX, XLS) wymagają zupełnie innego podejścia. Zrozumienie tej różnicy pozwoli Ci zaoszczędzić wiele godzin na debugowaniu i doprowadzi Cię do wyboru odpowiedniego narzędzia do danego zadania. Dla inżynierów DevOps wdrażających aplikacje w kontenerach Docker lub środowiskach Kubernetes, staje się to szczególnie istotne, ponieważ natywne zależności mogą skomplikować konteneryzację.

Dlaczego StreamReader nie może odczytywać plików Excel?

StreamReader jest przeznaczony do plików tekstowych, odczytując dane znakowe linia po linii za pomocą określonego kodowania. Pliki Excel, mimo wyglądu arkusza kalkulacyjnego, są w rzeczywistości złożonymi strukturami binarnymi lub skompresowanymi ZIP strukturami XML, które StreamReader nie może zinterpretować. Nowoczesne pliki XLSX są zgodne ze standardem Office Open XML, podczas gdy starsze pliki XLS wykorzystują zastrzeżony format binarny.

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

Po uruchomieniu tego fragmentu kodu zamiast danych z arkusza kalkulacyjnego zobaczysz dane binarne, takie jak "PK♥♦" lub podobne znaki. Dzieje się tak, ponieważ pliki XLSX są archiwami ZIP zawierającymi wiele plików XML, podczas gdy pliki XLS wykorzystują zastrzeżony format binarny. StreamReader oczekuje zwykłego tekstu i próbuje zinterpretować te skomplikowane struktury jako znaki, co skutkuje bezsensownym wyjściem. W przypadku aplikacji kontenerowych próba użycia natywnych bibliotek Excel lub COM Interop wymagałaby zainstalowania pakietu Microsoft Office w kontenerze, co znacznie zwiększyłoby rozmiar obrazu i złożoność.

Co się dzieje, gdy StreamReader próbuje przetworzyć pliki Excel?

Poniższy przykład przedstawia typowy plik Excel zawierający dane produktowe, które chcemy przetworzyć. Zwróć uwagę, jak uporządkowane i przejrzyste są dane z arkusza kalkulacyjnego po otwarciu w programie Excel:

Dlaczego w wyniku pojawiają się zniekształcone znaki?

Kiedy StreamReader próbuje przetworzyć ten plik Excel, wyjście konsoli ujawnia podstawowy problem. Zamiast danych, które można odczytać, widzisz zawartość binarną, ponieważ struktura pliku nie może być zinterpretowana jako tekst:

Nowoczesne pliki Excel (XLSX) zawierają wiele elementów: arkusze, style, wspólne ciągi znaków i relacje, a wszystko to w jednym pakiecie. Ta złożoność wymaga specjalistycznych bibliotek, które rozumieją strukturę plików Excel, co prowadzi nas do biblioteki IronXL. Biblioteka wewnętrznie radzi sobie z tymi wszystkimi złożonymi kwestiami, oferując jednocześnie proste API, co czyni ją idealną do zautomatyzowanych procesów wdrażania, gdzie ręczna interwencja nie jest możliwa.

Jak odczytywać pliki Excel za pomocą IronXL?

IronXL zapewnia proste rozwiązanie do odczytu plików Excel w języku C#. W przeciwieństwie do StreamReader, IronXL rozumie wewnętrzną strukturę Excel i oferuje intuicyjne metody dostępu do danych. Biblioteka obsługuje systemy Windows, Linux, macOS oraz kontenery Docker, dzięki czemu idealnie nadaje się do nowoczesnych, wielopłatformowych aplikacji. Dla zespołów DevOps, architektura IronXL bez zależności oznacza brak natywnych bibliotek lub komponentów COM do zarządzania podczas wdrożenia.

Najpierw zainstaluj IronXL za pomocą menedżera pakietów NuGet:

Install-Package IronXL.Excel

Oto jak poprawnie odczytać plik Excel:

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

Ten kod z powodzeniem ładuje plik Excel i zapewnia łatwy dostęp do wartości komórek. Metoda WorkBook.Load automatycznie wykrywa format pliku (XLSX, XLS, XLSM, CSV) i wewnętrznie obsługuje wszystkie złożone operacje parsowania. Dostęp do komórek można uzyskać za pomocą znanej notacji programu Excel, takiej jak "A1", lub zakresów, takich jak "A1:C5", dzięki czemu kod jest intuicyjny dla każdego, kto zna program Excel.

W przypadku wdrożeń kontenerowych można łatwo dołączyć punkty końcowe sprawdzające stan, które weryfikują możliwości przetwarzania programu Excel:

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

Jak odczytywać dane z Excela ze strumieni pamięci?

W rzeczywistych zastosowaniach często konieczne jest przetwarzanie plików Excel z strumieni, a nie z dysku. Typowe scenariusze obejmują obsługę przesyłania plików przez Internet, pobieranie plików z baz danych lub przetwarzanie danych z pamięci masowej w chmurze, takiej jak AWS S3 lub Azure Blob Storage. IronXL płynnie radzi sobie z takimi sytuacjami:

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

Metoda FromStream akceptuje każdy typ strumienia, czy to MemoryStream, FileStream, czy strumień sieciowy. Ta elastyczność pozwala przetwarzać pliki Excel z różnych źródeł bez konieczności ich uprzedniego zapisywania na dysku. Przykład pokazuje również konwersję danych z arkusza do tabeli DataTable, która płynnie integruje się z bazami danych i scenariuszami powiązania danych. W przypadku architektur mikrousługowe to podejście oparte na strumieniach minimalizuje operacje wejścia/wyjścia na dysku i poprawia wydajność.

Jakie wyniki daje przetwarzanie strumienia pamięci?

Kiedy należy używać obiektu sender w scenariuszach odczytu danych w programie Excel?

W przypadkach, gdy ten kod jest używany w programowaniu sterowanym zdarzeniami (np. obsługa przycisku przesyłania plików w Windows Forms lub ASP.NET), sygnatura metody często zawiera parametry, takie jak obiekt sender i EventArgs e. Ten kontekst zapewnia, że logika przetwarzania w Excelu prawidłowo łączy się z wydarzeniami interfejsu użytkownika lub usługi. W przypadku interfejsów API w kontenerach można przetwarzać przesłane dane bezpośrednio z żądań HTTP:

[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

Jak konwertować pliki między formatami Excel i CSV?

Chociaż StreamReader może obsługiwać pliki CSV, często trzeba konwertować między formatami Excel i CSV. IronXL sprawia, że ta konwersja jest prosta, co jest szczególnie przydatne dla kanałów ETL i scenariuszy integracji danych, powszechnych w przepływach pracy DevOps:

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")

Te konwersje pozwalają zachować dane przy zmianie formatu pliku. Podczas konwersji pliku Excel do formatu CSV program IronXL domyślnie spłaszcza pierwszy arkusz, ale można określić, który arkusz ma zostać wyeksportowany. Konwersja z formatu CSV do Excela tworzy poprawnie sformatowany arkusz kalkulacyjny, który zachowuje typy danych i umożliwia przyszłe formatowanie oraz dodawanie formuł.

W przypadku zautomatyzowanych potoków danych można również eksportować do formatów JSON lub XML:

// 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()

Najlepsze praktyki wdrażania kontenerów

Dla inżynierów DevOps wdrażających aplikacje do przetwarzania Excel, IronXL oferuje kilka zalet. Oto gotowy do użycia plik Dockerfile zoptymalizowany pod kątem przetwarzania arkuszy Excel:

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"]

Ten plik Dockerfile zapewnia płynne działanie aplikacji do przetwarzania plików Excel w kontenerach przy minimalnej liczbie zależności. Licencjonowanie odbywa się za pomocą zmiennych środowiskowych, co ułatwia zarządzanie w różnych środowiskach wdrożeniowych.

Jakie są następne kroki dla przetwarzania Excela w C#?

Niezdolność StreamReader do przetwarzania plików Excel wynika z podstawowej różnicy między zwykłym tekstem a złożoną strukturą plików Excel. Chociaż StreamReader działa idealnie dla CSV i innych formatów tekstowych, prawdziwe pliki Excel wymagają specjalizowanej biblioteki, takiej jak IronXL, która rozumie struktury binarne i XML wewnątrz.

IronXL zapewnia kompleksowe rozwiązanie dzięki intuicyjnemu API, obszernej obsłudze formatów i płynnym możliwościom przetwarzania strumieniowego. Niezależnie od tego, czy tworzysz aplikacje internetowe, oprogramowanie desktopowe czy usługi w chmurze, IronXL niezawodnie obsługuje pliki Excel na wszystkich platformach. Obsługa formatowania warunkowego, wykresów, formuł i zaawansowanych funkcji programu Excel sprawia, że biblioteka ta stanowi kompletne rozwiązanie dla aplikacji Enterprise.

Dla zespołów DevOps, architektura IronXL przyjazna kontenerom, minimalne zależności systemowe i solidne charakterystyki wydajności czynią go idealnym wyborem dla nowoczesnych aplikacji chmurowych. Biblioteka obsługuje skalowanie horyzontalne, działa płynnie w podach Kubernetes i dobrze integruje się z potokami CI/CD.

Gotowy, aby zacząć prawidłowo pracować z plikami Excel? Pobierz bezpłatną wersję próbną IronXL, która najlepiej odpowiada potrzebom Twojego projektu. Biblioteka oferuje elastyczne opcje licencjonowania, w tym wdrożenia w środowiskach programistycznych, testowych i produkcyjnych, z opcjami dla środowisk kontenerowych i aplikacji natywnych dla chmury.