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.
L'utilisation d' Excel dans .NET Core est cruciale pour les applications Enterprise 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 capacité est particulièrement précieuse pour les ingénieurs DevOps automatisant la génération de rapports, les pipelines de traitement de 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 dans les flux de travail modernes DevOps.
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.
| 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 |
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 :
Ou utilisez la console Package Manager dans Visual Studio
Pour l'installation de version spécifique (utile pour des builds reproductibles)
Ou, ajoutez-le à votre fichier .csproj pour la gestion déclarative des packages
<PackageReference Include="IronXL.Excel" Version="2024.12.0" />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.
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"]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!");
}
}Imports IronXL
Imports System
Class QuickStartExample
Shared Sub Main()
' Load existing Excel file - supports XLSX, XLS, XLSM, XLTX
Dim workBook As WorkBook = WorkBook.Load("sales_report.xlsx")
' Access the default worksheet (usually first sheet)
Dim sheet As WorkSheet = 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.5 ' 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!")
End Sub
End ClassCe 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 ce code pour qu'il s'exécute dans un conteneur, déclenché par des événements ou des plannings basés sur le temps, 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.
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
}
});
}
}Imports IronXL
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Extensions.Logging
Public Class ExcelProcessor
Private ReadOnly _logger As ILogger(Of ExcelProcessor)
Private ReadOnly _workingDirectory As String
Public Sub New(logger As ILogger(Of ExcelProcessor), workingDirectory As String)
_logger = logger
_workingDirectory = workingDirectory
End Sub
Public Async Function ProcessExcelFileAsync(fileName As String) As Task
Try
Dim filePath = Path.Combine(_workingDirectory, fileName)
' Validate file exists
If Not File.Exists(filePath) Then
_logger.LogError($"File not found: {filePath}")
Throw New FileNotFoundException("Excel file not found", fileName)
End If
' Load workbook with error handling
_logger.LogInformation($"Loading Excel file: {fileName}")
Dim workBook As WorkBook = WorkBook.Load(filePath)
' Process each worksheet
For Each worksheet In workBook.WorkSheets
_logger.LogInformation($"Processing worksheet: {worksheet.Name}")
Await ProcessWorksheetAsync(worksheet)
Next
' Save with timestamp for version control
Dim outputName = $"{Path.GetFileNameWithoutExtension(fileName)}_processed_{DateTime.Now:yyyyMMddHHmmss}.xlsx"
Dim 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 ex As Exception
_logger.LogError(ex, $"Error processing Excel file: {fileName}")
Throw
End Try
End Function
Private Async Function ProcessWorksheetAsync(worksheet As WorkSheet) As Task
' Example: Update timestamp in specific cell
Dim timestampCell = worksheet("A1")
If timestampCell.StringValue = "Last Updated:" Then
worksheet("B1").Value = DateTime.Now
worksheet("B1").FormatString = "yyyy-MM-dd HH:mm:ss"
End If
' Example: Process data rows asynchronously
Await Task.Run(Sub()
For row As Integer = 2 To worksheet.RowCount
' Skip empty rows
If worksheet($"A{row}").IsEmpty Then
Continue For
End If
' Apply business logic
Dim quantity = worksheet($"B{row}").IntValue
Dim price = worksheet($"C{row}").DoubleValue
worksheet($"D{row}").Value = quantity * price
worksheet($"E{row}").Formula = $"=D{row}*0.08" ' Tax calculation
Next
End Sub)
End Function
End ClassUne 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.
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");
}
}Imports IronXL
Imports System
Imports System.Linq
Imports System.Collections.Generic
Public Class CellEditingExamples
Public Shared Sub DemonstrateVariousCellEdits()
Dim workBook As WorkBook = WorkBook.Load("data.xlsx")
Dim sheet As WorkSheet = 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
Dim rowIndex As Integer = 5
Dim columnLetter As String = "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
Dim 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
For Each cell In sheet("J1:J10")
cell.Value = New Random().Next(0, 100)
If cell.IntValue > 50 Then
cell.Style.BackgroundColor = "#90EE90" ' Light green for high values
Else
cell.Style.BackgroundColor = "#FFB6C1" ' Light red for low values
End If
Next
' 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")
End Sub
End ClassIronXL 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 .
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");
}
}Imports IronXL
Imports System
Imports System.Diagnostics
Public Class BulkCellOperations
Public Shared Sub PerformBulkUpdates()
Dim stopwatch = Stopwatch.StartNew()
Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = 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
Dim ranges = {"F1:F10", "H1:H10", "J1:J10"}
For Each range As String In ranges
sheet(range).Value = "Batch Update"
sheet(range).Style.BottomBorder.Type = BorderType.Double
Next
' Method 6: Conditional bulk updates
Dim dataRange = sheet("K1:K100")
For Each cell As var In dataRange
' Generate test data
cell.Value = New Random().Next(1, 1000)
' Apply conditional formatting based on value
If cell.IntValue > 750 Then
cell.Style.BackgroundColor = "#00FF00" ' Green for high values
cell.Style.Font.Bold = True
ElseIf cell.IntValue < 250 Then
cell.Style.BackgroundColor = "#FF0000" ' Red for low values
cell.Style.Font.Color = "#FFFFFF"
End If
Next
stopwatch.Stop()
Console.WriteLine($"Total execution time: {stopwatch.ElapsedMilliseconds}ms")
workBook.SaveAs("inventory_bulk_updated.xlsx")
End Sub
End ClassLes 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è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 |
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);
}
}Imports IronXL
Imports System
Imports System.Collections.Generic
Imports System.Threading.Tasks
Public Class InteractiveExcelEditor
Public Class EditRequest
Public Property FileName As String
Public Property WorksheetName As String
Public Property CellUpdates As Dictionary(Of String, Object)
Public Property RangeUpdates As List(Of RangeUpdate)
End Class
Public Class RangeUpdate
Public Property Range As String
Public Property Value As Object
Public Property Style As CellStyle
End Class
Public Class CellStyle
Public Property BackgroundColor As String
Public Property Bold As Boolean
Public Property NumberFormat As String
End Class
Public Async Function ProcessEditRequestAsync(request As EditRequest) As Task(Of String)
Try
' Load workbook
Dim workBook As WorkBook = WorkBook.Load(request.FileName)
Dim sheet As WorkSheet = If(String.IsNullOrEmpty(request.WorksheetName), workBook.DefaultWorkSheet, workBook.GetWorkSheet(request.WorksheetName))
' Process individual cell updates
If request.CellUpdates IsNot Nothing Then
For Each update In request.CellUpdates
Dim cell = sheet(update.Key)
cell.Value = update.Value
' Auto-detect and apply appropriate formatting
If TypeOf update.Value Is Decimal OrElse TypeOf update.Value Is Double Then
cell.FormatString = "#,##0.00"
ElseIf TypeOf update.Value Is DateTime Then
cell.FormatString = "yyyy-MM-dd"
End If
Next
End If
' Process range updates
If request.RangeUpdates IsNot Nothing Then
For Each rangeUpdate In request.RangeUpdates
Dim range = sheet(rangeUpdate.Range)
range.Value = rangeUpdate.Value
' Apply styling if provided
If rangeUpdate.Style IsNot Nothing Then
If Not String.IsNullOrEmpty(rangeUpdate.Style.BackgroundColor) Then range.Style.BackgroundColor = rangeUpdate.Style.BackgroundColor
If rangeUpdate.Style.Bold Then range.Style.Font.Bold = True
If Not String.IsNullOrEmpty(rangeUpdate.Style.NumberFormat) Then range.FormatString = rangeUpdate.Style.NumberFormat
End If
Next
End If
' Generate unique output filename
Dim outputFile As String = $"edited_{DateTime.Now:yyyyMMddHHmmss}_{request.FileName}"
workBook.SaveAs(outputFile)
Return outputFile
Catch ex As Exception
Throw New InvalidOperationException($"Failed to process edit request: {ex.Message}", ex)
End Try
End Function
' Example REST API endpoint implementation
Public Shared Async Function HandleApiRequest(jsonRequest As String) As Task(Of String)
Dim request = System.Text.Json.JsonSerializer.Deserialize(Of EditRequest)(jsonRequest)
Dim editor = New InteractiveExcelEditor()
Return Await editor.ProcessEditRequestAsync(request)
End Function
End ClassPour les scénarios DevOps, intégrez le traitement Excel dans 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/*.xlsxPour développer vos capacités d'automatisation Excel, explorez ces ressources spécialisées :
IronXL offre des fonctionnalités étendues allant au-delà de la simple édition de cellules :
Considérez ces techniques avancées :
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 |
| Modification de la plage | 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 à implémenter ces modèles dans vos flux de travail DevOps dès aujourd'hui pour simplifier la génération de rapports et les tâches de traitement de données.
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronXL fait partie de IRONSUITE
10 API .NET pour vos documents
L'API Excel dont vous avez besoin, sans tracas Interop Office.
