VERGLEICH MIT ANDEREN KOMPONENTEN

Ein Vergleich zwischen IronXL und GrapeCity Excel Viewer

Veröffentlicht 9. Juni 2022

Teilen Sie:

Die Verwendung von Excel-Daten in einer Programmiersituation mit einer .NET-Umgebung kann eine Reihe von Problemen verursachen, insbesondere wenn es um Interoperabilität geht.

Excel ist das am häufigsten verwendete Tabellenkalkulationsprogramm der Welt. Zu den Nutzern gehören sowohl Entwickler als auch die breite Öffentlichkeit, aber Entwickler sind wahrscheinlich eher an diesen Inhalten interessiert. Ursprünglich hatten Entwickler nicht viele Alternativen, um Excel in ihre verschiedenen Anwendungen zu integrieren. Die Office Suite enthielt jedoch VBA (Visual Basic für Anwendungen)mit dem Sie jedes Office-Produkt an Ihre Bedürfnisse anpassen können.

Entwickler haben ihre Interaktion mit XLSX-Tabellen und deren Daten sowie die visuellen Funktionen mit VBA in Excel angepasst.

Was ist GrapeCity Documents for Excel?

GrapeCity Documents for Excel .NET Edition ist eine neue leistungsstarke Tabellenkalkulationskomponente mit geringem Platzbedarf, die in Server- oder Desktop-Anwendungen eingesetzt werden kann. Es bietet eine reichhaltige API für die Erstellung, Bearbeitung, Konvertierung und gemeinsame Nutzung von Microsoft Excel-kompatiblen Tabellenkalkulationen. Sie können es auch aus fast jeder Anwendung oder Plattform wie Angular, React oder Vue verwenden, um benutzerdefinierte Stile zu erstellen.

Sie verfügt über eine nahtlos eingebettete BI-Plattform wyn mit interaktiven Dashboards, Planungs- und Verteilungswerkzeugen in jeder internen oder kommerziellen Anwendung.

Die eingebettete BI-Plattform von GrapeCity bietet eine grenzenlose visuelle Hochgeschwindigkeits-Datenexploration, die es dem alltäglichen Benutzer ermöglicht, datengesteuert zu werden und mit Hilfe der BI-Ad-hoc-Berichterstattung und interaktiven Dashboards problemlos Lösungen mit umfangreichen Daten zu erstellen.

GcExcel .NET ist mit einer Vielzahl von Plattformen kompatibel, darunter das .NET-Framework, .NET Core und Mono, was es zur idealen Wahl für alle Ihre Tabellenkalkulationsanforderungen macht.

Das Beste an GcExcel .NET ist, dass seine schnittstellenbasierte API auf dem Dokumentenobjekt-Paradigma von Excel aufbaut. So können die Benutzer jederzeit beliebige Tabellenkalkulationsszenarien importieren, berechnen, abfragen, erstellen und exportieren. Darüber hinaus können in den importierten oder erzeugten Tabellenblättern u. a. umfassende Berichte, Sortier- und Filtertabellen, Sortier- und Filter-Pivot-Tabellen, Diagramme, Sparklines, bedingte Formate und Dashboard-Berichte referenziert werden.

Was bietet Ihnen GrapeCity Documents for Excel?

Ermöglicht die Erstellung, Manipulation und Serialisierung von Tabellenkalkulationen auf dem Server.
Geringer Speicherbedarf.
Führt komplexe Berechnungen mit Hilfe des leistungsstarken Berechnungsprogramms durch.
Intuitives Hochgeschwindigkeitsdokument; eingebettete Business Intelligence.
Bietet umfassende Lösungen für die Berichterstattung.
Ermöglicht Ihnen die volle Kontrolle über Ihre Dokumente bei hoher Geschwindigkeit.
Erzeugt Ausgaben in einer Vielzahl von Formaten, einschließlich.xlsx und ssjson.
Unterstützung für .NET-Framework, .NET Core und Mono auf mehreren Plattformen.
Kompatibel mit Winforms, WPF, ASP .NET und anderen Umgebungen.

GrapeCity Excel - herausragende Merkmale

Die neueste Version 14.1 bietet viele neue und interessante Funktionen.

Leichtgewichtige Tabellenkalkulations-API-Architektur für verbesserte Effizienz

GcExcel .NET ermöglicht es Anwendern, eine beträchtliche Menge an Zeit, Speicherplatz und Aufwand zu sparen, indem es die Gesamteffizienz mit seiner leichtgewichtigen API-Architektur verbessert, die zum Erzeugen, Laden, Bearbeiten, Speichern und Konvertieren von Tabellenkalkulationen verwendet werden kann.
Keine Abhängigkeit von MS Excel

Um mit GcExcel .NET arbeiten zu können, müssen die Benutzer weder die MS Office Suite installieren noch auf MS Excel zugreifen.
Erstellen Sie ein interaktives Erlebnis mit SpreadJS DSheets

GcExcel .NET kann mit Tabellenkalkulationen verwendet werden, um eine vollständig interaktive und benutzerfreundliche Tabellenkalkulation zu ermöglichen.
Apps mit Excel-Tabellen in der Cloud bereitstellen

Mit GcExcel .NET können Sie Cloud-basierte Bereitstellungen durchführen und Ihre Anwendungen auf Azure und AWS Lambda bereitstellen.
Formen und Bilder

Mit der Tabellenkalkulations-API können Sie Formen und Bilder in die Zellen eines Arbeitsblatts einfügen und anpassen, Formatierungen und Farbverläufe anwenden, Text konfigurieren, Hyperlinks einfügen, Anpassungspunkte für die Formen festlegen, sie in einem Arbeitsblatt gruppieren/entgruppieren und die Position und Größe eines Bildes bestimmen.

Was ist IronXL?

IronXL ist eine C#-Bibliothek, die das Lesen und Bearbeiten von Microsoft Excel-Dokumenten erleichtert. IronXL. Excel ist eine .NET-Softwarebibliothek, die eine Vielzahl von Tabellenkalkulationsformaten lesen kann. Es erfordert weder die Installation von Microsoft Excel, noch ist es auf Interop angewiesen.

IronXL ist eine benutzerfreundliche C#-API, mit der Sie Excel-Dateien in .NET in rasender Geschwindigkeit lesen, bearbeiten und generieren können. .NET Core, .NET-Framework, Xamarin, Mobile, Linux, macOS und Azure werden alle von IronXL unterstützt.

IronXL ist eine C# Excel-Tabellenbibliothek für .NET Core und .NET-Framework.

IronXL Funktionsumfang

Daten laden, lesen und bearbeiten - aus XLS/XLSX/CSV/TSV
Speichern und Exportieren - in XLS/XLSX/CSV/TSV/JSON
System.Data-Objekte - Arbeiten Sie mit Excel-Arbeitsblättern als System.Data.DataSet- und System.Data.DataTable-Objekte.
Formeln - arbeitet mit Excel-Formeln. Formeln werden jedes Mal neu berechnet, wenn ein Blatt bearbeitet wird.
Bereiche - Einfach zu verwendendes WorkSheet ["A1:B10"] syntax. Kombinieren und erstellen Sie Bereiche intuitiv.
Sortieren - Sortieren von Bereichen, Spalten und Zeilen.
Styling - Visuelle Stile für Zellen, Schriftart, Größe, Hintergrundmuster, Rahmen, Ausrichtung und Zahlenformate.

Installation von GrapeCity-Dokumenten für Excel

Um GcExcel .NET in einer .NET Core-, ASP .NET Core- oder .NET-Framework-Anwendung verwenden zu können (jedes Ziel, das .NET-Standard 2.0 unterstützt)installieren Sie die NuGet-Pakete mit den folgenden Schritten in Ihrer Anwendung:

So finden und installieren Sie das NuGet-Paket GrapeCity.Documents.Excel

Wählen Sie NuGet-Pakete verwalten aus dem Kontextmenü von Abhängigkeiten oder einem Projekt im Projektmappen-Explorer.
Wählen Sie nuget.org aus der Dropdown-Liste Paketquelle auf der Registerkarte Durchsuchen.
Suchen Sie auf der Registerkarte Durchsuchen nach dem Paket "GrapeCity.Documents.Excel", indem Sie "grapecity.documents" oder "GrapeCity.Documents" in das obere Suchfeld eingeben.
Klicken Sie auf Installieren, um das Paket GrapeCity.Documents.Excel und seine Abhängigkeiten im Projekt zu installieren. Wenn die Installation abgeschlossen ist, stellen Sie sicher, dass Sie den NuGet-Ordner in Ihrem Projektmappen-Explorer überprüfen und bestätigen, ob das GrapeCity.Documents.Excel-Paket zu Ihren Projektabhängigkeiten hinzugefügt wurde oder nicht.

IronXL C# Bibliothek Installation

Sie können die IronXL-Bibliothek mit den folgenden Methoden herunterladen und installieren:

Verwendung von Visual Studio mit NuGet-Paketen.
Laden Sie das NuGet-Paket direkt herunter.
Manuelle Installation mit der DLL.

Schauen wir uns jede einzelne davon genauer an.

Verwendung von Visual Studio mit NuGet-Paketen

Visual Studio bietet den NuGet Package Manager, um NuGet-Pakete in Ihren Projekten zu installieren. Sie können über das Projektmenü darauf zugreifen, oder indem Sie mit der rechten Maustaste auf Ihr Projekt im Projektmappen-Explorer klicken.

Dann suchen Sie auf der Registerkarte Durchsuchen -> IronXL.Excel -> Installieren
Und wir sind fertig.

Verwendung der NuGet-Paketmanager-Konsole

Eine andere Möglichkeit, die Microsoft.Office.Interop.Excel C#-Bibliothek herunterzuladen und zu installieren, ist die Verwendung der folgenden Schritte, um das NuGet-Paket über die Eingabeaufforderung für Entwickler zu installieren.

Öffnen Sie die Developer-Eingabeaufforderung, die sich normalerweise im Ordner Visual Studio befindet.
Geben Sie den folgenden Befehl ein:

PM> Install-Package Microsoft.Office.Interop.Excel

* Drücken Sie die Eingabetaste.
* Dadurch wird das Paket heruntergeladen und installiert.
* Laden Sie Ihr Visual Studio-Projekt neu und verwenden Sie es.

### Notwendige Verwendungsrichtlinien hinzufügen

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei Program.cs und dann auf Code anzeigen.

2. Fügen Sie die folgenden using-Direktiven am Anfang der Codedatei hinzu:

using Excel = Microsoft.Office.Interop.Excel;


## Erstellen von Excel-Arbeitsmappen und -Blättern

Eine Arbeitsmappe ist eine Excel-Datei, die viele Zeilen und Spalten von Arbeitsblättern enthält. Die Möglichkeit, eine neue Excel-Arbeitsmappe und Blätter zu erstellen, ist in beiden Bibliotheken verfügbar. Schauen wir uns den Code Schritt für Schritt an.

### Erstellen von Excel-Dateien mit IronXL

Die Erstellung einer neuen Excel-Arbeitsmappe mit IronXL ist denkbar einfach. Nur eine Zeile Code! Ja, wirklich. Fügen Sie den folgenden Code zu Ihrer static void main-Funktion in der Datei Program.cs hinzu:

```cs
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

Beide XLS (ältere Excel-Datei-Version) und XLSX (aktuelle und neuere Dateiversion) dateiformate können mit IronXL erstellt werden.

Und es ist sogar noch einfacher, ein Standard-Arbeitsblatt zu erstellen:

var worksheet = workbook.CreateWorkSheet("IronXL Features");

var worksheet = workbook.CreateWorkSheet("IronXL Features");

Dim worksheet = workbook.CreateWorkSheet("IronXL Features")

VB C#

Sie können nun die Arbeitsblattvariable verwenden, um Zellwerte zu setzen und praktisch alles zu tun, was eine Excel-Datei tun kann.

Erstellen von Excel-Dateien mit einer serverseitigen Excel-API GrapeCity excel

GrapeCity-Dokumente für Excel (oder GcExcel) ist eine serverseitige Excel-API, die das Erstellen, Laden, Speichern, Konvertieren, Berechnen, Formatieren, Parsen und Exportieren von Tabellenkalkulationen in jeder .NET-Standard-Anwendung ermöglicht. Dank der vollständigen .NET5-Unterstützung für Windows, Linux und Mac kann GcExcel ohne jegliche Excel-Abhängigkeiten auf Azure bereitgestellt werden.

Mit GcExcel können Sie serverseitige Excel-Tabellen erstellen und generieren, ohne MS Excel verwenden zu müssen.

Erstellen Sie eine Arbeitsmappe mit GcExcel in einer Funktion.
Rückkehr zur Client-Seite nach der Konvertierung der Arbeitsmappe in JSON.

In diesem Beispiel werden wir lediglich eine Tabelle BidTracker.xlsx erstellen. Dieses Beispiel zeigt zusätzliche serverseitige Funktionen, die mit GcExcel programmiert werden können.

[HttpGet("{caseName}")]
public IActionResult GetSSJsonFromUseCase(string caseName)
{
Workbook workbook = CreateWorkbookByCaseName(caseName);
var ssjson = workbook.ToJson();
return Ok(ssjson);
}

        private Workbook CreateWorkbookByCaseName(string caseName)
        {
            switch (caseName)
            {
                case "BidTracker":
                    return GetBidTracker();
                default:
                    break;
            }

            return new Workbook();
        }
}

[HttpGet("{caseName}")]
public IActionResult GetSSJsonFromUseCase(string caseName)
{
Workbook workbook = CreateWorkbookByCaseName(caseName);
var ssjson = workbook.ToJson();
return Ok(ssjson);
}

        private Workbook CreateWorkbookByCaseName(string caseName)
        {
            switch (caseName)
            {
                case "BidTracker":
                    return GetBidTracker();
                default:
                    break;
            }

            return new Workbook();
        }
}

<HttpGet("{caseName}")>
Public Function GetSSJsonFromUseCase(ByVal caseName As String) As IActionResult
Dim workbook As Workbook = CreateWorkbookByCaseName(caseName)
Dim ssjson = workbook.ToJson()
Return Ok(ssjson)
End Function

		Private Function CreateWorkbookByCaseName(ByVal caseName As String) As Workbook
			Select Case caseName
				Case "BidTracker"
					Return GetBidTracker()
				Case Else
			End Select

			Return New Workbook()
		End Function
}

VB C#

Excel-Dateien bearbeiten

Entwickler müssen vorsichtig sein, wenn sie mit dem Ändern und Bearbeiten von Excel-Dateien in C# beginnen, da ein einziger Fehler leicht das gesamte Dokument verändern kann. Die Möglichkeit, sich auf einfache und effiziente Codezeilen zu verlassen, verringert die Gefahr von Fehlern und erleichtert es uns, Excel-Dateien programmatisch zu aktualisieren oder zu löschen. Heute werden wir die Verfahren durchgehen, die notwendig sind, um Excel-Dateien in C# genau und schnell zu bearbeiten, indem wir getestete Funktionen verwenden.

Excel-Dateien mit GrapeCity Excel bearbeiten

Lassen Sie uns mit GcExcel und Java beginnen, um diese Probleme zu lösen.

Sie erhalten ein Arbeitsblatt, das so aussieht:

Zunächst müssen wir das Blatt formatieren:

Ändern Sie die Schrifteigenschaften des Titels des Blattes und der Zelle Gesamteinkommen.
Ändern Sie Tabellen-, Tabellenspalten- und Zellenformate.

Schauen wir uns an, wie man dies mit GcExcel und Java erreichen kann.

Schritt 1: Laden Sie ein vorhandenes Excel-Tabellenblatt

Schreiben Sie den folgenden Code, um ein vorhandenes Arbeitsblatt in Ihre GcExcel-Arbeitsmappe zu laden:

Workbook workbook = new Workbook();
workbook.open("Event budget.xlsx");

Workbook workbook = new Workbook();
workbook.open("Event budget.xlsx");

Dim workbook As New Workbook()
workbook.open("Event budget.xlsx")

VB C#

Schritt 2: Holen Sie das Arbeitsblatt, das Sie ändern möchten

IWorksheet worksheet = workbook.getActiveSheet();

IWorksheet worksheet = workbook.getActiveSheet();

Dim worksheet As IWorksheet = workbook.getActiveSheet()

VB C#

Schritt 3: Ändern Sie die Schrifteigenschaften der Titel

Ändern Sie die Schrifteigenschaften von B2 (schriftgröße) und E4 (fett setzen) zellen:

//change range B2s font size.
worksheet.getRange("B2").getFont().setSize(22);

//change range E4s font style to bold.
worksheet.getRange("E4").getFont().setBold(true);

//change range B2s font size.
worksheet.getRange("B2").getFont().setSize(22);

//change range E4s font style to bold.
worksheet.getRange("E4").getFont().setBold(true);

'change range B2s font size.
worksheet.getRange("B2").getFont().setSize(22)

'change range E4s font style to bold.
worksheet.getRange("E4").getFont().setBold(True)

VB C#

Schritt 4: Tabellenstil ändern

Setzen Sie die Stile der vier Tabellen auf einen eingebauten Stil.

worksheet.getTables().get("tblAdmissions").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblAds").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblVendors").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblItems").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));

worksheet.getTables().get("tblAdmissions").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblAds").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblVendors").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblItems").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));

worksheet.getTables().get("tblAdmissions").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"))
worksheet.getTables().get("tblAds").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"))
worksheet.getTables().get("tblVendors").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"))
worksheet.getTables().get("tblItems").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"))

VB C#

Schritt 5: Ändern des Zellbereichsstils

Ändern Sie das Zellformat der Zellen für das Gesamteinkommen. Die Funktion getInterior() methode eines Bereichs können Sie die Eigenschaften ThemeColor und TintAndShade einstellen. Sie können auch die Schriftart für den gesamten Bereich ändern, indem Sie die Funktion getFont() methode. Darüber hinaus kann dieser Code die Grenzen eines Bereichs von Zellen festlegen.

Da die Kalkulationstabelle die Budgetdaten anzeigt, stellen Sie das Zahlenformat eines Zellbereichs auf Währung ein.

//modify range F4:G5's cell style.
worksheet.getRange("F4:G5").getInterior().setThemeColor(ThemeColor.Light1);
worksheet.getRange("F4:G5").getInterior().setTintAndShade(-0.15);
worksheet.getRange("F4:G5").getFont().setThemeFont(ThemeFont.Major);
worksheet.getRange("F4:G5").getFont().setSize(12);  worksheet.getRange("F4:G5").getBorders().get(BordersIndex.InsideHorizontal).setLineStyle(BorderLineStyle.None);
worksheet.getRange("F5:G5").setNumberFormat("$#,##0.00");

//modify range F4:G5's cell style.
worksheet.getRange("F4:G5").getInterior().setThemeColor(ThemeColor.Light1);
worksheet.getRange("F4:G5").getInterior().setTintAndShade(-0.15);
worksheet.getRange("F4:G5").getFont().setThemeFont(ThemeFont.Major);
worksheet.getRange("F4:G5").getFont().setSize(12);  worksheet.getRange("F4:G5").getBorders().get(BordersIndex.InsideHorizontal).setLineStyle(BorderLineStyle.None);
worksheet.getRange("F5:G5").setNumberFormat("$#,##0.00");

'modify range F4:G5's cell style.
worksheet.getRange("F4:G5").getInterior().setThemeColor(ThemeColor.Light1)
worksheet.getRange("F4:G5").getInterior().setTintAndShade(-0.15)
worksheet.getRange("F4:G5").getFont().setThemeFont(ThemeFont.Major)
worksheet.getRange("F4:G5").getFont().setSize(12)
worksheet.getRange("F4:G5").getBorders().get(BordersIndex.InsideHorizontal).setLineStyle(BorderLineStyle.None)
worksheet.getRange("F5:G5").setNumberFormat("$#,##0.00")

VB C#

Schritt 6: Ändern von Tabellenspaltenstilen

Da die Spaltenbereiche der Tabelle unterschiedlich sind, legen Sie die Eigenschaften ThemeColor, TintAndShade und NumberFormat auf einen anderen Spaltenbereich der Tabelle fest.

worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setThemeColor(ThemeColor.Light1);
worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setTintAndShade(-0.15);
worksheet.getRange("E8:G11, E15:G18, E22:G25, E29:G33").setNumberFormat("$#,##0.00");

worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setThemeColor(ThemeColor.Light1);
worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setTintAndShade(-0.15);
worksheet.getRange("E8:G11, E15:G18, E22:G25, E29:G33").setNumberFormat("$#,##0.00");

worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setThemeColor(ThemeColor.Light1)
worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setTintAndShade(-0.15)
worksheet.getRange("E8:G11, E15:G18, E22:G25, E29:G33").setNumberFormat("$#,##0.00")

VB C#

Schritt 7: Speichern der Excel-Datei

//save to an excel file
workbook.save("EventBudget.xlsx");

//save to an excel file
workbook.save("EventBudget.xlsx");

'save to an excel file
workbook.save("EventBudget.xlsx")

VB C#

Herzlichen Glückwunsch! Sie haben die Formatierung des Dokuments vollständig geändert. Führen Sie die Anwendung aus, und Ihr Excel-Arbeitsblatt sieht wie folgt aus:

Excel-Dateien mit IronXL bearbeiten

Nachdem Sie IronXL installiert haben, wollen wir uns nun mit der Bearbeitung von Excel-Dateien befassen.

Bearbeiten der Werte bestimmter Zellen

Zunächst sehen wir uns an, wie man die Werte bestimmter Zellen in einer Excel-Tabelle ändern kann.

Dazu importieren wir das zu ändernde Excel-Arbeitsblatt und greifen auf dessen WorkSheet zu. Dann können wir die Änderungen wie unten angegeben vornehmen.

using IronXL;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");//import Excel SpreadSheet
WorkSheet ws = wb.GetWorkSheet("Sheet1");//access specific workshet
ws.Rows [3].Columns [1].Value = "New Value";//access specific cell and modify its value
wb.SaveAs("sample.xlsx");//save changes
}

using IronXL;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");//import Excel SpreadSheet
WorkSheet ws = wb.GetWorkSheet("Sheet1");//access specific workshet
ws.Rows [3].Columns [1].Value = "New Value";//access specific cell and modify its value
wb.SaveAs("sample.xlsx");//save changes
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
Dim wb As WorkBook = WorkBook.Load("sample.xlsx") 'import Excel SpreadSheet
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1") 'access specific workshet
ws.Rows (3).Columns (1).Value = "New Value" 'access specific cell and modify its value
wb.SaveAs("sample.xlsx") 'save changes
End Sub

VB C#

Hier sind die Vorher- und Nachher-Screenshots der Excel-Tabelle sample.xlsx:

Wir können sehen, wie einfach es ist, den Wert in der Excel-Tabelle zu ändern.

Bei Bedarf gibt es auch eine alternative Möglichkeit, den spezifischen Zellwert über die Zelladresse zu bearbeiten:

ws ["B4"].Value = "New Value"; //alternative way to access specific cell and apply changes

ws ["B4"].Value = "New Value"; //alternative way to access specific cell and apply changes

ws ("B4").Value = "New Value" 'alternative way to access specific cell and apply changes

VB C#

Vollständige Zeilenwerte bearbeiten

Es ist ziemlich einfach, ganze Zeilenwerte einer Excel-Tabelle mit einem statischen Wert zu bearbeiten.

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    ws.Rows [3].Value = "New Value";            
    wb.SaveAs("sample.xlsx");
}

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    ws.Rows [3].Value = "New Value";            
    wb.SaveAs("sample.xlsx");
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	ws.Rows (3).Value = "New Value"
	wb.SaveAs("sample.xlsx")
End Sub

VB C#

Siehe die Screenshots der sample.xlsx unten:

Zu diesem Zweck können wir auch den Wert eines bestimmten Bereichs der Zeile bearbeiten, indem wir die Bereichsfunktion verwenden:

ws ["A3:E3"].Value = "New Value";

ws ["A3:E3"].Value = "New Value";

ws ("A3:E3").Value = "New Value"

VB C#

Vollständige Spaltenwerte bearbeiten

Auf die gleiche Weise wie oben können wir ganze Spalten der Excel-Tabelle mit einem einzigen Wert bearbeiten.

using IronXL;static void Main(string [] args){    WorkBook wb = WorkBook.Load("sample.xlsx");    WorkSheet ws = wb.GetWorkSheet("Sheet1");    ws.Columns [1].Value = "New Value";    wb.SaveAs("sample.xlsx");}

using IronXL;static void Main(string [] args){    WorkBook wb = WorkBook.Load("sample.xlsx");    WorkSheet ws = wb.GetWorkSheet("Sheet1");    ws.Columns [1].Value = "New Value";    wb.SaveAs("sample.xlsx");}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	ws.Columns (1).Value = "New Value"
	wb.SaveAs("sample.xlsx")
End Sub

VB C#

Dadurch wird unser Arbeitsblatt sample.xlsx als solches erstellt:

Bearbeiten ganzer Zeilen mit dynamischen Werten

Mit IronXL ist es auch möglich, bestimmte Zeilen mit dynamischen Werten zu bearbeiten. Das bedeutet, dass wir eine ganze Zeile bearbeiten können, indem wir jeder Zelle dynamische Werte zuweisen. Schauen wir uns das Beispiel an:

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    for (int i = 0; i < ws.Columns.Count(); i++)    {        
        ws.Rows [3].Columns [i].Value = "New Value "+i.ToString();    
    }            
    wb.SaveAs("sample.xlsx");
}

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    for (int i = 0; i < ws.Columns.Count(); i++)    {        
        ws.Rows [3].Columns [i].Value = "New Value "+i.ToString();    
    }            
    wb.SaveAs("sample.xlsx");
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	For i As Integer = 0 To ws.Columns.Count() - 1
		ws.Rows (3).Columns (i).Value = "New Value " & i.ToString()
	Next i
	wb.SaveAs("sample.xlsx")
End Sub

VB C#

In der nachstehenden Tabelle sind die Screenshots der Excel-Tabelle sample.xlsx aus dieser Ausgabe zu sehen:

Bearbeitung ganzer Spalten mit dynamischen Werten

Es ist auch einfach, bestimmte Spalten mit dynamischen Werten zu bearbeiten.

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    for (int i = 0; i < ws.Rows.Count(); i++)    {        
        if (i == 0) //it is for if our first column is used as a header            
            continue;        

        ws.Rows [i].Columns [1].Value = "New Value " + i.ToString();
    }    
    wb.SaveAs("sample.xlsx");
}

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    for (int i = 0; i < ws.Rows.Count(); i++)    {        
        if (i == 0) //it is for if our first column is used as a header            
            continue;        

        ws.Rows [i].Columns [1].Value = "New Value " + i.ToString();
    }    
    wb.SaveAs("sample.xlsx");
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	For i As Integer = 0 To ws.Rows.Count() - 1
		If i = 0 Then 'it is for if our first column is used as a header
			Continue For
		End If

		ws.Rows (i).Columns (1).Value = "New Value " & i.ToString()
	Next i
	wb.SaveAs("sample.xlsx")
End Sub

VB C#

Mit der Tabelle Ergebnisse der sample.xlsx unten:

Volle Spalten mit dynamischen Werten bearbeiten

Es ist auch einfach, bestimmte Spalten mit dynamischen Werten zu bearbeiten.

using IronXL;static void Main(string [] args){ WorkBook wb = WorkBook.Load("beispiel.xlsx"); Arbeitsblatt ws = wb.GetWorkSheet("Blatt1"); für (int i = 0; i < ws.Rows.Count(); i++) { wenn (i == 0)//für den Fall, dass unsere erste Spalte als Überschrift verwendet wird weiter; ws.Zeilen [i]kolumnen [1].Value = "Neuer Wert " + i.ToString(); } wb.SaveAs("beispiel.xlsx");}

Mit der Tabelle Ergebnisse der sample.xlsx unten:

Tabellenkalkulationen in PDF, XML und JSON konvertieren

Verwenden Sie eine Excel-API, um Tabellenkalkulationen in Java-Anwendungen zu erstellen? Bei der Arbeit mit Daten kommt es vor, dass Sie Ihre Daten nicht in einem Excel-Tabellenblatt speichern möchten. Stattdessen benötigen Sie eine PDF-Datei.

Es gibt mehrere Gründe, warum Sie Daten nicht in einer Excel-Tabelle speichern sollten:

Sie brauchen eine langfristige Erhaltung.
Sie haben Microsoft Office nicht auf Ihrem System installiert, möchten aber dennoch Ihre Excel-Tabellen drucken oder verteilen.
Sie müssen Ihre Tabellenkalkulation freigeben und Ihre Formatierung beibehalten. Sie möchten, dass Ihre Excel-Tabellen beim Öffnen auf verschiedenen Systemen genau gleich aussehen.

GrapeCity zum Konvertieren von Tabellenkalkulationen in PDF verwenden

GrapeCity-Dokumente für Excel, Java-Ausgabe (GcExcel Java) ist eine schnelle, platzsparende Tabellenkalkulations-API, die keine Abhängigkeiten in Excel erfordert. Mit voller Unterstützung für Windows, Linux und MAC können Sie Tabellen erstellen, laden, ändern und speichern und sie dann in ein PDF konvertieren.

Hier sind die drei Schritte für die Konvertierung von Tabellenkalkulationen in PDFs in Java-Anwendungen:

Laden eines vorhandenen Excel-Arbeitsblatts in eine GcExcel-Arbeitsmappe
PDFBox als Bibliothek hinzufügen
Tabellenkalkulation in PDF konvertieren

Schritt 1: Laden Sie eine vorhandene Excel-Tabelle in eine GcExcel-Arbeitsmappe

Erstellen Sie ein GcExcel-Arbeitsmappenobjekt und laden Sie ein vorhandenes Arbeitsblatt.

Workbook workbook=new Workbook();
workbook.open("FinancialKPI.xlsx");

Workbook workbook=new Workbook();
workbook.open("FinancialKPI.xlsx");

Dim workbook As New Workbook()
workbook.open("FinancialKPI.xlsx")

VB C#

Schritt 2: PDFBox als Bibliothek hinzufügen

GcExcel Java verweist auf PDFBox, um Tabellenkalkulationen in PDF zu konvertieren. PDFBox hängt auch von den Paketen FontBox und Commons Logging ab.

Wenn Sie diese Schritte befolgen, können Sie diese JAR-Dateien als Bibliothek zu Ihrem Projekt hinzufügen:

Laden Sie das Paket herunter - PDFBox, FontBox, Commons Loggings JAR-Dateien.
Fügen Sie unter dem Ordner "src" im Projekt einen Ordner "libs" hinzu.
Kopieren Sie die drei JAR-Dateien in den Ordner "libs".
Klicken Sie mit der rechten Maustaste auf den Ordner "libs" und wählen Sie die Option "Als Bibliothek hinzufügen".
Drücken Sie OK.

Anmerkung: Die oben genannten Schritte sind nur erforderlich, wenn es sich bei dem Projekt um ein Original-Java-Konsolenprojekt handelt. Wenn es sich bei dem Projekt um ein Maven- oder Gradle-Projekt handelt, reicht es aus, die Java-Abhängigkeit von GcExcel hinzuzufügen. Maven oder Gradle werden alle abhängigen JARs automatisch herunterladen und installieren.

In einigen Versionen von Maven kann beim Hinzufügen der oben genannten JAR-Dateien ein Abhängigkeitsfehler auftreten. Um dies zu beheben, fügen Sie bitte den folgenden Knoten vor den Abhängigkeiten in pom.xml ein:
```
<build>
<plugins>
    <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <extensions>wahr</extensions>
    </plugin>
</plugins>
</build>
```

**Schritt 3: Tabellenkalkulation in PDF konvertieren

Speichern Sie die Kalkulationstabelle mit dem folgenden Code als PDF:

workbook.save("FinancialKPI.pdf", SaveFileFormat.Pdf);

workbook.save("FinancialKPI.pdf", SaveFileFormat.Pdf);

workbook.save("FinancialKPI.pdf", SaveFileFormat.Pdf)

VB C#

Ihr PDF sieht dann so aus:

Verwendung von IronXL zur Konvertierung von Tabellenkalkulationen in XML und JSON

Der folgende Code zeigt, wie man mit IronXL eine Excel-Datei in eine XML- oder JSON-Datei exportiert. Fügen Sie den folgenden Code hinzu:

Den Namespace einbeziehen:

using IronXL;

using IronXL;

Imports IronXL

VB C#

Fügen Sie die nächsten Zeilen hinzu:

    private void button4_Click(object sender, EventArgs e)    {        
        WorkBook workbook = WorkBook.Load("IronXL_Output.xlsx");        
        workbook.SaveAsJson("IronXL_Output.json");        
        workbook.SaveAsXml("IronXL_Output.xml");    
    }

    private void button4_Click(object sender, EventArgs e)    {        
        WorkBook workbook = WorkBook.Load("IronXL_Output.xlsx");        
        workbook.SaveAsJson("IronXL_Output.json");        
        workbook.SaveAsXml("IronXL_Output.xml");    
    }

Private Sub button4_Click(ByVal sender As Object, ByVal e As EventArgs)
		Dim workbook As WorkBook = WorkBook.Load("IronXL_Output.xlsx")
		workbook.SaveAsJson("IronXL_Output.json")
		workbook.SaveAsXml("IronXL_Output.xml")
End Sub

VB C#

Hier wird ein bestehendes Excel-Arbeitsmappenobjekt geladen und dann in die Formate JSON und XML exportiert.

Lizenzierung und Preisgestaltung

IronXL-Lizenzierung und Preisgestaltung

IronXL ist eine offen kommerzielle C#-Excel-Bibliothek. Es ist kostenlos für die Entwicklung und kann jederzeit für den kommerziellen Einsatz lizenziert werden. Es werden Lizenzen für Einzelprojekte, einzelne Entwickler, Agenturen und multinationale Organisationen sowie für SaaS und OEM-Weiterverteilung angeboten. Alle Lizenzen beinhalten eine 30-tägige Geld-zurück-Garantie, ein Jahr Software-Support und Upgrades, Gültigkeit für Entwicklung/Taging/Produktion sowie eine permanente Lizenz (einmaliger Kauf). Das Lite-Paket beginnt mit $749.

GrapeCity-Lizenzierung und Preisgestaltung

Auf der anderen Seite ist GrapeCity Excel auch eine kommerzielle Excel-Bibliothek; sie bietet keine kostenlosen Dienste an. Die Preise für GrapeCity Documents beginnen bei einem Pauschalpreis von $999 pro Jahr. Sie bieten auch eine kostenlose Testversion an. Die Lizenzen sind in vier Pakete unterteilt:

Entwicklerlizenz (1 Entwickler, 1 Standort)

Eine (1) entwickler können GrapeCity-Dokumente in einem (1) standort mit einer Entwicklerlizenz (definiert als eine physische Adresse oder ein Bürogebäude). Mehrere Standorte gelten als eine Cloud-Bereitstellung; siehe Unbegrenzte Lizenzen für weitere Informationen.

Unbegrenzte Lizenz für Entwickler (1 Entwickler, unbegrenzte Standorte oder Cloud)

Eine (1) entwickler können GrapeCity-Dokumente an einer unbegrenzten Anzahl von Standorten verwenden (als physische Adresse oder Bürogebäude angegeben) oder in der Cloud mit einer Unbegrenzten Lizenz für Entwickler.

Unbegrenzte Lizenz für Teams (2-5 Entwickler, unbeschränkte Standorte oder Cloud)

GrapeCity-Dokumente können von bis zu fünf Personen genutzt werden (5) entwickler an unendlich vielen Orten (als physische Adresse oder Bürogebäude angegeben) oder in der Cloud mit einer Unbegrenzten Lizenz für Teams.

OEM- und SaaS-Lizenz (ab 6 Entwicklern)

Dies kann durch Kontaktaufnahme mit dem Vertriebssupport eingerichtet werden.

Schlussfolgerung

Mit IronXL for .NET können Entwickler in .NET-Anwendungen und -Websites Excel-Dateien lesen, erstellen und bearbeiten (und andere Tabellenkalkulationsdateien). XLS/XLSX/CSV/TSV können gelesen und bearbeitet werden, und Exporte können in XLS/XLSX/CSV/TSV/JSON gespeichert werden. Es ist mit dem .NET-Framework, .NET Core und Azure kompatibel. All dies wird ohne zusätzliche Abhängigkeiten oder die Installation von Microsoft Office erreicht. Wenn Sie jemals das Gefühl hatten, dass Excel Ihren .NET-Büroverwaltungsfähigkeiten im Weg steht, dann ist IronXL hier, um zu helfen. Aus diesem Grund haben wir das C# Excel-Bibliothekmit dem Sie als erfolgreicher Entwickler Excel-Dateien in .NET-Anwendungen und Websites lesen, generieren und modifizieren können.

GcExcel (GrapeCity-Dokumente für Excel) ist eine schnelle Tabellenkalkulations-API mit geringem Platzbedarf, für die kein Excel erforderlich ist. Sie können Tabellenkalkulationen in .NET-Framework, .NET Core, Mono und Xamarin mit voller Unterstützung des .NET-Standards 2.0 erstellen, laden, ändern und konvertieren. Diese Tabellenkalkulations-API kann zur Erstellung von Anwendungen für die Cloud, Windows, Mac und Linux verwendet werden. Dank der ausgefeilten Berechnungs-Engine und der breiten Palette an Funktionen müssen Sie keine Abstriche beim Design oder den Anforderungen machen.

Die GrapeCity Excel-Lizenz beginnt bei $995 pro Entwickler, verglichen mit der $749 für IronXL, die den Vorteil eines lizenzfreien und unbegrenzten Multi-User-Plans hat, der billiger wird, wenn Sie für eine große Anzahl von Entwicklern kaufen, als GCexcel, das ein Maximum von 6 Benutzern auf seinen Ultra-Multi-User-Plänen hat.

IronXL wird aufgrund seiner Effizienz im Umgang mit Excel-Dokumenten anderen C#-Alternativen vorgezogen. IronXL zeichnet sich auch durch seine Betriebsmethoden aus, die kürzere Codezeilen fördern.

Iron Software bietet derzeit allen Kunden und Anwendern die Möglichkeit, die gesamte Iron Software Suite mit zwei Klicks zu erwerben - zum Preis von nur zwei Paketen aus der Iron Software Suite erhalten Sie stattdessen alle fünf Pakete zusammen mit einem ununterbrochenen Support.

< PREVIOUS
Ein Vergleich von IronXL und ClosedXML

NÄCHSTES >
Ein Vergleich zwischen IronXL und Syncfusion Excel