Cómo leer un archivo CSV en C# usando IronXL

¿Qué hace que IronXL sea diferente de los enfoques StreamReader?

IronXL convierte la lectura de archivos CSV de un dolor de cabeza de análisis a operaciones simples. A diferencia de las operaciones de división manual o los enfoques básicos StreamReader, IronXL maneja automáticamente casos extremos como comas incrustadas, nuevas líneas y columnas separadas por delimitadores inusuales. El robusto API de la biblioteca elimina errores comunes de análisis que plagan los enfoques tradicionales, como el manejo incorrecto de campos entrecomillados o valores de celda de varias líneas.

Al desplegar en entornos con contenedores, la arquitectura autónoma de IronXL significa que no necesitas preocuparte por instalar dependencias adicionales o lidiar con peculiaridades específicas del manejo de archivos de la plataforma. La biblioteca maneja límites de tamaño de archivo de manera elegante y proporciona un comportamiento consistente ya sea ejecutándose en una estación de trabajo de desarrollador o en un pod de Kubernetes.

¿Cómo maneja IronXL la implementación multiplataforma?

La biblioteca opera independientemente de Microsoft Office, lo que la hace perfecta para entornos de servidores y despliegues en la nube. Ya sea implementando en Windows, Linux, macOS, Azure o AWS, IronXL ofrece resultados consistentes en todas las plataformas. Esta compatibilidad multiplataforma, combinada con su API intuitiva, lo convierte en la elección ideal para aplicaciones modernas en C# que requieren un análisis de CSV confiable.

Para los ingenieros DevOps, la compatibilidad con Linux y el soporte para macOS de IronXL significa que puedes estandarizar en una sola biblioteca en toda tu línea de despliegue. La mínima huella de recursos de la biblioteca y su uso eficiente de memoria garantizan que tus contenedores permanezcan ligeros y receptivos, incluso al procesar archivos CSV grandes.

¿Por qué es importante la conversión de CSV a Excel?

IronXL trata los archivos CSV como ciudadanos de primera clase junto a los formatos Excel, permitiendo transiciones fluidas entre tipos de archivos sin pérdida de datos o problemas de formato. Esta capacidad de conversión es crucial para pipelines de reportes automatizados donde los datos CSV se transforman en reportes Excel refinados listos para la revisión de los interesados.

Más allá de la simple lectura de CSV, IronXL también admite la escritura de archivos CSV desde cero usando C#. Asegúrate de consultar nuestra guía práctica para aprender más sobre esto. Esto lo convierte en la biblioteca perfecta para todas tus necesidades de CSV, capaz de todo, desde leer y crear archivos CSV hasta convertirlos a cualquier formato soportado.

¿Cuál es el método de instalación más rápido?

Instalar IronXL lleva solo unos momentos a través del Gestor de Paquetes NuGet de Visual Studio. Abre tu proyecto, haz clic derecho en Referencias en el Explorador de Soluciones y selecciona "Administrar paquetes NuGet". Busca "IronXL.Excel" y haz clic en "Instalar". Para implementaciones en contenedores, agrega IronXL a tu archivo de proyecto:

<PackageReference Include="IronXL.Excel" Version="2025.*" />

<PackageReference Include="IronXL.Excel" Version="2025.*" />

Para una guía de instalación detallada, incluyendo instrucciones de configuración de Docker, visita la documentación de instalación de IronXL. La biblioteca soporta .NET MAUI, Blazor, y aplicaciones .NET tradicionales igualmente bien.

¿Cómo leo mi primer archivo CSV?

Una vez instalado, leer tu primer archivo CSV requiere un código fuente mínimo, como se muestra en el siguiente ejemplo:

using IronXL;

// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a specific cell
string cellValue = sheet["A1"].StringValue;

// Iterate through rows
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.WriteLine(cell.StringValue);
    }
}

// Apply aggregate functions
decimal total = sheet["B:B"].Sum();
decimal average = sheet["B:B"].Avg();

using IronXL;

// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a specific cell
string cellValue = sheet["A1"].StringValue;

// Iterate through rows
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.WriteLine(cell.StringValue);
    }
}

// Apply aggregate functions
decimal total = sheet["B:B"].Sum();
decimal average = sheet["B:B"].Avg();

Imports IronXL

' Load CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Read a specific cell
Dim cellValue As String = sheet("A1").StringValue

' Iterate through rows
For Each row In sheet.Rows
    For Each cell In row
        Console.WriteLine(cell.StringValue)
    Next
Next

' Apply aggregate functions
Dim total As Decimal = sheet("B:B").Sum()
Dim average As Decimal = sheet("B:B").Avg()

¿Qué sucede detrás de escena durante la carga de CSV?

En este ejemplo, el lector accede a los datos CSV como matrices de cadenas. El método WorkBook.LoadCSV maneja la identificación del encabezado, crea una tabla de datos y realiza un análisis eficiente en memoria, simplificando la gestión de tu estructura de datos. La biblioteca detecta automáticamente la codificación (soporte para UTF-8, UTF-16, ASCII) y gestiona diversos formatos CSV sin configuración manual.

¿Por qué importan los diferentes delimitadores en producción?

Los archivos CSV del mundo real no siempre usan comas. Punto y coma, tuberías y tabulaciones son alternativas comunes, especialmente en conjuntos de datos internacionales donde las comas se utilizan como separadores decimales. IronXL maneja elegantemente cualquier delimitador a través de sus opciones de carga flexibles, asegurando que sus aplicaciones contenidas puedan procesar archivos de diversas fuentes sin modificación.

¿Cómo configuro delimitadores personalizados?

using IronXL;

// Load CSV with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("european-data.csv", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: ";");

// Load tab-separated values
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: "\t");

// Load pipe-delimited files
WorkBook pipeWorkbook = WorkBook.LoadCSV("legacy_export.txt", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: "|");

// Access data normally
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

// Apply math functions for analysis
decimal maxValue = sheet["C:C"].Max();
decimal minValue = sheet["C:C"].Min();

using IronXL;

// Load CSV with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("european-data.csv", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: ";");

// Load tab-separated values
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: "\t");

// Load pipe-delimited files
WorkBook pipeWorkbook = WorkBook.LoadCSV("legacy_export.txt", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: "|");

// Access data normally
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

// Apply math functions for analysis
decimal maxValue = sheet["C:C"].Max();
decimal minValue = sheet["C:C"].Min();

Imports IronXL

' Load CSV with semicolon delimiter
Dim workbook As WorkBook = WorkBook.LoadCSV("european-data.csv", 
    fileFormat:=ExcelFileFormat.XLSX, 
    listDelimiter:=";")

' Load tab-separated values
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv", 
    fileFormat:=ExcelFileFormat.XLSX, 
    listDelimiter:=vbTab)

' Load pipe-delimited files
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("legacy_export.txt", 
    fileFormat:=ExcelFileFormat.XLSX, 
    listDelimiter:="|")

' Access data normally
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim totalSales As Decimal = sheet("B2:B10").Sum()

' Apply math functions for analysis
Dim maxValue As Decimal = sheet("C:C").Max()
Dim minValue As Decimal = sheet("C:C").Min()

¿Qué pasa con la preservación de tipos de datos?

El parámetro listDelimiter acepta cualquier cadena, proporcionando control total sobre el comportamiento de análisis. IronXL preserva los valores de las columnas y los tipos de datos durante el análisis. Los valores numéricos permanecen como números, las fechas se mantienen como objetos DateTime, y las fórmulas mantienen sus relaciones. Esta preservación automática de tipos elimina el código de conversión manual y reduce errores, lo cual es crítico para mantener la integridad de los datos en pipelines automatizados.

¿Cómo funciona el manejo de errores con datos malformados?

Para archivos con formato inconsistente, el manejo de errores de IronXL maneja graciosamente las filas malformadas sin estrellarse, registrando los problemas para revisión mientras continúa procesando datos válidos. Esta resiliencia es esencial para entornos de producción donde los archivos CSV provienen de fuentes externas con estándares de calidad variables.

¿Por qué mapear CSV a objetos fuertemente tipados?

Transformar filas CSV en objetos fuertemente tipados optimiza el procesamiento de datos y habilita operaciones LINQ. IronXL hace este mapeo sencillo a través de sus métodos de acceso a celdas. El siguiente código muestra cómo crear un analizador CSV simple con un manejo de errores y validación adecuados:

¿Cómo creo un Analizador Tipado Seguro?

using IronXL;

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public DateTime? LastUpdated { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Parse CSV into objects with validation
        var products = new List<Product>();
        WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
        WorkSheet sheet = workbook.DefaultWorkSheet;

        // Skip header row, parse remaining lines
        for (int row = 2; row <= sheet.RowCount; row++)
        {
            try
            {
                var product = new Product
                {
                    Name = sheet[$"A{row}"].StringValue,
                    Price = sheet[$"B{row}"].DecimalValue,
                    Stock = sheet[$"C{row}"].IntValue,
                    LastUpdated = sheet[$"D{row}"].DateTimeValue
                };

                // Validate data
                if (product.Price > 0 && !string.IsNullOrWhiteSpace(product.Name))
                {
                    products.Add(product);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing row {row}: {ex.Message}");
            }
        }

        // Use LINQ for analysis
        var lowStock = products.Where(p => p.Stock < 10).ToList();
        var totalInventoryValue = products.Sum(p => p.Price * p.Stock);

        // Export results to new Excel file
        var reportWorkbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var reportSheet = reportWorkbook.CreateWorkSheet("Low Stock Report");

        // Add headers with formatting
        reportSheet["A1"].Value = "Product Name";
        reportSheet["B1"].Value = "Current Stock";
        reportSheet["C1"].Value = "Unit Price";
        reportSheet["A1:C1"].Style.Font.Bold = true;

        // Add data
        int reportRow = 2;
        foreach (var item in lowStock)
        {
            reportSheet[$"A{reportRow}"].Value = item.Name;
            reportSheet[$"B{reportRow}"].Value = item.Stock;
            reportSheet[$"C{reportRow}"].Value = item.Price;
            reportRow++;
        }

        reportWorkbook.SaveAs("low_stock_alert.xlsx");
    }
}

using IronXL;

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public DateTime? LastUpdated { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Parse CSV into objects with validation
        var products = new List<Product>();
        WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
        WorkSheet sheet = workbook.DefaultWorkSheet;

        // Skip header row, parse remaining lines
        for (int row = 2; row <= sheet.RowCount; row++)
        {
            try
            {
                var product = new Product
                {
                    Name = sheet[$"A{row}"].StringValue,
                    Price = sheet[$"B{row}"].DecimalValue,
                    Stock = sheet[$"C{row}"].IntValue,
                    LastUpdated = sheet[$"D{row}"].DateTimeValue
                };

                // Validate data
                if (product.Price > 0 && !string.IsNullOrWhiteSpace(product.Name))
                {
                    products.Add(product);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing row {row}: {ex.Message}");
            }
        }

        // Use LINQ for analysis
        var lowStock = products.Where(p => p.Stock < 10).ToList();
        var totalInventoryValue = products.Sum(p => p.Price * p.Stock);

        // Export results to new Excel file
        var reportWorkbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var reportSheet = reportWorkbook.CreateWorkSheet("Low Stock Report");

        // Add headers with formatting
        reportSheet["A1"].Value = "Product Name";
        reportSheet["B1"].Value = "Current Stock";
        reportSheet["C1"].Value = "Unit Price";
        reportSheet["A1:C1"].Style.Font.Bold = true;

        // Add data
        int reportRow = 2;
        foreach (var item in lowStock)
        {
            reportSheet[$"A{reportRow}"].Value = item.Name;
            reportSheet[$"B{reportRow}"].Value = item.Stock;
            reportSheet[$"C{reportRow}"].Value = item.Price;
            reportRow++;
        }

        reportWorkbook.SaveAs("low_stock_alert.xlsx");
    }
}

Imports IronXL

Public Class Product
    Public Property Name As String
    Public Property Price As Decimal
    Public Property Stock As Integer
    Public Property LastUpdated As DateTime?
End Class

Module Program
    Sub Main(args As String())
        ' Parse CSV into objects with validation
        Dim products As New List(Of Product)()
        Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet

        ' Skip header row, parse remaining lines
        For row As Integer = 2 To sheet.RowCount
            Try
                Dim product As New Product With {
                    .Name = sheet($"A{row}").StringValue,
                    .Price = sheet($"B{row}").DecimalValue,
                    .Stock = sheet($"C{row}").IntValue,
                    .LastUpdated = sheet($"D{row}").DateTimeValue
                }

                ' Validate data
                If product.Price > 0 AndAlso Not String.IsNullOrWhiteSpace(product.Name) Then
                    products.Add(product)
                End If
            Catch ex As Exception
                Console.WriteLine($"Error parsing row {row}: {ex.Message}")
            End Try
        Next

        ' Use LINQ for analysis
        Dim lowStock = products.Where(Function(p) p.Stock < 10).ToList()
        Dim totalInventoryValue = products.Sum(Function(p) p.Price * p.Stock)

        ' Export results to new Excel file
        Dim reportWorkbook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim reportSheet = reportWorkbook.CreateWorkSheet("Low Stock Report")

        ' Add headers with formatting
        reportSheet("A1").Value = "Product Name"
        reportSheet("B1").Value = "Current Stock"
        reportSheet("C1").Value = "Unit Price"
        reportSheet("A1:C1").Style.Font.Bold = True

        ' Add data
        Dim reportRow As Integer = 2
        For Each item In lowStock
            reportSheet($"A{reportRow}").Value = item.Name
            reportSheet($"B{reportRow}").Value = item.Stock
            reportSheet($"C{reportRow}").Value = item.Price
            reportRow += 1
        Next

        reportWorkbook.SaveAs("low_stock_alert.xlsx")
    End Sub
End Module

¿Qué hace más seguro a la conversión de tipos de IronXL?

Las propiedades de valor tipado de IronXL (StringValue, DecimalValue, IntValue, DateTimeValue) manejan conversiones de forma segura, devolviendo valores predeterminados para datos inválidos en lugar de lanzar excepciones. Esto evita el tedioso trabajo manual de crear una nueva cadena para cada propiedad después de analizar. Este enfoque defensivo asegura aplicaciones robustas que manejan datos imperfectos con elegancia. El soporte de formato de datos de celda de la biblioteca asegura que los valores numéricos mantengan precisión y las fechas conserven su formato.

¿Cómo manejo reglas de negocio complejas?

La biblioteca también admite tipos anulables y lógica de análisis personalizada cuando sea necesario, acomodando reglas de negocio complejas sin sacrificar la simplicidad. Para escenarios avanzados, puede aprovechar la evaluación de fórmulas de IronXL para aplicar cálculos directamente en los datos interpretados, o usar formato condicional para resaltar anomalías en los datos.

¿Cuándo debo convertir CSV a Excel?

Muchos flujos de trabajo empresariales requieren datos CSV en formato Excel para un análisis avanzado, formateo o distribución a las partes interesadas. IronXL hace esta conversión trivial mientras preserva toda la integridad de los datos. El proceso de conversión es especialmente valioso cuando necesita agregar gráficos, aplicar estilos de celda, o implementar validación de datos que los archivos CSV no pueden soportar.

¿Qué tan simple es el proceso de conversión?

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");

// Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx");

// Add advanced formatting before saving
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;

// Apply header styling
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

// Format currency columns
sheet["B:B"].FormatString = "$#,##0.00";

// Add borders to data range
var dataRange = sheet["A1:D100"];
dataRange.Style.Border.SetBorder(BorderType.AllBorders, BorderStyle.Thin, "#000000");

// Autosize columns for better readability
sheet.AutoSizeColumn(0); // Column A
sheet.AutoSizeColumn(1); // Column B
sheet.AutoSizeColumn(2); // Column C
sheet.AutoSizeColumn(3); // Column D

// Add a summary chart
var chart = sheet.CreateChart(ChartType.Column, 10, 5);
chart.AddSeries("B2:B10", "A2:A10");
chart.SetTitle("Monthly Sales Summary");
chart.Plot();

// Add data validation
sheet["E2:E100"].DataValidation.AllowList = new string[] { "Approved", "Pending", "Rejected" };

// Save the enhanced Excel file
csvWorkbook.SaveAs("monthly-report-formatted.xlsx");

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");

// Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx");

// Add advanced formatting before saving
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;

// Apply header styling
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

// Format currency columns
sheet["B:B"].FormatString = "$#,##0.00";

// Add borders to data range
var dataRange = sheet["A1:D100"];
dataRange.Style.Border.SetBorder(BorderType.AllBorders, BorderStyle.Thin, "#000000");

// Autosize columns for better readability
sheet.AutoSizeColumn(0); // Column A
sheet.AutoSizeColumn(1); // Column B
sheet.AutoSizeColumn(2); // Column C
sheet.AutoSizeColumn(3); // Column D

// Add a summary chart
var chart = sheet.CreateChart(ChartType.Column, 10, 5);
chart.AddSeries("B2:B10", "A2:A10");
chart.SetTitle("Monthly Sales Summary");
chart.Plot();

// Add data validation
sheet["E2:E100"].DataValidation.AllowList = new string[] { "Approved", "Pending", "Rejected" };

// Save the enhanced Excel file
csvWorkbook.SaveAs("monthly-report-formatted.xlsx");

' Load CSV file
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("monthly-report.csv")

' Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx")

' Add advanced formatting before saving
Dim sheet As WorkSheet = csvWorkbook.DefaultWorkSheet

' Apply header styling
sheet("A1:D1").Style.Font.Bold = True
sheet("A1:D1").Style.BackgroundColor = "#4472C4"
sheet("A1:D1").Style.Font.Color = "#FFFFFF"

' Format currency columns
sheet("B:B").FormatString = "$#,##0.00"

' Add borders to data range
Dim dataRange = sheet("A1:D100")
dataRange.Style.Border.SetBorder(BorderType.AllBorders, BorderStyle.Thin, "#000000")

' Autosize columns for better readability
sheet.AutoSizeColumn(0) ' Column A
sheet.AutoSizeColumn(1) ' Column B
sheet.AutoSizeColumn(2) ' Column C
sheet.AutoSizeColumn(3) ' Column D

' Add a summary chart
Dim chart = sheet.CreateChart(ChartType.Column, 10, 5)
chart.AddSeries("B2:B10", "A2:A10")
chart.SetTitle("Monthly Sales Summary")
chart.Plot()

' Add data validation
sheet("E2:E100").DataValidation.AllowList = New String() {"Approved", "Pending", "Rejected"}

' Save the enhanced Excel file
csvWorkbook.SaveAs("monthly-report-formatted.xlsx")

¿Qué características de integridad de datos se preservan?

La conversión preserva la precisión numérica, los formatos de fecha y los caracteres especiales que a menudo causan problemas con los métodos de conversión manual. IronXL optimiza automáticamente la estructura del archivo Excel resultante, creando archivos eficientes que se abren rápidamente incluso con grandes conjuntos de datos. La biblioteca mantiene comentarios en las celdas, hipervínculos, e incluso reglas de formato condicional durante la conversión.

¿Cómo habilita esto la presentación de informes automatizados?

Esta capacidad de conversión sin problemas permite canalizaciones de informes automatizados donde los datos CSV de varias fuentes se transforman en informes Excel pulidos listos para la revisión ejecutiva. Puede crear tablas nombradas para una mejor organización de datos, aplicar congelación de paneles para una navegación más fácil, e incluso agregar imágenes como logotipos de la empresa para crear informes con apariencia profesional.

¿Cómo maneja IronXL la internacionalización?

IronXL cuenta con varios avances avanzados que mejoran la confiabilidad del procesamiento de CSV. La biblioteca maneja automáticamente diversas codificaciones de texto (UTF-8, UTF-16, ASCII), asegurando que los valores de cadena internacionales y las columnas se muestren correctamente. Los procesos de transmisión eficientes en memoria permiten manejar archivos CSV grandes sin cargar todos los datos en la RAM al mismo tiempo, crucial para entornos de contenedores con limitaciones de recursos.

Para implementaciones internacionales, IronXL maneja correctamente diferentes formatos de números y representaciones de fechas. Ya sea que tu CSV use notación decimal europea o formatos de fecha americanos, la biblioteca se adapta automáticamente, reduciendo la configuración específica de la implementación.

¿Qué estrategias de manejo de errores debo usar?

Al procesar archivos CSV de fuentes no confiables, envuelve las operaciones en bloques try-catch para mayor seguridad. Para estrategias de manejo de errores completas, revise las guías de solución de problemas de IronXL. Implementa registro para entornos de producción para rastrear métricas de procesamiento e identificar archivos problemáticos:

using IronXL;
using System.Diagnostics;

public class CSVProcessor
{
    private readonly ILogger _logger;

    public async Task<ProcessingResult> ProcessCSVBatch(string[] filePaths)
    {
        var results = new List<FileResult>();
        var stopwatch = Stopwatch.StartNew();

        foreach (var filePath in filePaths)
        {
            try
            {
                var fileStopwatch = Stopwatch.StartNew();
                var workbook = WorkBook.LoadCSV(filePath);
                var sheet = workbook.DefaultWorkSheet;

                // Process data
                var recordCount = sheet.RowCount - 1; // Exclude header
                var processedRecords = 0;

                for (int row = 2; row <= sheet.RowCount; row++)
                {
                    try
                    {
                        // Your processing logic here
                        processedRecords++;
                    }
                    catch (Exception rowEx)
                    {
                        _logger.LogWarning($"Failed to process row {row} in {filePath}: {rowEx.Message}");
                    }
                }

                results.Add(new FileResult
                {
                    FileName = filePath,
                    Success = true,
                    RecordsProcessed = processedRecords,
                    ProcessingTime = fileStopwatch.ElapsedMilliseconds
                });

                _logger.LogInformation($"Processed {filePath}: {processedRecords}/{recordCount} records in {fileStopwatch.ElapsedMilliseconds}ms");
            }
            catch (Exception ex)
            {
                _logger.LogError($"Failed to process {filePath}: {ex.Message}");
                results.Add(new FileResult
                {
                    FileName = filePath,
                    Success = false,
                    Error = ex.Message
                });
            }
        }

        return new ProcessingResult
        {
            FileResults = results,
            TotalProcessingTime = stopwatch.ElapsedMilliseconds,
            SuccessRate = (decimal)results.Count(r => r.Success) / results.Count
        };
    }
}

using IronXL;
using System.Diagnostics;

public class CSVProcessor
{
    private readonly ILogger _logger;

    public async Task<ProcessingResult> ProcessCSVBatch(string[] filePaths)
    {
        var results = new List<FileResult>();
        var stopwatch = Stopwatch.StartNew();

        foreach (var filePath in filePaths)
        {
            try
            {
                var fileStopwatch = Stopwatch.StartNew();
                var workbook = WorkBook.LoadCSV(filePath);
                var sheet = workbook.DefaultWorkSheet;

                // Process data
                var recordCount = sheet.RowCount - 1; // Exclude header
                var processedRecords = 0;

                for (int row = 2; row <= sheet.RowCount; row++)
                {
                    try
                    {
                        // Your processing logic here
                        processedRecords++;
                    }
                    catch (Exception rowEx)
                    {
                        _logger.LogWarning($"Failed to process row {row} in {filePath}: {rowEx.Message}");
                    }
                }

                results.Add(new FileResult
                {
                    FileName = filePath,
                    Success = true,
                    RecordsProcessed = processedRecords,
                    ProcessingTime = fileStopwatch.ElapsedMilliseconds
                });

                _logger.LogInformation($"Processed {filePath}: {processedRecords}/{recordCount} records in {fileStopwatch.ElapsedMilliseconds}ms");
            }
            catch (Exception ex)
            {
                _logger.LogError($"Failed to process {filePath}: {ex.Message}");
                results.Add(new FileResult
                {
                    FileName = filePath,
                    Success = false,
                    Error = ex.Message
                });
            }
        }

        return new ProcessingResult
        {
            FileResults = results,
            TotalProcessingTime = stopwatch.ElapsedMilliseconds,
            SuccessRate = (decimal)results.Count(r => r.Success) / results.Count
        };
    }
}

Imports IronXL
Imports System.Diagnostics

Public Class CSVProcessor
    Private ReadOnly _logger As ILogger

    Public Async Function ProcessCSVBatch(filePaths As String()) As Task(Of ProcessingResult)
        Dim results As New List(Of FileResult)()
        Dim stopwatch = Stopwatch.StartNew()

        For Each filePath In filePaths
            Try
                Dim fileStopwatch = Stopwatch.StartNew()
                Dim workbook = WorkBook.LoadCSV(filePath)
                Dim sheet = workbook.DefaultWorkSheet

                ' Process data
                Dim recordCount = sheet.RowCount - 1 ' Exclude header
                Dim processedRecords = 0

                For row As Integer = 2 To sheet.RowCount
                    Try
                        ' Your processing logic here
                        processedRecords += 1
                    Catch rowEx As Exception
                        _logger.LogWarning($"Failed to process row {row} in {filePath}: {rowEx.Message}")
                    End Try
                Next

                results.Add(New FileResult With {
                    .FileName = filePath,
                    .Success = True,
                    .RecordsProcessed = processedRecords,
                    .ProcessingTime = fileStopwatch.ElapsedMilliseconds
                })

                _logger.LogInformation($"Processed {filePath}: {processedRecords}/{recordCount} records in {fileStopwatch.ElapsedMilliseconds}ms")
            Catch ex As Exception
                _logger.LogError($"Failed to process {filePath}: {ex.Message}")
                results.Add(New FileResult With {
                    .FileName = filePath,
                    .Success = False,
                    .Error = ex.Message
                })
            End Try
        Next

        Return New ProcessingResult With {
            .FileResults = results,
            .TotalProcessingTime = stopwatch.ElapsedMilliseconds,
            .SuccessRate = CDec(results.Count(Function(r) r.Success)) / results.Count
        }
    End Function
End Class

¿Cómo puedo optimizar el rendimiento para conjuntos de datos grandes?

Para un rendimiento óptimo con grandes conjuntos de datos, use operaciones de rango en lugar de acceder a celdas individuales. El motor de fórmulas de IronXL también funciona con datos CSV, permitiendo cálculos sin convertir primero a Excel. Considere estas estrategias de optimización:

• Use rangos nombrados para secciones de datos de acceso frecuente
• Aproveche la gestión de hojas de trabajo para dividir archivos grandes en fragmentos manejables
• Aplique ordenación y filtrado para reducir la carga de procesamiento de datos
• Utilice exportación de DataSet para operaciones masivas de base de datos

¿Por qué es IronXL perfecto para la implementación en contenedores?

El soporte multiplataforma de la biblioteca se extiende más allá de la compatibilidad básica. Los contenedores Docker, los servidores Linux, y las funciones en la nube ejecutan IronXL sin cambios de configuración, lo que lo hace ideal para arquitecturas de microservicios. Las medidas de seguridad de la biblioteca aseguran una operación segura en entornos multi-tenant, mientras que sus opciones de configuración de licencia soportan varios escenarios de implementación.

Para implementaciones en contenedores, la dependencia mínima de IronXL y el uso eficiente de los recursos lo convierten en una excelente opción. La biblioteca no requiere instalaciones de Office, componentes COM, o bibliotecas específicas de la plataforma, simplificando la creación de Dockerfile y reduciendo los tamaños de imagen. Los puntos de verificación de estado pueden incorporar fácilmente operaciones de IronXL para verificar que las capacidades de procesamiento de CSV sigan estando operativas.