IronXL ermöglicht Entwicklern die Bearbeitung von Excel-Zellen in .NET Core -Anwendungen mithilfe von einfachem C#-Code, ohne dass Microsoft Office erforderlich ist. Es unterstützt die Zellmanipulation, Bereichsoperationen und die Bereitstellung unter Windows, Linux und macOS.
Die Arbeit mit Excel in .NET Core ist für moderne Enterprise unerlässlich, insbesondere in Cloud-nativen und containerisierten Umgebungen. Die IronXL Bibliothek bietet umfangreiche Excel-Funktionen , die plattformübergreifend reibungslos funktionieren, ohne dass Microsoft Office installiert werden muss. Diese Fähigkeit ist besonders wertvoll für DevOps-Ingenieure, die die Berichterstellung automatisieren, Datenverarbeitungs-Pipelines und CI/CD-Workflows optimieren.
Stellen Sie sich folgendes typische Szenario vor: Ihr Team muss monatliche Leistungsberichte aus verschiedenen Datenquellen generieren, bestimmte Zellen auf Basis von Berechnungen modifizieren und diese Funktionalität in Docker-Containern in mehreren Umgebungen bereitstellen. Die herkömmliche Excel-Automatisierung würde die Installation von Office auf jedem Server erfordern, was zu Lizenzierungsproblemen und komplexen Bereitstellungsabläufen führen würde. IronXL beseitigt diese Barrieren, indem es eine in sich geschlossene Lösung bietet, die überall dort funktioniert, wo Ihre .NET Core Anwendungen ausgeführt werden.
Die Bibliothek zeichnet sich durch die Erstellung von Tabellenkalkulationen von Grund auf, die programmatische Verwaltung von Arbeitsblättern und die Konvertierung zwischen Dateiformaten ohne externe Abhängigkeiten aus. Egal, ob Sie Microservices, serverlose Funktionen oder containerisierte Anwendungen entwickeln, IronXL integriert sich nahtlos in moderne DevOps-Workflows.
Cloud-Umgebungen erfordern schlanke und flexible Lösungen. IronXL überzeugt durch die standardmäßige Unterstützung von Docker-Bereitstellungen , Azure Functions und AWS Lambda . Die Architektur der Bibliothek gewährleistet einen minimalen Ressourcenverbrauch bei gleichzeitig hoher Leistungsfähigkeit, was für einen kosteneffizienten Cloud-Betrieb von entscheidender Bedeutung ist. Sie können mit Excel auch ohne Interop arbeiten , was die Bereitstellung übersichtlicher und effizienter macht.
| Fähigkeit | Beschreibung |
|---|---|
| Plattformübergreifende Kompatibilität | Native Unterstützung für Windows, Linux und macOS |
| Containerfertig | Optimiert für Docker- und Kubernetes-Bereitstellungen |
| Cloud-native Integration | Funktioniert reibungslos mit serverlosen Plattformen |
| Keine externen Abhängigkeiten | Eigenständige Bibliothek ohne Office-Anforderungen |
| Leistungsoptimierung | Effiziente Speichernutzung für groß angelegte Operationen |
Der Einstieg in IronXL in Ihrem .NET Core Projekt dauert nur wenige Minuten. Die Bibliothek ist über gängige Paketmanager verfügbar und unterstützt alle modernen Bereitstellungsszenarien. So fügen Sie IronXL zu Ihrem Projekt hinzu:
Oder verwenden Sie die Paketmanager-Konsole in Visual Studio
Zur Installation spezifischer Versionen (nützlich für reproduzierbare Builds)
Oder fügen Sie Ihrer .csproj-Datei zur deklarativen Paketverwaltung hinzu
<PackageReference Include="IronXL.Excel" Version="2024.12.0" />Konfigurieren Sie nach der Installation Ihren Lizenzschlüssel für den Produktiveinsatz . IronXL bietet flexible Lizenzierungsoptionen, die für unterschiedliche Bereitstellungsgrößen geeignet sind, von Einzelserveranwendungen bis hin zu unternehmensweiten Lösungen. Bei Webanwendungen können Sie die Lizenz in der web.config-Datei für eine zentrale Verwaltung konfigurieren . Erwägen Sie Lizenzerweiterungen , um Ihre Anwendungen skalieren und Upgrade-Optionen nutzen zu können, wenn Ihre Anforderungen wachsen.
Bei der Bereitstellung in Containern sollten Sie diese Optimierungsstrategien berücksichtigen, die den Best Practices für die Docker-Einrichtung entsprechen:
# 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"]Hier ist ein praktisches Beispiel, das die Kernfunktionalität demonstriert. Dieser Code zeigt, wie man eine bestehende Excel-Datei lädt und bestimmte Zellen ändert:
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 ClassDieses Muster eignet sich perfekt für automatisierte Arbeitsabläufe, da es deterministisch ist und keine Benutzerinteraktion erfordert. Sie können diesen Code so planen, dass er in einem Container ausgeführt wird, ausgelöst durch Ereignisse oder zeitbasierte Zeitpläne, was ihn ideal für DevOps-Automatisierungsszenarien macht. Die Möglichkeit , Excel-Arbeitsblätter programmatisch zu öffnen und zu bearbeiten, eröffnet effektive Automatisierungsmöglichkeiten.
Für die Entwicklung einer zuverlässigen Excel-Bearbeitungslösung ist eine ordnungsgemäße Projektvorbereitung erforderlich. Lassen Sie uns ein vollständiges Beispiel erstellen, das Best Practices für Produktionsbereitstellungen aufzeigt und Fehlerbehandlung und Protokollierung beinhaltet:
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 ClassEine zuverlässige Fehlerbehandlung ist für den Einsatz in Produktionsumgebungen unerlässlich. Das obige Beispiel veranschaulicht die Integration von Protokollierung und korrekter Ausnahmebehandlung. Diese sind unerlässlich für die Fehlersuche in containerisierten Umgebungen, in denen möglicherweise kein direkter Zugriff auf die Laufzeitumgebung besteht. Erwägen Sie die Implementierung von Sicherheitsmaßnahmen und überprüfen Sie die Dateigrößenbeschränkungen für Ihren Anwendungsfall.
Lassen Sie uns verschiedene Techniken zur Änderung von Zellwerten untersuchen, von einfachen Aktualisierungen bis hin zu komplexen Datentransformationen. IronXL bietet intuitive Methoden zum Schreiben von Werten in Excel-Zellen und unterstützt dabei verschiedene Datentypen und -formate. Sie können Zellen auch kopieren und deren Inhalt bei Bedarf löschen .
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 erkennt und konvertiert Datentypen automatisch, aber die explizite Formatierung gewährleistet die korrekte Anzeige. Die Bibliothek unterstützt die Festlegung von Zelldatenformaten für Währungen, Prozentsätze, Datumsangaben und benutzerdefinierte Muster. Sie können die Excel-Zahlenformate erkunden, um erweiterte Formatierungsoptionen zu erhalten. Darüber hinaus können Sie Schriftarten und -größen der Zellen anpassen , Hintergrundmuster und -farben anwenden sowie Zellrahmen und -ausrichtung konfigurieren.
Massenverarbeitung ist für eine effiziente Excel-Verarbeitung unerlässlich. IronXL bietet effektive Bereichsauswahlfunktionen , die es ermöglichen, mehrere Zellen gleichzeitig zu aktualisieren. Sie können außerdem Zeilen und Spalten hinzufügen , neue Zeilen und Spalten einfügen und Zellen nach Bedarf zusammenführen :
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 ClassBereichsoperationen werden als einzelne Befehle ausgeführt, anstatt einzelne Zellen zu durchlaufen, was die Leistung deutlich verbessert. Diese Effizienz ist von entscheidender Bedeutung bei der Verarbeitung großer Datensätze oder beim Betrieb in ressourcenbeschränkten Containerumgebungen. Die Möglichkeit, Bereiche auszuwählen und zu bearbeiten, ermöglicht effektive Datentransformationen mit minimalem Codeaufwand. Sie können außerdem Zellbereiche sortieren , Zellbereiche kürzen und mehrere Bereiche kombinieren .
| Muster | Syntax | Beschreibung |
|---|---|---|
| Spaltenbereiche | "A:A" | Wählt die gesamte Spalte A aus |
| Zeilenbereiche | "1:1" | Wählt die gesamte Zeile 1 aus |
| Rechteckige Bereiche | "A1:C3" | Wählt einen 3x3-Block aus |
| Benannte Gebirgszüge | Benannte Bereiche erstellen und verwenden | Zur Verdeutlichung |
| Dynamikbereiche | Bereichszeichenketten programmatisch erstellen | Für flexible Auswahl |
Die interaktive Bearbeitung von Excel-Tabellen wird erst dann effektiv, wenn sie mit Benutzereingaben oder externen Datenquellen kombiniert wird. Dieser Ansatz ist wertvoll für die Entwicklung von APIs, die Parameter akzeptieren und benutzerdefinierte Berichte generieren. Möglicherweise möchten Sie Excel-Daten aus verschiedenen Quellen importieren oder in verschiedene Formate exportieren :
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 ClassFür DevOps-Szenarien integrieren Sie die Excel-Verarbeitung in Ihre Build- und Bereitstellungs-Pipelines. Sie können Excel-Dateien in ASP.NET Anwendungen lesen oder bei Bedarf mit .NET Excel-Dateien arbeiten:
# 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/*.xlsxUm Ihre Excel-Automatisierungsmöglichkeiten zu erweitern, sollten Sie diese spezialisierten Ressourcen nutzen:
IronXL bietet weit mehr als nur die grundlegende Zellenbearbeitung:
Betrachten Sie diese fortgeschrittenen Techniken:
Hier finden Sie eine zusammenfassende Übersicht über gängige Bearbeitungsvorgänge in Excel:
| Betrieb | Codebeispiel | Anwendungsfall |
|---|---|---|
| Einzelzellenbearbeitung | sheet["A1"].Value = "New Value" | Aktualisieren Sie spezifische Datenpunkte |
| Bereichsbearbeitung | sheet["A1:C10"].Value = "Bulk Update" | Stapelverarbeitung für mehr Effizienz |
| Anwendung der Formel | sheet["D1"].Formula = "=SUM(A1:C1)" | Dynamische Berechnungen |
| Bedingte Formatierung | Farbe basierend auf dem Wert anwenden | Visuelle Datenanalyse |
| Datumsformatierung | cell.FormatString = "yyyy-MM-dd" | Einheitliche Datumsanzeige |
| Währungsformat | cell.FormatString = "$#,##0.00" | Finanzberichterstattung |
| Zellen zusammenführen | sheet["A1:C1"].Merge() | Erstellen Sie Überschriften und Titel. |
| Spalten automatisch anpassen | sheet.AutoSizeColumn(0) | Lesbarkeit verbessern |
Dieser vollständige Leitfaden zeigt, wie IronXL die Excel-Automatisierung in .NET Core Umgebungen vereinfacht. Egal ob Sie Microservices entwickeln, in Containern bereitstellen oder serverlose Funktionen erstellen, IronXL bietet die Werkzeuge, die für eine effiziente Excel-Verarbeitung ohne externe Abhängigkeiten benötigt werden. Beginnen Sie noch heute mit der Implementierung dieser Muster in Ihren DevOps-Workflows, um die Berichterstellung und Datenverarbeitungsaufgaben zu vereinfachen.
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronXL ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Das Excel-API, das Sie brauchen, ohne den Office Interop Aufwand.
