Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. .NET Core Excel
USANDO O IRONXL

Instale via .NET CLI (recomendado para pipelines de CI/CD)

Jordi Bardia
Jordi Bardia
Atualizado:

O IronXL permite que desenvolvedores modifiquem células de Excel em aplicações .NET Core usando código C# direto sem precisar do Microsoft Office. Ele suporta manipulação de células, operações de intervalo e implantação no Windows, Linux e macOS.

Por que usar o IronXL para Desenvolvimento Excel no .NET Core?

Trabalhar com Excel no .NET Core é crucial para aplicações empresariais modernas, especialmente em ambientes nativo de nuvem e conteinerizados. A biblioteca IronXL oferece ampla funcionalidade de Excel que opera suavemente através das plataformas sem necessitar de instalações do Microsoft Office. Essa capacidade é particularmente valiosa para engenheiros DevOps que automatizam a geração de relatórios, pipelines de processamento de dados e fluxos de trabalho CI/CD.

Considere um cenário típico: sua equipe precisa gerar relatórios de desempenho mensais de várias fontes de dados, modificar células específicas com base em cálculos, e implantar essa funcionalidade em contêineres Docker em vários ambientes. A automação tradicional do Excel exigiria instalações do Office em cada servidor, criando dores de cabeça de licenciamento e complexidades de implantação. O IronXL elimina essas barreiras, fornecendo uma solução autossuficiente que funciona em qualquer lugar onde suas aplicações .NET Core sejam executadas.

A biblioteca se destaca na criação de planilhas do zero, gerenciamento de planilhas programático, e conversão entre formatos de arquivo sem dependências externas. Esteja você construindo microsserviços, funções serverless ou aplicativos conteinerizados, o IronXL se integra naturalmente aos fluxos de trabalho DevOps modernos.

Por que escolher o IronXL para Processamento de Excel Nativo de Núvem?

Ambientes de nuvem exigem soluções leves e flexíveis. O IronXL entrega ao suportar implantações com Docker, Funções Azure, e AWS Lambda desde o início. A arquitetura da biblioteca garante consumo mínimo de recursos mantendo alta performance, o que é crucial para operações de nuvem custo-efetivas. Você pode trabalhar com Excel sem Interop, tornando as implantações mais limpas e eficientes.

Capacidades Principais para Edição de Excel no .NET Core

Capacidade Descrição
Compatibilidade multiplataforma Suporte nativo para Windows, Linux e macOS
Pronto para contêiner Otimizado para implantações em Docker e Kubernetes
Integração nativa com a nuvem Funciona perfeitamente com plataformas serverless
Sem dependências externas Biblioteca autônoma sem requisitos do Office
Otimizado para desempenho Uso eficiente de memória para operações em larga escala

Como Instalar a Biblioteca IronXL

Começar com o IronXL em seu projeto .NET Core leva apenas alguns minutos. A biblioteca está disponível através de gerenciadores de pacotes padrão e suporta todos os cenários modernos de implantação. Veja como adicionar o IronXL ao seu projeto:

dotnet add package IronXl.Excel

# Or use Package Manager Console in Visual Studio
Install-Package IronXl.Excel

# For specific version installation (useful for reproducible builds)
dotnet add package IronXl.Excel --version 2024.12.0

# Add to your .csproj file for declarative package management
# <PackageReference Include="IronXl.Excel" Version="2024.12.0" />
dotnet add package IronXl.Excel

# Or use Package Manager Console in Visual Studio
Install-Package IronXl.Excel

# For specific version installation (useful for reproducible builds)
dotnet add package IronXl.Excel --version 2024.12.0

# Add to your .csproj file for declarative package management
# <PackageReference Include="IronXl.Excel" Version="2024.12.0" />
SHELL

Configurando Licenciamento para Produção

Após a instalação, configure sua chave de licença para implantações de produção. IronXL oferece opções de licenciamento flexíveis adequadas para diferentes escalas de implantação, desde aplicações em servidor único até soluções empresariais. Para aplicações web, você pode configurar a licença no web.config para gestão centralizada. Considere extensões de licença para escalar suas aplicações e opções de upgrade conforme suas necessidades crescem.

Melhorando o IronXL para Ambientes de Contêiner

Ao implantar em contêineres, considere estas estratégias de otimização que se alinham com melhores práticas de configuração do Docker:

# Dockerfile example for IronXL applications
FROM mcr.microsoft.com/dotnet/runtime:6.0-alpine AS base
WORKDIR /app

# Install required dependencies for Excel processing
RUN apk add --no-cache \
    icu-libs \
    krb5-libs \
    libgcc \
    libintl \
    libssl1.1 \
    libstdc++ \
    zlib

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

FROM build AS publish
RUN dotnet publish "YourProject.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "YourProject.dll"]

Modificando Rapidamente Células de Excel no .NET Core

Aqui está um exemplo prático demonstrando a funcionalidade central. Este código mostra como carregar um arquivo Excel existente e modificar células específicas:

using IronXL;
using System;

class QuickStartExample
{
    static void Main()
    {
        // Load existing Excel file - supports XLSX, XLS, XLSM, XLTX
        WorkBook workBook = WorkBook.Load("sales_report.xlsx");

        // Access the default worksheet (usually first sheet)
        WorkSheet sheet = workBook.DefaultWorkSheet;

        // Modify individual cells with different data types
        sheet["A1"].Value = "Q4 Sales Report";  // String value
        sheet["B2"].Value = DateTime.Now;       // Date value
        sheet["C2"].Value = 158750.50;          // Numeric value

        // Apply formulas for calculations
        sheet["D2"].Formula = "=C2*1.15";       // 15% markup
        sheet["E2"].Formula = "=D2-C2";         // Profit calculation

        // Bulk update a range of cells
        sheet["A5:A15"].Value = "Updated by Automation";

        // Style the header row
        sheet["A1:E1"].Style.Font.Bold = true;
        sheet["A1:E1"].Style.BackgroundColor = "#1F4788";
        sheet["A1:E1"].Style.Font.Color = "#FFFFFF";

        // Save the modified workbook
        workBook.SaveAs("sales_report_updated.xlsx");

        Console.WriteLine("Excel file updated successfully!");
    }
}
using IronXL;
using System;

class QuickStartExample
{
    static void Main()
    {
        // Load existing Excel file - supports XLSX, XLS, XLSM, XLTX
        WorkBook workBook = WorkBook.Load("sales_report.xlsx");

        // Access the default worksheet (usually first sheet)
        WorkSheet sheet = workBook.DefaultWorkSheet;

        // Modify individual cells with different data types
        sheet["A1"].Value = "Q4 Sales Report";  // String value
        sheet["B2"].Value = DateTime.Now;       // Date value
        sheet["C2"].Value = 158750.50;          // Numeric value

        // Apply formulas for calculations
        sheet["D2"].Formula = "=C2*1.15";       // 15% markup
        sheet["E2"].Formula = "=D2-C2";         // Profit calculation

        // Bulk update a range of cells
        sheet["A5:A15"].Value = "Updated by Automation";

        // Style the header row
        sheet["A1:E1"].Style.Font.Bold = true;
        sheet["A1:E1"].Style.BackgroundColor = "#1F4788";
        sheet["A1:E1"].Style.Font.Color = "#FFFFFF";

        // Save the modified workbook
        workBook.SaveAs("sales_report_updated.xlsx");

        Console.WriteLine("Excel file updated successfully!");
    }
}
$vbLabelText   $csharpLabel

Por que Este Padrão é Ideal para Automação?

Este padrão funciona perfeitamente em fluxos de trabalho automatizados porque é determinístico e não requer interação do usuário. Você pode agendar este código para ser executado em um contêiner, acionado por eventos ou cronogramas baseados em tempo, tornando-o ideal para cenários de automação DevOps. A capacidade de abrir planilhas do Excel e editá-las programaticamente permite possibilidades de automação eficazes.

Iniciando um Projeto de Edição de Excel no .NET Core

Construir uma solução confiável de edição de Excel requer uma configuração adequada do projeto. Vamos criar um exemplo completo que demonstra melhores práticas para implantações de produção, incorporando tratamento de erros e logging:

using IronXL;
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public class ExcelProcessor
{
    private readonly ILogger<ExcelProcessor> _logger;
    private readonly string _workingDirectory;

    public ExcelProcessor(ILogger<ExcelProcessor> logger, string workingDirectory)
    {
        _logger = logger;
        _workingDirectory = workingDirectory;
    }

    public async Task ProcessExcelFileAsync(string fileName)
    {
        try
        {
            var filePath = Path.Combine(_workingDirectory, fileName);

            // Validate file exists
            if (!File.Exists(filePath))
            {
                _logger.LogError($"File not found: {filePath}");
                throw new FileNotFoundException("Excel file not found", fileName);
            }

            // Load workbook with error handling
            _logger.LogInformation($"Loading Excel file: {fileName}");
            WorkBook workBook = WorkBook.Load(filePath);

            // Process each worksheet
            foreach (var worksheet in workBook.WorkSheets)
            {
                _logger.LogInformation($"Processing worksheet: {worksheet.Name}");
                await ProcessWorksheetAsync(worksheet);
            }

            // Save with timestamp for version control
            var outputName = $"{Path.GetFileNameWithoutExtension(fileName)}_processed_{DateTime.Now:yyyyMMddHHmmss}.xlsx";
            var outputPath = Path.Combine(_workingDirectory, "output", outputName);

            // Ensure output directory exists
            Directory.CreateDirectory(Path.GetDirectoryName(outputPath));

            workBook.SaveAs(outputPath);
            _logger.LogInformation($"Saved processed file: {outputName}");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"Error processing Excel file: {fileName}");
            throw;
        }
    }

    private async Task ProcessWorksheetAsync(WorkSheet worksheet)
    {
        // Example: Update timestamp in specific cell
        var timestampCell = worksheet["A1"];
        if (timestampCell.StringValue == "Last Updated:")
        {
            worksheet["B1"].Value = DateTime.Now;
            worksheet["B1"].FormatString = "yyyy-MM-dd HH:mm:ss";
        }

        // Example: Process data rows asynchronously
        await Task.Run(() =>
        {
            for (int row = 2; row <= worksheet.RowCount; row++)
            {
                // Skip empty rows
                if (worksheet[$"A{row}"].IsEmpty)
                    continue;

                // Apply business logic
                var quantity = worksheet[$"B{row}"].IntValue;
                var price = worksheet[$"C{row}"].DoubleValue;
                worksheet[$"D{row}"].Value = quantity * price;
                worksheet[$"E{row}"].Formula = $"=D{row}*0.08"; // Tax calculation
            }
        });
    }
}
using IronXL;
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public class ExcelProcessor
{
    private readonly ILogger<ExcelProcessor> _logger;
    private readonly string _workingDirectory;

    public ExcelProcessor(ILogger<ExcelProcessor> logger, string workingDirectory)
    {
        _logger = logger;
        _workingDirectory = workingDirectory;
    }

    public async Task ProcessExcelFileAsync(string fileName)
    {
        try
        {
            var filePath = Path.Combine(_workingDirectory, fileName);

            // Validate file exists
            if (!File.Exists(filePath))
            {
                _logger.LogError($"File not found: {filePath}");
                throw new FileNotFoundException("Excel file not found", fileName);
            }

            // Load workbook with error handling
            _logger.LogInformation($"Loading Excel file: {fileName}");
            WorkBook workBook = WorkBook.Load(filePath);

            // Process each worksheet
            foreach (var worksheet in workBook.WorkSheets)
            {
                _logger.LogInformation($"Processing worksheet: {worksheet.Name}");
                await ProcessWorksheetAsync(worksheet);
            }

            // Save with timestamp for version control
            var outputName = $"{Path.GetFileNameWithoutExtension(fileName)}_processed_{DateTime.Now:yyyyMMddHHmmss}.xlsx";
            var outputPath = Path.Combine(_workingDirectory, "output", outputName);

            // Ensure output directory exists
            Directory.CreateDirectory(Path.GetDirectoryName(outputPath));

            workBook.SaveAs(outputPath);
            _logger.LogInformation($"Saved processed file: {outputName}");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"Error processing Excel file: {fileName}");
            throw;
        }
    }

    private async Task ProcessWorksheetAsync(WorkSheet worksheet)
    {
        // Example: Update timestamp in specific cell
        var timestampCell = worksheet["A1"];
        if (timestampCell.StringValue == "Last Updated:")
        {
            worksheet["B1"].Value = DateTime.Now;
            worksheet["B1"].FormatString = "yyyy-MM-dd HH:mm:ss";
        }

        // Example: Process data rows asynchronously
        await Task.Run(() =>
        {
            for (int row = 2; row <= worksheet.RowCount; row++)
            {
                // Skip empty rows
                if (worksheet[$"A{row}"].IsEmpty)
                    continue;

                // Apply business logic
                var quantity = worksheet[$"B{row}"].IntValue;
                var price = worksheet[$"C{row}"].DoubleValue;
                worksheet[$"D{row}"].Value = quantity * price;
                worksheet[$"E{row}"].Formula = $"=D{row}*0.08"; // Tax calculation
            }
        });
    }
}
$vbLabelText   $csharpLabel

Melhores Práticas para Tratamento de Erros

Um tratamento de erros confiável é crucial para implantações de produção. O exemplo acima demonstra integração de logging e manuseio adequado de exceções, que são essenciais para depurar problemas em ambientes containerizados onde você pode não ter acesso direto ao tempo de execução. Considere implementar medidas de segurança e revisar limites de tamanho de arquivo para seu caso de uso.

Editando o Valor de uma Célula Específica

Vamos explorar diferentes técnicas para modificar valores de células, desde atualizações simples até transformações de dados complexas. IronXL fornece métodos intuitivos para escrever valores em células do Excel enquanto suporta vários tipos de dados e formatos. Você também pode copiar células e limpar conteúdos de células conforme necessário.

using IronXL;
using System;
using System.Linq;
using System.Collections.Generic;

public class CellEditingExamples
{
    public static void DemonstrateVariousCellEdits()
    {
        WorkBook workBook = WorkBook.Load("data.xlsx");
        WorkSheet sheet = workBook.DefaultWorkSheet;

        // 1. Simple value assignment
        sheet["A1"].Value = "Product Name";
        sheet["B1"].Value = 99.99;
        sheet["C1"].Value = true;
        sheet["D1"].Value = DateTime.Now;

        // 2. Using cell references with variables
        int rowIndex = 5;
        string columnLetter = "E";
        sheet[$"{columnLetter}{rowIndex}"].Value = "Dynamic Reference";

        // 3. Setting values with specific formatting
        sheet["F1"].Value = 0.175;
        sheet["F1"].FormatString = "0.00%"; // Display as 17.50%

        // 4. Currency formatting
        sheet["G1"].Value = 1234.56;
        sheet["G1"].FormatString = "$#,##0.00"; // Display as $1,234.56

        // 5. Date formatting variations
        var dateCell = sheet["H1"];
        dateCell.Value = DateTime.Now;
        dateCell.FormatString = "MMM dd, yyyy"; // Display as "Dec 25, 2024"

        // 6. Setting hyperlinks
        sheet["I1"].Value = "Visit Documentation";
        sheet["I1"].Hyperlink = "___PROTECTED_URL_54___";

        // 7. Applying conditional formatting
        foreach (var cell in sheet["J1:J10"])
        {
            cell.Value = new Random().Next(0, 100);
            if (cell.IntValue > 50)
            {
                cell.Style.BackgroundColor = "#90EE90"; // Light green for high values
            }
            else
            {
                cell.Style.BackgroundColor = "#FFB6C1"; // Light red for low values
            }
        }

        // 8. Working with formulas
        sheet["K1"].Formula = "=SUM(B1:B10)";
        sheet["K2"].Formula = "=AVERAGE(B1:B10)";
        sheet["K3"].Formula = "=IF(K2>50,\"Above Average\",\"Below Average\")";

        workBook.SaveAs("data_edited.xlsx");
    }
}
using IronXL;
using System;
using System.Linq;
using System.Collections.Generic;

public class CellEditingExamples
{
    public static void DemonstrateVariousCellEdits()
    {
        WorkBook workBook = WorkBook.Load("data.xlsx");
        WorkSheet sheet = workBook.DefaultWorkSheet;

        // 1. Simple value assignment
        sheet["A1"].Value = "Product Name";
        sheet["B1"].Value = 99.99;
        sheet["C1"].Value = true;
        sheet["D1"].Value = DateTime.Now;

        // 2. Using cell references with variables
        int rowIndex = 5;
        string columnLetter = "E";
        sheet[$"{columnLetter}{rowIndex}"].Value = "Dynamic Reference";

        // 3. Setting values with specific formatting
        sheet["F1"].Value = 0.175;
        sheet["F1"].FormatString = "0.00%"; // Display as 17.50%

        // 4. Currency formatting
        sheet["G1"].Value = 1234.56;
        sheet["G1"].FormatString = "$#,##0.00"; // Display as $1,234.56

        // 5. Date formatting variations
        var dateCell = sheet["H1"];
        dateCell.Value = DateTime.Now;
        dateCell.FormatString = "MMM dd, yyyy"; // Display as "Dec 25, 2024"

        // 6. Setting hyperlinks
        sheet["I1"].Value = "Visit Documentation";
        sheet["I1"].Hyperlink = "___PROTECTED_URL_54___";

        // 7. Applying conditional formatting
        foreach (var cell in sheet["J1:J10"])
        {
            cell.Value = new Random().Next(0, 100);
            if (cell.IntValue > 50)
            {
                cell.Style.BackgroundColor = "#90EE90"; // Light green for high values
            }
            else
            {
                cell.Style.BackgroundColor = "#FFB6C1"; // Light red for low values
            }
        }

        // 8. Working with formulas
        sheet["K1"].Formula = "=SUM(B1:B10)";
        sheet["K2"].Formula = "=AVERAGE(B1:B10)";
        sheet["K3"].Formula = "=IF(K2>50,\"Above Average\",\"Below Average\")";

        workBook.SaveAs("data_edited.xlsx");
    }
}
$vbLabelText   $csharpLabel

Manipulando Diferentes Tipos de Dados com Eficiência

IronXL detecta e converte automaticamente os tipos de dados, mas o formatação explícita garante a exibição adequada. A biblioteca suporta definição de formatos de dados de células para moedas, porcentagens, datas e padrões personalizados. Você pode explorar formatos de números do Excel para opções de formatação avançadas. Além disso, você pode customizar fontes e tamanhos de células, aplicar padrões e cores de fundo, e configurar bordas e alinhamento de células.

Atribuindo Valores a Múltiplas Células

Operações em massa são essenciais para um processamento eficiente do Excel. IronXL oferece efetivas capacidades de seleção de intervalo que facilitam a atualização de várias células simultaneamente. Você também pode adicionar linhas e colunas, inserir novas linhas e colunas, e mesclar células conforme necessário:

using IronXL;
using System;
using System.Diagnostics;

public class BulkCellOperations
{
    public static void PerformBulkUpdates()
    {
        var stopwatch = Stopwatch.StartNew();

        WorkBook workBook = WorkBook.Load("inventory.xlsx");
        WorkSheet sheet = workBook.DefaultWorkSheet;

        // Method 1: Update entire column
        sheet["A:A"].Value = "Updated";
        Console.WriteLine($"Column update: {stopwatch.ElapsedMilliseconds}ms");

        // Method 2: Update specific range
        sheet["B2:B100"].Value = DateTime.Now.ToShortDateString();

        // Method 3: Update entire row
        sheet["1:1"].Style.Font.Bold = true;
        sheet["1:1"].Style.BackgroundColor = "#333333";
        sheet["1:1"].Style.Font.Color = "#FFFFFF";

        // Method 4: Update rectangular range
        sheet["C2:E50"].Formula = "=ROW()*COLUMN()";

        // Method 5: Update non-contiguous ranges efficiently
        var ranges = new[] { "F1:F10", "H1:H10", "J1:J10" };
        foreach (var range in ranges)
        {
            sheet[range].Value = "Batch Update";
            sheet[range].Style.BottomBorder.Type = BorderType.Double;
        }

        // Method 6: Conditional bulk updates
        var dataRange = sheet["K1:K100"];
        foreach (var cell in dataRange)
        {
            // Generate test data
            cell.Value = new Random().Next(1, 1000);

            // Apply conditional formatting based on value
            if (cell.IntValue > 750)
            {
                cell.Style.BackgroundColor = "#00FF00"; // Green for high values
                cell.Style.Font.Bold = true;
            }
            else if (cell.IntValue < 250)
            {
                cell.Style.BackgroundColor = "#FF0000"; // Red for low values
                cell.Style.Font.Color = "#FFFFFF";
            }
        }

        stopwatch.Stop();
        Console.WriteLine($"Total execution time: {stopwatch.ElapsedMilliseconds}ms");

        workBook.SaveAs("inventory_bulk_updated.xlsx");
    }
}
using IronXL;
using System;
using System.Diagnostics;

public class BulkCellOperations
{
    public static void PerformBulkUpdates()
    {
        var stopwatch = Stopwatch.StartNew();

        WorkBook workBook = WorkBook.Load("inventory.xlsx");
        WorkSheet sheet = workBook.DefaultWorkSheet;

        // Method 1: Update entire column
        sheet["A:A"].Value = "Updated";
        Console.WriteLine($"Column update: {stopwatch.ElapsedMilliseconds}ms");

        // Method 2: Update specific range
        sheet["B2:B100"].Value = DateTime.Now.ToShortDateString();

        // Method 3: Update entire row
        sheet["1:1"].Style.Font.Bold = true;
        sheet["1:1"].Style.BackgroundColor = "#333333";
        sheet["1:1"].Style.Font.Color = "#FFFFFF";

        // Method 4: Update rectangular range
        sheet["C2:E50"].Formula = "=ROW()*COLUMN()";

        // Method 5: Update non-contiguous ranges efficiently
        var ranges = new[] { "F1:F10", "H1:H10", "J1:J10" };
        foreach (var range in ranges)
        {
            sheet[range].Value = "Batch Update";
            sheet[range].Style.BottomBorder.Type = BorderType.Double;
        }

        // Method 6: Conditional bulk updates
        var dataRange = sheet["K1:K100"];
        foreach (var cell in dataRange)
        {
            // Generate test data
            cell.Value = new Random().Next(1, 1000);

            // Apply conditional formatting based on value
            if (cell.IntValue > 750)
            {
                cell.Style.BackgroundColor = "#00FF00"; // Green for high values
                cell.Style.Font.Bold = true;
            }
            else if (cell.IntValue < 250)
            {
                cell.Style.BackgroundColor = "#FF0000"; // Red for low values
                cell.Style.Font.Color = "#FFFFFF";
            }
        }

        stopwatch.Stop();
        Console.WriteLine($"Total execution time: {stopwatch.ElapsedMilliseconds}ms");

        workBook.SaveAs("inventory_bulk_updated.xlsx");
    }
}
$vbLabelText   $csharpLabel

Eficiência das Operações de Intervalo

Operações de intervalo são executadas como comandos únicos em vez de iterar através de células individuais, melhorando significativamente o desempenho. Essa eficiência se torna crucial ao processar grandes conjuntos de dados ou operar em ambientes de contêiner com recursos limitados. A capacidade de selecionar e manipular intervalos permite transformações de dados eficazes com código mínimo. Você também pode ordenar intervalos de células, aparar intervalos de células e combinar múltiplos intervalos.

Padrões Comuns de Seleção de Intervalo

Padrão Sintaxe Descrição
Intervalos de colunas "A:A" Seleciona a coluna A inteira
Intervalos de linhas "1:1" Seleciona a linha 1 inteira
Intervalos retangulares "A1:C3" Seleciona um bloco 3x3
Intervalos nomeados Criar e usar intervalos nomeados Para clareza
Intervalos dinâmicos Construir strings de intervalo programaticamente Para seleção flexível

Editando Células com Entradas do Usuário

A edição interativa do Excel se torna eficaz quando combinada com entradas do usuário ou fontes de dados externas. Esta abordagem é valiosa para construir APIs que aceitam parâmetros e geram relatórios personalizados. Você pode querer importar dados do Excel de várias fontes ou exportar para diferentes formatos:

using IronXL;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class InteractiveExcelEditor
{
    public class EditRequest
    {
        public string FileName { get; set; }
        public string WorksheetName { get; set; }
        public Dictionary<string, object> CellUpdates { get; set; }
        public List<RangeUpdate> RangeUpdates { get; set; }
    }

    public class RangeUpdate
    {
        public string Range { get; set; }
        public object Value { get; set; }
        public CellStyle Style { get; set; }
    }

    public class CellStyle
    {
        public string BackgroundColor { get; set; }
        public bool Bold { get; set; }
        public string NumberFormat { get; set; }
    }

    public async Task<string> ProcessEditRequestAsync(EditRequest request)
    {
        try
        {
            // Load workbook
            WorkBook workBook = WorkBook.Load(request.FileName);
            WorkSheet sheet = string.IsNullOrEmpty(request.WorksheetName) 
                ? workBook.DefaultWorkSheet 
                : workBook.GetWorkSheet(request.WorksheetName);

            // Process individual cell updates
            if (request.CellUpdates != null)
            {
                foreach (var update in request.CellUpdates)
                {
                    var cell = sheet[update.Key];
                    cell.Value = update.Value;

                    // Auto-detect and apply appropriate formatting
                    if (update.Value is decimal || update.Value is double)
                    {
                        cell.FormatString = "#,##0.00";
                    }
                    else if (update.Value is DateTime)
                    {
                        cell.FormatString = "yyyy-MM-dd";
                    }
                }
            }

            // Process range updates
            if (request.RangeUpdates != null)
            {
                foreach (var rangeUpdate in request.RangeUpdates)
                {
                    var range = sheet[rangeUpdate.Range];
                    range.Value = rangeUpdate.Value;

                    // Apply styling if provided
                    if (rangeUpdate.Style != null)
                    {
                        if (!string.IsNullOrEmpty(rangeUpdate.Style.BackgroundColor))
                            range.Style.BackgroundColor = rangeUpdate.Style.BackgroundColor;

                        if (rangeUpdate.Style.Bold)
                            range.Style.Font.Bold = true;

                        if (!string.IsNullOrEmpty(rangeUpdate.Style.NumberFormat))
                            range.FormatString = rangeUpdate.Style.NumberFormat;
                    }
                }
            }

            // Generate unique output filename
            string outputFile = $"edited_{DateTime.Now:yyyyMMddHHmmss}_{request.FileName}";
            workBook.SaveAs(outputFile);

            return outputFile;
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException($"Failed to process edit request: {ex.Message}", ex);
        }
    }

    // Example REST API endpoint implementation
    public static async Task<string> HandleApiRequest(string jsonRequest)
    {
        var request = System.Text.Json.JsonSerializer.Deserialize<EditRequest>(jsonRequest);
        var editor = new InteractiveExcelEditor();
        return await editor.ProcessEditRequestAsync(request);
    }
}
using IronXL;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class InteractiveExcelEditor
{
    public class EditRequest
    {
        public string FileName { get; set; }
        public string WorksheetName { get; set; }
        public Dictionary<string, object> CellUpdates { get; set; }
        public List<RangeUpdate> RangeUpdates { get; set; }
    }

    public class RangeUpdate
    {
        public string Range { get; set; }
        public object Value { get; set; }
        public CellStyle Style { get; set; }
    }

    public class CellStyle
    {
        public string BackgroundColor { get; set; }
        public bool Bold { get; set; }
        public string NumberFormat { get; set; }
    }

    public async Task<string> ProcessEditRequestAsync(EditRequest request)
    {
        try
        {
            // Load workbook
            WorkBook workBook = WorkBook.Load(request.FileName);
            WorkSheet sheet = string.IsNullOrEmpty(request.WorksheetName) 
                ? workBook.DefaultWorkSheet 
                : workBook.GetWorkSheet(request.WorksheetName);

            // Process individual cell updates
            if (request.CellUpdates != null)
            {
                foreach (var update in request.CellUpdates)
                {
                    var cell = sheet[update.Key];
                    cell.Value = update.Value;

                    // Auto-detect and apply appropriate formatting
                    if (update.Value is decimal || update.Value is double)
                    {
                        cell.FormatString = "#,##0.00";
                    }
                    else if (update.Value is DateTime)
                    {
                        cell.FormatString = "yyyy-MM-dd";
                    }
                }
            }

            // Process range updates
            if (request.RangeUpdates != null)
            {
                foreach (var rangeUpdate in request.RangeUpdates)
                {
                    var range = sheet[rangeUpdate.Range];
                    range.Value = rangeUpdate.Value;

                    // Apply styling if provided
                    if (rangeUpdate.Style != null)
                    {
                        if (!string.IsNullOrEmpty(rangeUpdate.Style.BackgroundColor))
                            range.Style.BackgroundColor = rangeUpdate.Style.BackgroundColor;

                        if (rangeUpdate.Style.Bold)
                            range.Style.Font.Bold = true;

                        if (!string.IsNullOrEmpty(rangeUpdate.Style.NumberFormat))
                            range.FormatString = rangeUpdate.Style.NumberFormat;
                    }
                }
            }

            // Generate unique output filename
            string outputFile = $"edited_{DateTime.Now:yyyyMMddHHmmss}_{request.FileName}";
            workBook.SaveAs(outputFile);

            return outputFile;
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException($"Failed to process edit request: {ex.Message}", ex);
        }
    }

    // Example REST API endpoint implementation
    public static async Task<string> HandleApiRequest(string jsonRequest)
    {
        var request = System.Text.Json.JsonSerializer.Deserialize<EditRequest>(jsonRequest);
        var editor = new InteractiveExcelEditor();
        return await editor.ProcessEditRequestAsync(request);
    }
}
$vbLabelText   $csharpLabel

Integrando Edição do Excel com Pipelines CI/CD

Para cenários DevOps, integre o processamento de Excel em seus pipelines de construção e implantação. Você pode ler arquivos do Excel em aplicativos ASP.NET ou trabalhar com arquivos do Excel em VB.NET, se necessário:

# Example GitHub Actions workflow
name: Process Excel Reports

on:
  schedule:
    - cron: '0 2 * * *' # Run daily at 2 AM
  workflow_dispatch:

jobs:
  process-excel:
    runs-on: ubuntu-latest
    container:
      image: mcr.microsoft.com/dotnet/sdk:6.0

    steps:
    - uses: actions/checkout@v2

    - name: Restore dependencies
      run: dotnet restore

    - name: Build
      run: dotnet build --configuration Release

    - name: Process Excel files
      run: |
        dotnet run -- \
          --input-dir ./data/input \
          --output-dir ./data/output \
          --operation bulk-update

    - name: Upload processed files
      uses: actions/upload-artifact@v2
      with:
        name: processed-excel-files
        path: ./data/output/*.xlsx
# Example GitHub Actions workflow
name: Process Excel Reports

on:
  schedule:
    - cron: '0 2 * * *' # Run daily at 2 AM
  workflow_dispatch:

jobs:
  process-excel:
    runs-on: ubuntu-latest
    container:
      image: mcr.microsoft.com/dotnet/sdk:6.0

    steps:
    - uses: actions/checkout@v2

    - name: Restore dependencies
      run: dotnet restore

    - name: Build
      run: dotnet build --configuration Release

    - name: Process Excel files
      run: |
        dotnet run -- \
          --input-dir ./data/input \
          --output-dir ./data/output \
          --operation bulk-update

    - name: Upload processed files
      uses: actions/upload-artifact@v2
      with:
        name: processed-excel-files
        path: ./data/output/*.xlsx
YAML

Recursos Adicionais de Automação do Excel

Para expandir suas capacidades de automação do Excel, explore esses recursos especializados:

Recursos Avançados para Explorar

IronXL oferece funcionalidades extensivas além da edição básica de células:

Melhorando Fluxos de Trabalho de Processamento de Excel

Considere essas técnicas avançadas:

Guia Rápido de Referência para Edição de Excel

Aqui está uma referência consolidada para operações comuns de edição do Excel:

Operação Exemplo de Código Caso de uso
Edição de Célula Única sheet["A1"].Value = "New Value" Atualizar pontos de dados específicos
Edição de Intervalo sheet["A1:C10"].Value = "Bulk Update" Atualizações em lote para eficiência
Aplicação de Fórmula sheet["D1"].Formula = "=SUM(A1:C1)" Cálculos Dinâmicos
Formatação Condicional Aplicar cor com base no valor Análise visual de dados
Formatação de Data cell.FormatString = "yyyy-MM-dd" Exibição consistente de data
Formato de Moeda cell.FormatString = "$#,##0.00" Relatórios financeiros
Mesclar Células sheet["A1:C1"].Merge() Criar cabeçalhos e títulos
Tamanho Automático das Colunas sheet.AutoSizeColumn(0) Melhorar a legibilidade

Este guia completo demonstra como o IronXL simplifica a automação do Excel em ambientes .NET Core. Se você está construindo microsserviços, implantando em contêineres ou criando funções sem servidor, o IronXL fornece as ferramentas necessárias para um processamento de Excel eficiente, sem dependências externas. Comece a implementar esses padrões em seus fluxos de trabalho DevOps hoje para simplificar a geração de relatórios e tarefas de processamento de dados.

Perguntas frequentes

Qual a finalidade de usar o Excel em aplicações .NET Core?

O Excel é usado em aplicações .NET Core para gerenciamento e manipulação de dados eficientes. O IronXL permite que desenvolvedores carreguem, editem e salvem arquivos do Excel programaticamente usando C#, aumentando a produtividade e os recursos de manipulação de dados.

Como posso instalar a biblioteca do Excel em um projeto .NET Core?

Você pode instalar a biblioteca IronXL em um projeto .NET Core usando o Gerenciador de Pacotes NuGet com o comando: dotnet add package IronXl.Excel . Como alternativa, você pode baixar o arquivo DLL diretamente do site da IronXL.

Quais são os passos para carregar um arquivo Excel no .NET Core?

Para carregar um arquivo Excel no .NET Core usando o IronXL, utilize o método WorkBook.Load . Por exemplo, WorkBook wb = WorkBook.Load("sample.xlsx"); carregará a planilha Excel chamada 'sample.xlsx'.

Posso editar um intervalo de células em uma planilha do Excel usando o .NET Core?

Sim, com o IronXL, você pode editar um intervalo de células em uma planilha do Excel simultaneamente. Use a sintaxe ws["A1:A9"].Value = "new value"; para atribuir um valor a várias células, onde ws é um objeto WorkSheet .

Como posso lidar com entradas do usuário ao editar arquivos do Excel no .NET Core?

O IronXL permite o processamento de entradas do usuário, capturando-as através do console ou de uma interface de usuário, que podem então ser usadas para definir o intervalo de células e o valor para atualizações na planilha do Excel.

Qual linguagem de programação é usada para manipulação do Excel no .NET Core?

O C# é usado para manipular arquivos do Excel programaticamente em aplicações .NET Core usando a biblioteca IronXL.

Existe algum tutorial para trabalhar com arquivos do Excel no .NET Core?

Sim, existem tutoriais completos sobre como ler e manipular arquivos Excel usando C# com IronXL. Recursos adicionais e projetos de exemplo podem ser encontrados no site da IronXL.

Quais são os requisitos de compatibilidade para usar a biblioteca Excel no .NET Core?

O IronXL é compatível com diversas versões do .NET Core. Informações detalhadas sobre compatibilidade podem ser encontradas na documentação do IronXL em seu site.

Onde posso acessar a documentação da API da biblioteca do Excel?

A documentação da API do IronXL está disponível online, fornecendo detalhes sobre todos os namespaces, métodos e recursos. Visite o site do IronXL para acessar esse recurso.

Jordi Bardia
Jordi Bardia
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software
Jordi é extremamente proficiente em Python, C# e C++, e quando não está utilizando suas habilidades na Iron Software, dedica-se à programação de jogos. Compartilhando as responsabilidades por testes, desenvolvimento e pesquisa de produtos, Jordi agrega imenso valor à melhoria contínua dos produtos. Essa experiência diversificada o mantém ...
Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Iron Support Team

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