Icône de message
Passer au contenu du pied de page
  1. IronXL
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. .NET Core Excel
UTILISATION D'IRONXL

Installation via l'interface de ligne de commande .NET (recommandée pour les pipelines CI/CD)

Jordi Bardia
Jordi Bardia
Mis à jour:

IronXL permet aux développeurs de modifier les cellules Excel dans les applications .NET Core à l'aide d'un code C# simple, sans avoir besoin de Microsoft Office. Il prend en charge la manipulation des cellules, les opérations sur les plages et le déploiement sur Windows, Linux et macOS.

Pourquoi utiliser IronXL pour le développement Excel .NET Core ?

L'utilisation d' Excel dans .NET Core est cruciale pour les applications d'entreprise modernes, notamment dans les environnements cloud-native et conteneurisés. La bibliothèque IronXL offre des fonctionnalités Excel étendues qui fonctionnent de manière fluide sur différentes plateformes sans nécessiter l'installation de Microsoft Office. Cette fonctionnalité est particulièrement précieuse pour les ingénieurs DevOps qui automatisent la génération de rapports, les pipelines de traitement des données et les flux de travail CI/CD.

Prenons un exemple typique : votre équipe doit générer des rapports de performance mensuels à partir de diverses sources de données, modifier des cellules spécifiques en fonction de calculs et déployer cette fonctionnalité dans des conteneurs Docker sur plusieurs environnements. L'automatisation traditionnelle d'Excel nécessiterait l'installation d'Office sur chaque serveur, ce qui engendrerait des problèmes de licences et des complexités de déploiement. IronXL élimine ces obstacles en fournissant une solution autonome qui fonctionne partout où vos applications .NET Core sont exécutées.

Cette bibliothèque excelle dans la création de feuilles de calcul à partir de zéro, la gestion programmatique des feuilles de calcul et la conversion entre formats de fichiers sans dépendances externes. Que vous développiez des microservices, des fonctions sans serveur ou des applications conteneurisées, IronXL s'intègre naturellement aux flux de travail DevOps modernes.

Pourquoi choisir IronXL pour le traitement Excel natif du cloud ?

Les environnements cloud exigent des solutions légères et flexibles. IronXL tient ses promesses en prenant en charge nativement les déploiements Docker , Azure Functions et AWS Lambda . L'architecture de la bibliothèque garantit une consommation minimale de ressources tout en maintenant des performances élevées, ce qui est crucial pour des opérations cloud rentables. Vous pouvez utiliser Excel sans Interop , ce qui rend les déploiements plus simples et plus efficaces.

Fonctionnalités clés de l'édition Excel avec .NET Core

Capacité Description du projet
Compatibilité multiplateforme Prise en charge native de Windows, Linux et macOS
Prêt pour le conteneur Optimisé pour les déploiements Docker et Kubernetes
Intégration native du cloud Fonctionne parfaitement avec les plateformes sans serveur
Aucune dépendance externe Bibliothèque autonome sans exigences bureautiques
Performances optimisées Utilisation efficace de la mémoire pour les opérations à grande échelle

Comment installer la bibliothèque IronXL

La prise en main d'IronXL dans votre projet .NET Core ne prend que quelques minutes. La bibliothèque est disponible via les gestionnaires de paquets standard et prend en charge tous les scénarios de déploiement modernes. Voici comment ajouter IronXL à votre projet :

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

Configuration des licences pour la production

Après l'installation, configurez votre clé de licence pour les déploiements en production . IronXL propose des options de licence flexibles adaptées à différentes échelles de déploiement, des applications mono-serveur aux solutions à l'échelle de l'entreprise. Pour les applications web, vous pouvez configurer la licence dans le fichier web.config pour une gestion centralisée. Pensez aux extensions de licence pour faire évoluer vos applications et aux options de mise à niveau au fur et à mesure que vos besoins augmentent.

Amélioration d'IronXL pour les environnements conteneurisés

Lors du déploiement dans des conteneurs, tenez compte de ces stratégies d'optimisation qui s'alignent sur les bonnes pratiques de configuration de 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"]

Modification rapide des cellules Excel dans .NET Core

Voici un exemple pratique illustrant les fonctionnalités principales. Ce code montre comment charger un fichier Excel existant et modifier des cellules spécifiques :

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

Pourquoi ce modèle est-il idéal pour l'automatisation ?

Ce modèle fonctionne parfaitement dans les flux de travail automatisés car il est déterministe et ne nécessite aucune interaction de l'utilisateur. Vous pouvez programmer l'exécution de ce code dans un conteneur, déclenchée par des événements ou des planifications temporelles, ce qui le rend idéal pour les scénarios d'automatisation DevOps . La possibilité d' ouvrir des feuilles de calcul Excel et de les modifier par programmation offre des possibilités d'automatisation efficaces.

Démarrage d'un projet d'édition Excel avec .NET Core

La mise en place d'une solution d'édition Excel fiable nécessite une configuration de projet adéquate. Prenons l'exemple complet qui illustre les bonnes pratiques pour les déploiements en production, en intégrant la gestion des erreurs et la journalisation :

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

Meilleures pratiques en matière de gestion des erreurs

Une gestion fiable des erreurs est cruciale pour les déploiements en production. L'exemple ci-dessus illustre l'intégration de la journalisation et la gestion appropriée des exceptions, essentielles pour le débogage des problèmes dans les environnements conteneurisés où l'accès direct à l'environnement d'exécution est limité. Pensez à mettre en œuvre des mesures de sécurité et à vérifier les limites de taille des fichiers pour votre cas d'utilisation.

Modification de la valeur d'une cellule spécifique

Explorons différentes techniques de modification des valeurs des cellules, allant des simples mises à jour aux transformations de données complexes. IronXL propose des méthodes intuitives pour écrire des valeurs dans les cellules Excel tout en prenant en charge différents types et formats de données. Vous pouvez également copier des cellules et effacer leur contenu selon vos besoins.

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

Gérer efficacement différents types de données

IronXL détecte et convertit automatiquement les types de données, mais une mise en forme explicite garantit un affichage correct. La bibliothèque permet de définir les formats de données des cellules pour les devises, les pourcentages, les dates et les modèles personnalisés. Vous pouvez explorer les formats numériques Excel pour accéder à des options de mise en forme avancées. De plus, vous pouvez personnaliser les polices et les tailles des cellules , appliquer des motifs et des couleurs d'arrière-plan , et configurer les bordures et l'alignement des cellules .

Attribution de valeurs à plusieurs cellules

Les opérations par lots sont essentielles pour un traitement Excel efficace. IronXL offre des fonctionnalités de sélection de portée efficaces qui facilitent la mise à jour simultanée de plusieurs cellules. Vous pouvez également ajouter des lignes et des colonnes , insérer de nouvelles lignes et colonnes et fusionner des cellules selon vos besoins :

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

Efficacité des opérations de tir

Les opérations sur les plages de cellules s'exécutent sous forme de commandes uniques plutôt que par itération sur chaque cellule, ce qui améliore considérablement les performances. Cette efficacité devient cruciale lors du traitement de grands ensembles de données ou lors de l'exécution dans des environnements de conteneurs aux ressources limitées. La possibilité de sélectionner et de manipuler des plages de valeurs permet des transformations de données efficaces avec un minimum de code. Vous pouvez également trier les plages de cellules , tronquer les plages de cellules et combiner plusieurs plages .

Modèles de sélection de gamme courants

Modèle Syntaxe Description du projet
Plages de colonnes "A:A" Sélectionne toute la colonne A
Plages de lignes "1:1" Sélectionne la ligne entière 1
Gammes rectangulaires A1:C3 Sélectionne un bloc 3x3
Plages nommées Créer et utiliser des plages nommées Pour plus de clarté
Plages dynamiques Construire des chaînes de plage par programmation Pour une sélection flexible

Modification des cellules avec les entrées de l'utilisateur

L'édition interactive dans Excel devient efficace lorsqu'elle est combinée aux données saisies par l'utilisateur ou à des sources de données externes. Cette approche est précieuse pour la création d'API qui acceptent des paramètres et génèrent des rapports personnalisés. Vous pouvez importer des données Excel provenant de diverses sources ou les exporter vers différents formats :

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

Intégration de l'édition Excel aux pipelines CI/CD

Dans les scénarios DevOps , intégrez le traitement Excel à vos pipelines de construction et de déploiement. Vous pouvez lire des fichiers Excel dans des applications ASP.NET ou travailler avec des fichiers Excel VB.NET si nécessaire :

# 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

Ressources supplémentaires pour l'automatisation Excel

Pour développer vos capacités d'automatisation Excel, explorez ces ressources spécialisées :

Fonctionnalités avancées à explorer

IronXL offre des fonctionnalités étendues allant au-delà de la simple édition de cellules :

Amélioration des flux de travail de traitement Excel

Considérez ces techniques avancées :

Guide de référence rapide pour l'édition Excel

Voici un guide récapitulatif des opérations d'édition Excel courantes :

Opération Exemple de code Cas d'utilisation
Édition de cellule unique sheet["A1"].Value = "New Value" Mise à jour de points de données spécifiques
Range Edit sheet["A1:C10"].Value = "Bulk Update" Mises à jour par lots pour plus d'efficacité
Application de la formule sheet["D1"].Formula = "=SUM(A1:C1)" calculs dynamiques
Mise en forme conditionnelle Appliquer la couleur en fonction de la valeur Analyse visuelle des données
Formatage de date cell.FormatString = "yyyy-MM-dd" Affichage de la date cohérent
Format de devise cell.FormatString = "$#,##0.00" rapports financiers
Fusionner les cellules sheet["A1:C1"].Merge() Créer des en-têtes et des titres
Colonnes à dimensionnement automatique sheet.AutoSizeColumn(0) Améliorer la lisibilité

Ce guide complet démontre comment IronXL simplifie l'automatisation d'Excel dans les environnements .NET Core. Que vous développiez des microservices, déployiez sur des conteneurs ou créiez des fonctions sans serveur, IronXL fournit les outils nécessaires à un traitement Excel efficace sans dépendances externes. Commencez dès aujourd'hui à mettre en œuvre ces modèles dans vos flux de travail DevOps afin de simplifier la génération de rapports et les tâches de traitement des données.

Questions Fréquemment Posées

Quel est l'objectif d'utiliser Excel dans les applications .NET Core ?

Excel est utilisé dans les applications .NET Core pour une gestion et une manipulation efficaces des données. IronXL permet aux développeurs de charger, éditer et enregistrer des fichiers Excel de manière programmatique en utilisant C#, améliorant ainsi la productivité et les capacités de gestion des données.

Comment puis-je installer la bibliothèque Excel dans un projet .NET Core ?

Vous pouvez installer la bibliothèque IronXL dans un projet .NET Core en utilisant le gestionnaire de packages NuGet avec la commande : dotnet add package IronXL.Excel. Alternativement, vous pouvez télécharger le fichier DLL directement depuis le site IronXL.

Quelles sont les étapes pour charger un fichier Excel dans .NET Core ?

Pour charger un fichier Excel dans .NET Core en utilisant IronXL, utilisez la méthode WorkBook.Load. Par exemple, WorkBook wb = WorkBook.Load("sample.xlsx"); chargera le classeur Excel nommé 'sample.xlsx'.

Puis-je éditer une plage de cellules dans une feuille Excel en utilisant .NET Core ?

Oui, avec IronXL, vous pouvez éditer une plage de cellules dans une feuille Excel simultanément. Utilisez la syntaxe ws["A1:A9"].Value = "nouvelle valeur"; pour attribuer une valeur à plusieurs cellules, où ws est un objet WorkSheet.

Comment gérer les entrées de l'utilisateur lors de l'édition de fichiers Excel dans .NET Core ?

IronXL permet de gérer les entrées utilisateur en les capturant via la console ou une interface utilisateur, qui peuvent ensuite être utilisées pour définir la plage de cellules et la valeur pour les mises à jour dans le tableur Excel.

Quel langage de programmation est utilisé pour la manipulation d'Excel dans .NET Core ?

C# est utilisé pour manipuler des fichiers Excel de manière programmatique dans les applications .NET Core en utilisant la bibliothèque IronXL.

Existe-t-il un tutoriel pour travailler avec des fichiers Excel dans .NET Core ?

Oui, des tutoriels exhaustifs sur la lecture et la manipulation de fichiers Excel en utilisant C# avec IronXL sont disponibles. Des ressources supplémentaires et des projets d'exemples peuvent être trouvés sur le site Web d'IronXL.

Quelles sont les exigences de compatibilité pour l'utilisation de la bibliothèque Excel dans .NET Core ?

IronXL prend en charge diverses versions de .NET Core. Des informations détaillées sur la compatibilité peuvent être trouvées dans la documentation d'IronXL sur leur site Web.

Où puis-je accéder à la documentation API pour la bibliothèque Excel ?

La documentation API pour IronXL est disponible en ligne, fournissant des détails sur tous les espaces de noms, méthodes et fonctionnalités. Visitez le site Web d'IronXL pour accéder à cette ressource.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit