IronXL umożliwia programistom modyfikowanie komórek Excela w aplikacjach .NET Core przy użyciu prostego kodu C# bez konieczności korzystania z pakietu Microsoft Office. Obsługuje manipulowanie komórkami, operacje na zakresach oraz wdrażanie w systemach Windows, Linux i macOS.
Praca z programem Excel w środowisku .NET Core ma kluczowe znaczenie dla nowoczesnych aplikacji Enterprise, zwłaszcza w środowiskach natywnych dla chmury i kontenerowych. Biblioteka IronXL oferuje rozbudowaną funkcjonalność programu Excel, która działa płynnie na różnych platformach bez konieczności instalowania pakietu Microsoft Office. Ta funkcjonalnosc jest szczegolnie cenna dla DevOps inzynierow automatyzujacych generowanie raportow, przetwarzanie danych i procesy CI/CD.
Rozważmy typowy scenariusz: Twój zespół musi generować miesięczne raporty wydajności z różnych źródeł danych, modyfikować określone komórki na podstawie obliczeń i wdrażać tę funkcjonalność w kontenerach Docker w wielu środowiskach. Tradycyjna automatyzacja programu Excel wymagałaby instalacji pakietu Office na każdym serwerze, co powodowałoby problemy z licencjami i komplikacje związane z wdrażaniem. IronXL eliminuje te bariery, zapewniając samodzielne rozwiązanie, które działa wszędzie tam, gdzie działają aplikacje .NET Core.
Biblioteka doskonale sprawdza się w tworzeniu arkuszy kalkulacyjnych od podstaw, programowym zarządzaniu arkuszami oraz konwersji między formatami plików bez zewnętrznych zależności. Niezaleznie od tego, czy budujesz mikrousługi, bezserwerowe funkcje czy aplikacje kontenerowe, IronXL integruje sie naturalnie z nowoczesnymi DevOps procesami.
Środowiska chmurowe wymagają lekkich, elastycznych rozwiązań. IronXL spełnia te wymagania, oferując natywną obsługę wdrożeń Docker, Azure Functions i AWS Lambda. Architektura biblioteki zapewnia minimalne zużycie zasobów przy zachowaniu wysokiej wydajności, co ma kluczowe znaczenie dla opłacalnej eksploatacji chmury. Możesz pracować z programem Excel bez korzystania z Interop, dzięki czemu wdrożenia są bardziej przejrzyste i wydajniejsze.
| Możliwości | Opis |
|---|---|
| Kompatybilność międzyplatformowa | Natywna obsługa systemów Windows, Linux i macOS |
| Gotowe do użycia w kontenerach | Zoptymalizowane pod kątem wdrożeń w środowiskach Docker i Kubernetes |
| Integracja natywna dla chmury | Działa płynnie z platformami bezserwerowymi |
| Brak zależności zewnętrznych | Samodzielna biblioteka bez wymagań dotyczących pakietu Office |
| Zoptymalizowana wydajność | Efektywne wykorzystanie pamięci w operacjach na dużą skalę |
Rozpoczęcie pracy z IronXL w projekcie .NET Core zajmuje zaledwie kilka minut. Biblioteka jest dostępna za pośrednictwem standardowych menedżerów pakietów i obsługuje wszystkie nowoczesne scenariusze wdrażania. Oto jak dodać IronXL do swojego projektu:
Lub użyj Console Managera Paczek w Visual Studio
Do instalacji specyficznej wersji (przydatne do reprodukowalnych buildów)
Lub dodaj to do swojego pliku .csproj, aby zarządzać paczkami deklaratywnie
<PackageReference Include="IronXL.Excel" Version="2024.12.0" />Po instalacji skonfiguruj klucz licencyjny do wdrożeń produkcyjnych. IronXL oferuje elastyczne opcje licencyjne dostosowane do różnych skal wdrożeń, od aplikacji na jednym serwerze po rozwiązania obejmujące całe przedsiębiorstwo. W przypadku aplikacji internetowych można skonfigurować licencję w pliku web.config w celu scentralizowanego zarządzania. Rozważ rozszerzenia licencji w celu skalowania aplikacji oraz opcje aktualizacji w miarę wzrostu potrzeb.
Podczas wdrażania w kontenerach należy wziąć pod uwagę następujące strategie optymalizacji zgodne z najlepszymi praktykami konfiguracji 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"]Oto praktyczny przykład ilustrujący podstawową funkcjonalność. Ten kod pokazuje, jak załadować istniejący plik Excel i zmodyfikować określone komórki:
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 ClassTen wzorzec doskonale sprawdza się w zautomatyzowanych procesach, ponieważ jest deterministyczny i nie wymaga interakcji użytkownika. Mozesz zaplanowac uruchamianie tego kodu w kontenerze, wyzwalane przez zdarzenia lub harmonogramy oparte na czasie, co czyni go idealnym dla DevOps scenariuszy automatyzacji. Możliwość otwierania arkuszy Excel i edytowania ich programowo zapewnia skuteczne możliwości automatyzacji.
Stworzenie niezawodnego rozwiązania do edycji plików Excel wymaga odpowiedniej konfiguracji projektu. Stwórzmy kompletny przykład, który pokazuje najlepsze praktyki dotyczące wdrożeń produkcyjnych, uwzględniając obsługę błędów i rejestrowanie:
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 ClassNiezawodna obsługa błędów ma kluczowe znaczenie dla wdrożeń produkcyjnych. Powyższy przykład ilustruje integrację logowania i prawidłową obsługę wyjątków, które są niezbędne do debugowania problemów w środowiskach kontenerowych, gdzie dostęp do środowiska uruchomieniowego może być ograniczony. Należy rozważyć wdrożenie środków bezpieczeństwa oraz sprawdzenie limitów rozmiaru plików w kontekście konkretnego zastosowania.
Przyjrzyjmy się różnym technikom modyfikacji wartości komórek, od prostych aktualizacji po złożone transformacje danych. IronXL zapewnia intuicyjne metody zapisywania wartości w komórkach programu Excel, obsługując jednocześnie różne typy i formaty danych. W razie potrzeby można również kopiować komórki i usuwać ich zawartość.
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 automatycznie wykrywa i konwertuje typy danych, ale wyraźne formatowanie zapewnia prawidłowe wyświetlanie. Biblioteka obsługuje ustawianie formatów danych komórek dla walut, wartości procentowych, dat i wzorów niestandardowych. Możesz zapoznać się z formatami liczb w programie Excel, aby uzyskać dostęp do zaawansowanych opcji formatowania. Dodatkowo można dostosować czcionki i rozmiary komórek, zastosować wzory i kolory tła oraz skonfigurować obramowania i wyrównanie komórek.
Operacje zbiorcze są niezbędne do wydajnego przetwarzania danych w programie Excel. IronXL zapewnia skuteczne funkcje zaznaczania zakresu, które ułatwiają jednoczesną aktualizację wielu komórek. W razie potrzeby można również dodawać wiersze i kolumny, wstawiać nowe wiersze i kolumny oraz łączyć komórki:
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 ClassOperacje na zakresach są wykonywane jako pojedyncze polecenia, a nie poprzez iterację po poszczególnych komórkach, co znacznie poprawia wydajność. Ta wydajność ma kluczowe znaczenie podczas przetwarzania dużych zbiorów danych lub pracy w środowiskach kontenerowych o ograniczonych zasobach. Możliwość wybierania i manipulowania zakresami umożliwia skuteczne przekształcanie danych przy minimalnym nakładzie kodu. Można również sortować zakresy komórek, przycinać je oraz łączyć wiele zakresów.
| Wzór | Składnia | Opis |
|---|---|---|
| Zakresy kolumn | "A:A" | Zaznacza całą kolumnę A |
| Zakresy wierszy | "1:1" | Zaznacza cały wiersz 1 |
| Zakresy prostokątne | "A1:C3" | Wybiera blok 3x3 |
| Zakresy nazwane | Tworzenie i używanie nazwanych zakresów | Dla jasności |
| Zakresy dynamiczne | Programowe tworzenie ciągów znaków zakresu | Elastyczny wybór |
Interaktywna edycja w programie Excel staje się skuteczna w połączeniu z danymi wprowadzanymi przez użytkownika lub zewnętrznymi źródłami danych. Takie podejście jest przydatne przy tworzeniu interfejsów API, które akceptują parametry i generują spersonalizowane raporty. Możesz chcieć importować dane z Excela z różnych źródeł lub eksportować je do różnych formatów:
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 ClassDla scenariuszy DevOps zintegrowanie przetwarzania Excel we wdrazaniu i budowaniu pipeline. W razie potrzeby można odczytywać pliki Excel w aplikacjach ASP.NET lub pracować z plikami Excel w VB.NET:
# 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/*.xlsxAby rozszerzyć możliwości automatyzacji programu Excel, zapoznaj się z poniższymi specjalistycznymi zasobami:
IronXL oferuje rozbudowaną funkcjonalność wykraczającą poza podstawową edycję komórek:
Weź pod uwagę następujące zaawansowane techniki:
Oto skonsolidowane źródło informacji na temat typowych operacji edycji w programie Excel:
| Działanie | Przykład kodu | Przykład zastosowania |
|---|---|---|
| Edytuj pojedynczą komórkę | sheet["A1"].Value = "New Value" | Zaktualizuj konkretne punkty danych |
| Zakres edycji | sheet["A1:C10"].Value = "Bulk Update" | Aktualizacje zbiorcze dla większej wydajności |
| Zastosowanie Formuły | sheet["D1"].Formula = "=SUM(A1:C1)" | Obliczenia dynamiczne |
| Formatowanie warunkowe | Zastosuj kolor na podstawie wartości | Wizualna analiza danych |
| Formatowanie daty | cell.FormatString = "yyyy-MM-dd" | Spójne wyświetlanie daty |
| Format waluty | cell.FormatString = "$#,##0.00" | Sprawozdawczość finansowa |
| Scałenie komórek | sheet["A1:C1"].Merge() | Utwórz nagłówki i tytuły |
| Automatyczne dopasowanie szerokości kolumn | sheet.AutoSizeColumn(0) | Popraw czytelność |
Ten kompletny przewodnik pokazuje, w jaki sposób IronXL upraszcza automatyzację Excela w środowiskach .NET Core. Niezależnie od tego, czy tworzysz mikrousługi, wdrażasz je w kontenerach, czy tworzysz funkcje bezserwerowe, IronXL zapewnia narzędzia niezbędne do wydajnego przetwarzania plików Excel bez zewnętrznych zależności. Rozpocznij wdrazanie tych wzorcow w swoich DevOps procesach dzisiaj, aby uproscic generowanie raportow i zadania przetwarzania danych.
Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
