資訊圖標
跳至頁尾內容
  1. IronXL
  2. IronXL 部落格
  3. using IronXL
  4. .NET Core Excel
USING IRONXL

透過 .NET CLI 安裝（建議用於 CI/CD 管線）

Curtis Chau
Curtis Chau
已更新:

IronXL允許開發者使用簡單的C#程式碼在.NET Core應用程式中修改Excel單元格，無需Microsoft Office。它支持單元格操作、範圍操作，並可部署於Windows、Linux和macOS。

為什麼選擇使用IronXL進行.NET Core Excel開發？

在.NET Core中處理Excel對於現代企業應用程式尤為重要，尤其是在以雲為基礎和容器化的環境中。 IronXL程式庫提供豐富的Excel功能，跨平台運行順暢，無需安裝Microsoft Office。 此功能對於自動化報告生成的DevOps工程師、資料處理管道和CI/CD工作流程特別有價值。

考慮一個典型場景：您的團隊需要從各種資料源生成月度性能報告，根據計算修改特定單元格，並在多個環境的Docker容器中部署這一功能。 傳統的Excel自動化需要在每個伺服器上安裝Office，導致授權問題和部署複雜性。 IronXL提供了一個自包含的解決方案，消除了這些障礙，並可在您所有的.NET Core應用程式運行的地方工作。

該程式庫擅長從頭建立電子表格、程式化管理工作表，以及在文件格式之間進行轉換，無需外部依賴。 無論您是在構建微服務、無伺服器函式還是容器化應用程式，IronXL可自然整合到現代DevOps工作流程中。

為什麼選擇IronXL進行雲原生Excel處理？

雲環境需要輕量靈活的解決方案。 IronXL提供支持Docker部署、Azure Functions和AWS Lambda的開箱即用功能。 該程式庫的架構確保了資源消耗最小化，同時保持高性能，這對於雲運營的成本效率至關重要。 您可以在不使用Interop的情況下使用Excel，使得部署更簡潔高效。

適用於.NET Core Excel編輯的關鍵功能

功能 描述
跨平台相容性 原生支持Windows、Linux和macOS
容器就緒 針對Docker和Kubernetes部署進行了優化
雲原生整合 在無伺服器平台上運行順暢
無外部依賴 無需Office要求的自包含程式庫
性能優化 對大規模操作進行高效的記憶體使用

如何安裝IronXL程式庫

在您的.NET Core專案中使用IronXL僅需幾分鐘。 該程式庫可通過標準的包管理器獲得，並支持所有現代部署場景。 這是將IronXL新增到您的專案中的方法：

dotnet add package IronXL.Excel

或在Visual Studio的Package Manager Console中使用

Install-Package IronXL.Excel

針對特定版本安裝（對於可重現性構建很有用）

dotnet add package IronXL.Excel --version 2024.12.0

或者，新增到您的.csproj文件以進行聲明式包管理

<PackageReference Include="IronXL.Excel" Version="2024.12.0" />

為生產配置授權

安裝後，請配置您的授權金鑰以進行生產部署。 IronXL提供靈活的授權選項，適合從單一伺服器應用到企業範圍的解決方案的不同部署規模。 對於web應用程式，您可以在web.config中配置授權金鑰以進行集中管理。 隨著需求的增長，考慮授權延伸以擴展應用程式，並考慮升級選項。

提升IronXL在容器環境中的應用

在部署到容器時，請考慮這些與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"]

快速修改.NET Core中的Excel單元格

這是演示核心功能的實用範例。 此程式碼演示如何載入現有Excel文件並修改特定單元格：

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!");
    }
}
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 Class
$vbLabelText   $csharpLabel

為什麼這種模式適合自動化？

這種模式在自動化工作流程中表現完美，因為它是確定性的，不需要使用者交互。 您可以將此程式碼安排在容器中運行，由事件或基於時間的計劃觸發，使其非常適合DevOps自動化場景。 能夠打開Excel工作表並程式化地編輯它們使得自動化具有有效的可能性。

開始.NET Core Excel編輯專案

構建可靠的Excel編輯解決方案需要正確的專案設置。讓我們建立一個完整的範例，展示生產部署的最佳實踐，融入錯誤處理和日誌記錄：

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
            }
        });
    }
}
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 Class
$vbLabelText   $csharpLabel

錯誤處理的最佳實踐

可靠的錯誤處理對生產部署至關重要。 上述例子展示了日誌整合和適當的異常處理，這對於除錯可能無法直接存取運行時的容器環境中的問題至關重要。考慮實施安全措施並檢查您的使用案例的文件大小限制。

編輯特定單元格的值

讓我們探索不同的技術來修改單元格值，從簡單的更新到複雜的資料轉換。 IronXL提供直觀的方法來將值寫入Excel單元格，同時支持各種資料型別和格式。 您還可以複製單元格和清除單元格內容。

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");
    }
}
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 Class
$vbLabelText   $csharpLabel

有效處理不同的資料型別

IronXL自動檢測和轉換資料型別，但明確的格式設置可確保適當的顯示。 該程式庫支持設置單元格資料格式，適用於貨幣、百分比、日期和自定義模式。 您可以瀏覽Excel數字格式以獲得更高級的格式化選項。 此外，您可以自定義單元格字體和大小，應用背景模式和顏色，以及配置單元格邊框和對齊。

為多個單元格分配值

批量操作對於高效的Excel處理至關重要。 IronXL提供有效的範圍選擇功能，使得同時更新多個單元格變得簡單。 您還可以新增行和列，插入新的行和列，以及合併單元格：

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");
    }
}
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 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 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 Class
$vbLabelText   $csharpLabel

範圍操作的效率

範圍操作以單一命令執行，而不是逐個遍歷單元格，顯著提高了性能。 在處理大型資料集或資源受限的容器環境中，這種效率尤為重要。 能夠選擇和操作範圍使得資料轉換變得有效，所需程式碼最少。 您還可以排序單元格範圍、修剪單元格範圍，並組合多個範圍。

常用範圍選擇模式

模式 語法 描述
列範圍 "A:A" 選擇整個列A
行範圍 "1:1" 選擇整行1
矩形範圍 "A1:C3" 選擇一個3x3區塊
命名範圍 建立並使用命名範圍 為清晰度
動態範圍 程式化構建範圍字串 為靈活選擇

使用使用者輸入編輯單元格

結合使用者輸入或外部資料來源的互動式Excel編輯變得有效。 這種方法對於構建接受參數並生成自定義報告的API非常有價值。 您可能需要從不同來源導入Excel資料或導出不同格式：

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);
    }
}
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
                        End If

                        If rangeUpdate.Style.Bold Then
                            range.Style.Font.Bold = True
                        End If

                        If Not String.IsNullOrEmpty(rangeUpdate.Style.NumberFormat) Then
                            range.FormatString = rangeUpdate.Style.NumberFormat
                        End If
                    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 Class
$vbLabelText   $csharpLabel

將Excel編輯整合到CI/CD流水線

對於DevOps場景，將Excel處理整合到您的構建和部署流水線中。 您可以在ASP.NET應用程式中讀取Excel文件，或在需要時處理VB.NET Excel文件：

# 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

更多Excel自動化資源

要擴展您的Excel自動化能力，請探索這些專門資源：

探索高級功能

IronXL提供超越基本單元格編輯的豐富功能：

提升Excel處理工作流程

考慮這些高級技術：

Excel編輯的快速參考指南

這是一個合併的常見Excel編輯操作參考：

操作 程式碼範例 用例
單一單元格編輯 sheet["A1"].Value = "New Value" 更新特定資料點
範圍編輯 sheet["A1:C10"].Value = "Bulk Update" 批量更新，提高效率
公式應用 sheet["D1"].Formula = "=SUM(A1:C1)" 動態計算
條件格式化 基於值的顏色應用 可視化資料分析
日期格式化 cell.FormatString = "yyyy-MM-dd" 一致的日期顯示
貨幣格式 cell.FormatString = "$#,##0.00" 財務報告
合併單元格 sheet["A1:C1"].Merge() 建立標題和標題
自動調整列寬 sheet.AutoSizeColumn(0) 提高可讀性

這份完整指南展示了如何使用IronXL簡化.NET Core環境中的Excel自動化。 無論您是在構建微服務、部署到容器還是建立無伺服器函式，IronXL都提供了進行高效Excel處理所需的工具，無需外部依賴。 立即在您的DevOps工作流程中實施這些模式，以簡化報告生成和資料處理任務。

常見問題

在.NET Core應用程式中使用Excel的目的是什麼？

在.NET Core應用程式中使用Excel是為了高效管理和操作資料。IronXL允許開發者透過C#程式設計載入、編輯及儲存Excel檔案，增進生產力和資料處理能力。

如何在.NET Core專案中安裝Excel程式庫？

您可以透過使用NuGet套件管理員的命令安裝IronXL程式庫：dotnet add package IronXL.Excel。或者，您可以直接從IronXL網站下載DLL檔案。

在.NET Core中載入Excel檔案的步驟是什麼？

要在.NET Core中使用IronXL載入Excel檔案，使用WorkBook.Load方法。例如，WorkBook wb = WorkBook.Load("sample.xlsx");將載入名為'sample.xlsx'的Excel工作簿。

我可以在.NET Core中編輯Excel工作表的儲存格範圍嗎？

是的，使用IronXL，您可以同時編輯Excel工作表中的儲存格範圍。使用語法ws["A1:A9"].Value = "new value";為多個儲存格分配值，其中ws是一個WorkSheet物件。

在.NET Core中編輯Excel檔案時如何處理使用者輸入？

IronXL允許透過控制台或使用者介面捕捉使用者輸入，然後可用於定義Excel試算表中更新的儲存格範圍和值。

在.NET Core中操作Excel使用的是什麼程式語言？

使用IronXL程式庫在.NET Core應用程式中以程式方式操作Excel檔案使用C#。

是否有在.NET Core中操作Excel檔案的教學？

是的，可用的綜合教學涉及使用C#和IronXL讀取及操作Excel檔案。額外資源和範例專案可以在IronXL網站上找到。

使用.NET Core中的Excel程式庫的相容性要求是什麼？

IronXL支持多個版本的.NET Core。詳細的相容性資訊可以在IronXL網站上的文件中找到。

我從哪裡可以存取Excel程式庫的API文件？

IronXL的API文件可在網上獲得，並提供有關所有命名空間、方法和功能的詳細資訊。存取IronXL網站查看此資源。

Curtis Chau
Curtis Chau
  立即與工程團隊聊天
技術作家

Curtis Chau擁有Carleton大學的電腦科學學士學位，專精於前端開發，擁有Node.js、TypeScript、JavaScript和React的專業知識。Curtis熱衷於建立直觀且美觀的使用者介面，喜愛使用現代框架並建立結構良好、視覺吸引力的手冊。

除了開發，Curtis對物聯網（IoT）有濃厚的興趣，探索創新的方法來整合硬體和軟體。在空閒時間，他喜歡玩遊戲和建立Discord機器人，結合他對技術的熱愛與創造力。

相關文章

30天試用→完整產品。無限制。無需信用卡。 開始免費試用

Iron 支援團隊

我們線上24小時，每週5天。
聊天
電子郵件
給我打電話