Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronXL
  2. IronXL Blog
  3. IronXL verwenden
  4. .NET Core Excel
IRONXL VERWENDEN

Installation über die .NET -Befehlszeilenschnittstelle (empfohlen für CI/CD-Pipelines)

Jordi Bardia
Jordi Bardia
Aktualisiert:

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.

Warum IronXL für die .NET Core Excel-Entwicklung verwenden?

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 Funktion ist besonders wertvoll für DevOps Ingenieure, die die Berichtserstellung, Datenverarbeitungspipelines und CI/CD-Workflows automatisieren.

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, Serverless Functions oder Containerized Applications entwickeln, IronXL integriert sich nahtlos in moderne DevOps Workflows.

Warum IronXL für die Cloud-native Excel-Verarbeitung wählen?

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.

Hauptfunktionen für die Excel-Bearbeitung mit .NET Core

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

So installieren Sie die IronXL Bibliothek

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:

dotnet add package IronXL.Excel

# Or use Package Manager Console in Visual Studio
Install-Package IronXL.Excel

# For specific version installation (useful for reproducible builds)
dotnet add package IronXL.Excel --version 2024.12.0

# Add to your .csproj file for declarative package management
# <PackageReference Include="IronXL.Excel" Version="2024.12.0" />
dotnet add package IronXL.Excel

# Or use Package Manager Console in Visual Studio
Install-Package IronXL.Excel

# For specific version installation (useful for reproducible builds)
dotnet add package IronXL.Excel --version 2024.12.0

# Add to your .csproj file for declarative package management
# <PackageReference Include="IronXL.Excel" Version="2024.12.0" />
SHELL

Lizenzierung für die Produktion konfigurieren

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.

Verbesserung von IronXL für Containerumgebungen

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"]

Schnelles Ändern von Excel-Zellen in .NET Core

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!");
    }
}
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

Warum eignet sich dieses Muster ideal für die Automatisierung?

Dieses Muster eignet sich perfekt für automatisierte Arbeitsabläufe, da es deterministisch ist und keine Benutzerinteraktion erfordert. Dieser Code kann so geplant werden, dass er in einem Container ausgeführt wird, ausgelöst durch Ereignisse oder zeitbasierte Zeitpläne. Dadurch eignet er sich ideal für DevOps Automatisierungsszenarien. Die Möglichkeit , Excel-Arbeitsblätter programmatisch zu öffnen und zu bearbeiten, eröffnet effektive Automatisierungsmöglichkeiten.

Starten eines .NET Core Excel-Bearbeitungsprojekts

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

Bewährte Verfahren für den Umgang mit Fehlern

Eine 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.

Bearbeiten eines bestimmten Zellenwerts

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");
    }
}
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

Effizienter Umgang mit verschiedenen Datentypen

IronXL 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.

Mehreren Zellen Werte zuweisen

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");
    }
}
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

Effizienz des Schießstandbetriebs

Bereichsoperationen 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 .

Gängige Muster bei der Gebietsauswahl

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

Zellen mit Benutzereingaben bearbeiten

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

Integration der Excel-Bearbeitung in CI/CD-Pipelines

Für DevOps Szenarien integrieren Sie die Excel-Verarbeitung in Ihre Build- und Deployment-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/*.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

Zusätzliche Ressourcen zur Excel-Automatisierung

Um Ihre Excel-Automatisierungsmöglichkeiten zu erweitern, sollten Sie diese spezialisierten Ressourcen nutzen:

Erweiterte Funktionen zum Erkunden

IronXL bietet weit mehr als nur die grundlegende Zellenbearbeitung:

Verbesserung der Excel-Verarbeitungsabläufe

Betrachten Sie diese fortgeschrittenen Techniken:

Kurzanleitung zur Excel-Bearbeitung

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 damit, diese Muster in Ihre DevOps Workflows zu implementieren, um die Berichtserstellung und Datenverarbeitung zu vereinfachen.

Häufig gestellte Fragen

Was ist der Zweck der Verwendung von Excel in .NET Core-Anwendungen?

Excel wird in .NET Core-Anwendungen für effizientes Datenmanagement und -manipulation verwendet. IronXL ermöglicht es Entwicklern, Excel-Dateien programmgesteuert mit C# zu laden, zu bearbeiten und zu speichern, was die Produktivität und die Fähigkeiten zur Datenverarbeitung verbessert.

Wie kann ich die Excel-Bibliothek in einem .NET Core-Projekt installieren?

Sie können die IronXL-Bibliothek in einem .NET Core-Projekt installieren, indem Sie den NuGet-Paket-Manager mit dem Befehl dotnet add package IronXL.Excel verwenden. Alternativ können Sie die DLL-Datei direkt von der IronXL-Website herunterladen.

Welche Schritte sind erforderlich, um eine Excel-Datei in .NET Core zu laden?

Um eine Excel-Datei in .NET Core mit IronXL zu laden, verwenden Sie die WorkBook.Load-Methode. Zum Beispiel lädt WorkBook wb = WorkBook.Load("sample.xlsx"); das Excel-Arbeitsbuch namens 'sample.xlsx'.

Kann ich einen Zellbereich in einer Excel-Tabelle mit .NET Core bearbeiten?

Ja, mit IronXL können Sie einen Bereich von Zellen in einer Excel-Tabelle gleichzeitig bearbeiten. Verwenden Sie die Syntax ws["A1:A9"].Value = "neuer Wert";, um mehreren Zellen einen Wert zuzuweisen, wobei ws ein WorkSheet-Objekt ist.

Wie gehen Sie mit Benutzereingaben um, wenn Sie Excel-Dateien in .NET Core bearbeiten?

IronXL ermöglicht den Umgang mit Benutzereingaben, indem diese über die Konsole oder eine Benutzeroberfläche erfasst werden, die dann verwendet werden können, um den Zellbereich und den Wert für Aktualisierungen in der Excel-Tabelle zu definieren.

Welche Programmiersprache wird für die Excel-Manipulation in .NET Core verwendet?

C# wird verwendet, um Excel-Dateien programmgesteuert in .NET Core-Anwendungen mit der IronXL-Bibliothek zu manipulieren.

Gibt es ein Tutorial für die Arbeit mit Excel-Dateien in .NET Core?

Ja, umfassende Tutorials zum Lesen und Bearbeiten von Excel-Dateien mit C# und IronXL sind verfügbar. Weitere Ressourcen und Beispielprojekte finden Sie auf der IronXL-Website.

Welche Kompatibilitätsanforderungen gibt es für die Verwendung der Excel-Bibliothek in .NET Core?

IronXL unterstützt verschiedene Versionen von .NET Core. Detaillierte Kompatibilitätsinformationen finden Sie in der IronXL-Dokumentation auf ihrer Website.

Wo kann ich auf die API-Dokumentation für die Excel-Bibliothek zugreifen?

Die API-Dokumentation für IronXL ist online verfügbar und bietet Details zu allen Namespaces, Methoden und Funktionen. Besuchen Sie die IronXL-Website, um auf diese Ressource zuzugreifen.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an