using IronXL;
using System;
using System.Linq;
// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");
// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];
// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;
// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;
// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}
// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();
// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);
Arbeiten mitExcel-DateienDie Programmierung kann die Effizienz und Automatisierungsfähigkeiten Ihrer C#-Anwendungen erheblich verbessern. Egal, ob Sie Berichte erstellen, Daten verarbeiten oder dynamisch komplexe Tabellenkalkulationen erstellen, das Beherrschen der Manipulation von Excel-Dateien ist entscheidend. In diesem Tutorial konzentrieren wir uns darauf, mit Excel-Bereichen zu arbeiten, indem wirIronXL. Wir werden behandeln, wie manschreiben, lesenundBereiche manipuliereninnerhalb einer Excel-Datei.
So lesen Sie Excel-Bereiche in C#.
Installieren Sie die IronXL-Bibliothek zur Bearbeitung von Excel-Dateien.
Laden Sie die Arbeitsmappe und geben Sie das Arbeitsblatt an.
Wählen Sie den Zellbereich aus, der gelesen werden soll.
Extrahieren und lesen Sie Daten aus dem angegebenen Bereich.
Was ist IronXL?
IronXList eine umfassende Bibliothek für C#, die das Arbeiten mit Excel-Dateien vereinfacht und eine Vielzahl von Funktionen für nahtlose Integration und Manipulation von Tabellendaten bietet. Zu seinen Fähigkeiten gehörenlesen, schreibenundmodifizierenExcel-Dateien ohne Installation von Microsoft Excel öffnen, wodurch plattformübergreifende Kompatibilität ermöglicht wird.
IronXL erleichtert die Extraktion von Daten aus spezifischenZellen, bereiche, oder ganze Arbeitsblätter, zusammen mit erweiterten Funktionen wieformatierung, stylingundbedingte Formatierung. Mit Unterstützung für Berechnungen, Formeln und statistische Analysen ermöglicht IronXL Entwicklern eine effiziente programmgesteuerte Bearbeitung von Excel-Operationen, was es zu einem unverzichtbaren Werkzeug für die Automatisierung datenorientierter Aufgaben innerhalb von C#-Anwendungen macht.
Erste Schritte mit Excel-Zellenbereich in C
Zuerst müssen wir die IronXL-Bibliothek in unserer Anwendung installieren.
Installieren Sie das IronXL NuGet-Paket
Sie können IronXL über den NuGet-Paket-Manager mit folgendem Befehl installieren:
Install-Package IronXL.Excel
Install-Package IronXL.Excel
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronXL.Excel
$vbLabelText $csharpLabel
Der obige Befehl installiert IronXL mit all seinen Abhängigkeiten.
Namespace hinzufügen
Fügen Sie den folgenden Namespace am Anfang der Program.cs-Klasse hinzu oder dort, wo Sie die IronXL-Methoden verwenden möchten.
using IronXL;
using IronXL;
Imports IronXL
$vbLabelText $csharpLabel
Excel-Arbeitsmappe laden
Der allererste Schritt besteht darin, die Excel-Arbeitsmappe zu laden. Der folgende Code lädt die Excel-Arbeitsmappe in unsere Anwendung.
static void Main(string[] args)
{
var workbook = WorkBook.Load("test_excel.xlsx");
var sheet = workbook.GetWorkSheet("Sheet1");
}
static void Main(string[] args)
{
var workbook = WorkBook.Load("test_excel.xlsx");
var sheet = workbook.GetWorkSheet("Sheet1");
}
Shared Sub Main(ByVal args() As String)
Dim workbook = WorkBook.Load("test_excel.xlsx")
Dim sheet = workbook.GetWorkSheet("Sheet1")
End Sub
$vbLabelText $csharpLabel
Die Dateizeile lädt eine vorhandene Excel-Arbeitsmappe aus der Datei namens "test_excel.xlsx". Die zweite Zeile ruft das Arbeitsblatt mit dem Namen "Sheet1" aus der geladenen Arbeitsmappe ab.
Ich werde die folgende Excel-Datei während dieses Tutorials verwenden.
Daten aus einem Bereich lesen
Nun, lesen wir Daten aus den angegebenen Zellbereichen.
var range = sheet["A2:G10"];
foreach (var item in range)
{
Console.WriteLine(item);
}
var range = sheet["A2:G10"];
foreach (var item in range)
{
Console.WriteLine(item);
}
Dim range = sheet("A2:G10")
For Each item In range
Console.WriteLine(item)
Next item
$vbLabelText $csharpLabel
Die erste Zeile wählt eine bestimmte Bereichsadresse aus.(A2 bis G10)in der Arbeitsmappe, sodass Sie gleichzeitig mit mehreren Excel-Zellen arbeiten können. Das foreach(var artikel im Bereich)Schleife iteriert über jede Zelle innerhalb dieses Zellbereichs und ermöglicht eine effiziente Datenverarbeitung.
Durch die Verwendung von Console.WriteLine(Artikel); Der Code gibt den Wert jeder Zelle auf der Konsole aus, was es einfach macht, den Inhalt des Bereichs zu überprüfen. Dieser Ansatz vereinfacht die Datenverarbeitung und verbessert die Lesbarkeit des Codes.
Excel-Formeln im Bereich verwenden
Lassen Sie uns einen bestimmten Bereich auswählen und einige Excel-Formeln implementieren.
var range = sheet["F2:F42"];
Console.WriteLine($"Minimum Age: {range.Min()}");
Console.WriteLine($"Maximum Age: {range.Max()}");
Console.WriteLine($"Average Age: {(int)range.Avg()}");
var range = sheet["F2:F42"];
Console.WriteLine($"Minimum Age: {range.Min()}");
Console.WriteLine($"Maximum Age: {range.Max()}");
Console.WriteLine($"Average Age: {(int)range.Avg()}");
Imports System
Dim range = sheet("F2:F42")
Console.WriteLine($"Minimum Age: {range.Min()}")
Console.WriteLine($"Maximum Age: {range.Max()}")
Console.WriteLine($"Average Age: {CInt(Math.Truncate(range.Avg()))}")
$vbLabelText $csharpLabel
Der Code var range = sheet["F2:F42"]; Wählt einen Zellbereich von F2 bis F42 aus und erleichtert die statistische Analyse von Altersdaten. Verwenden von range.Min()und range.Max(), es berechnet effizient die minimalen und maximalen Alterswerte innerhalb des angegebenen Bereichs und unterstützt dabei demografische Erkenntnisse.
Außerdem range.Avg()berechnet das Durchschnittsalter und bietet wertvolle statistische Kennzahlen für die Dateninterpretation. Dieser Ansatz vereinfacht die Datenanalyseaufgaben und bietet schnellen Zugriff auf wichtige statistische Informationen für fundierte Entscheidungen.
Daten aus einer einzelnen Zelle lesen
Lassen Sie uns Daten aus einer einzelnen Zelle lesen.
var read_from_single_cell = sheet["B2"];
Console.WriteLine($"The Value in Cell B2 is: {read_from_single_cell}");
var read_from_single_cell = sheet["B2"];
Console.WriteLine($"The Value in Cell B2 is: {read_from_single_cell}");
Dim read_from_single_cell = sheet("B2")
Console.WriteLine($"The Value in Cell B2 is: {read_from_single_cell}")
$vbLabelText $csharpLabel
Der Code var read_from_single_cell = sheet[B2]; ruft den in der Zelle B2 gespeicherten Wert aus dem Arbeitsblatt ab. Mit dieser Methode können Sie problemlos auf bestimmte Zellwerte innerhalb der Excel-Datei zugreifen.
Mit Console.WriteLine($"Der Wert in Zelle B2 ist:{aus_einzelner_Zelle_lesen}");, der Code druckt den abgerufenen Wert der referenzierten Zellen in die Konsole und erleichtert damit die Datenüberprüfung und Fehlerbehebung. Dies vereinfacht den Prozess des Abrufens und Anzeigens einzelner Zellwerte aus Excel-Dateien.
Daten aus einer gesamten Spalte lesen
Lassen Sie uns Daten aus einer gesamten Spalte mithilfe des Indexes lesen.
// Get Last name Column from Index 2
var columnValues = sheet.GetColumn(2); // 2 is column index
foreach ( var columnValue in columnValues )
{
Console.WriteLine(columnValue);
}
// Get Last name Column from Index 2
var columnValues = sheet.GetColumn(2); // 2 is column index
foreach ( var columnValue in columnValues )
{
Console.WriteLine(columnValue);
}
' Get Last name Column from Index 2
Dim columnValues = sheet.GetColumn(2) ' 2 is column index
For Each columnValue In columnValues
Console.WriteLine(columnValue)
Next columnValue
$vbLabelText $csharpLabel
Der Code var columnValues = sheet.GetColumn(2); ruft alle Werte aus der Spalte am Index 2 ab(B-Spalte)im Arbeitsblatt. Dies ermöglicht Ihnen, effizient auf alle Werte innerhalb einer bestimmten Spalte des Excel-Blatts zuzugreifen.
Durch die foreach-Schleife, die über columnValues iteriert, wird jeder Wert in der Spalte mit Console.WriteLine auf die Konsole ausgegeben.(Spaltenwert);. Dieser Ansatz erleichtert die Verarbeitung und Anzeige von Spalten-Daten aus Excel-Dateien und vereinfacht Aufgaben der Datenanalyse.
Alternativ können wir auch Daten aus einer Spalte mit einem Spaltennamen anstelle eines Indexes lesen. Betrachten Sie das folgende Beispiel:
var columnValues = sheet.GetColumn("C");
var columnValues = sheet.GetColumn("C");
Dim columnValues = sheet.GetColumn("C")
$vbLabelText $csharpLabel
Auf diese Weise können wir mehrere Spalten angeben.
Daten aus der gesamten Zeile lesen
Lassen Sie uns Daten aus der gesamten Zeile mit Zeilennummern lesen.
var rowValues = sheet.GetRow(1);// 1 is row index
foreach (var rowValue in rowValues)
{
Console.Write(rowValue + " ");
}
var rowValues = sheet.GetRow(1);// 1 is row index
foreach (var rowValue in rowValues)
{
Console.Write(rowValue + " ");
}
Dim rowValues = sheet.GetRow(1) ' 1 is row index
For Each rowValue In rowValues
Console.Write(rowValue & " ")
Next rowValue
$vbLabelText $csharpLabel
Der Code var rowValues = sheet.GetRow(1); ruft alle Werte aus einer einzelnen Zeile ab, die sich an Index 1 befindet(Reihe 2)im Arbeitsblatt, um effizienten Zugriff auf zeilenspezifische Daten zu ermöglichen. Durch die foreach-Schleife, die über rowValues iteriert, wird jeder Wert in der Zeile mit Console.Write auf die Konsole ausgegeben.(rowValue + " ");.
Dieser Ansatz vereinfacht die Extraktion und Anzeige von Zeilendaten aus Excel-Dateien und unterstützt bei der Datenanalyse und Berichterstattung. Auf diese Weise können wir Werte aus mehreren Zellen ohne Bereichsspezifikation auslesen.
Daten in eine Zelle oder einen Bereich schreiben
Wir können Daten sowohl in Zellen als auch in Bereiche schreiben. Zunächst werden wir Daten in einen Bereich schreiben.
var range = sheet["D2:D14"];
range.Value = "Prefer Not to Say"; // Change Gender Value
workbook.Save();
var range = sheet["D2:D14"];
range.Value = "Prefer Not to Say"; // Change Gender Value
workbook.Save();
Dim range = sheet("D2:D14")
range.Value = "Prefer Not to Say" ' Change Gender Value
workbook.Save()
$vbLabelText $csharpLabel
Der Code var range = sheet["D2:D14"]; wählt einen Bereich von der Zelle D2 bis D14 aus, sodass Massenänderungen von Daten möglich sind. Indem Sie range.Value auf "Möchte ich nicht angeben" setzen, wird der Geschlechterwert für jede Zelle innerhalb des angegebenen Bereichs effizient aktualisiert und repetitive Aufgaben werden minimiert.
Die nachfolgende workbook.Save(); Der Befehl sorgt für die dauerhafte Speicherung dieser Änderungen und bewahrt die Datenkonsistenz und -integrität. Dieser Ansatz vereinfacht Massenaktualisierungen und gewährleistet Einheitlichkeit über mehrere Zellen, wodurch die Effizienz der Datenverwaltung verbessert wird.
Nun, schreiben wir Daten in eine bestimmte Zelle.
sheet["B2"].Value = "John";
workbook.Save();
sheet["B2"].Value = "John";
workbook.Save();
sheet("B2").Value = "John"
workbook.Save()
$vbLabelText $csharpLabel
Das Codesheet[B2].Value = "John"; weist direkt den Wert "John" der Zelle B2 im Excel-Arbeitsblatt zu und bietet eine prägnante und unkomplizierte Methode zur Aktualisierung spezifischer Zellwerte. Dieser Ansatz vereinfacht den Prozess der Modifikation einzelner Zellinhalte, verbessert die Lesbarkeit des Codes und dessen Effizienz.
Schlussfolgerung
Abschließend lässt sich sagen, dass die Beherrschung von Excel-Bereichsoperationen in C# mit IronXL die Effizienz und Automatisierungsfähigkeiten von Anwendungen erheblich steigert, indem Aufgaben wie Datenverarbeitung, Berichtserstellung und dynamische Tabellenkalkulationen erleichtert werden.
Mit den leistungsstarken Funktionen von IronXL zum Lesen, Schreiben und Bearbeiten von Excel-Dateien können Entwickler Datenverarbeitungsprozesse optimieren und fortschrittliche Funktionalitäten wie Formeln, Formatierung und statistische Analysen nutzen. Zusätzlich bietet IronXL einkostenloser Test, um Flexibilität und Skalierbarkeit für verschiedene Projektanforderungen sicherzustellen.
Bevor er Software-Ingenieur wurde, promovierte Kannapat an der Universität Hokkaido in Japan im Bereich Umweltressourcen. Während seines Studiums wurde Kannapat auch Mitglied des Vehicle Robotics Laboratory, das Teil der Abteilung für Bioproduktionstechnik ist. Im Jahr 2022 wechselte er mit seinen C#-Kenntnissen zum Engineering-Team von Iron Software, wo er sich auf IronPDF konzentriert. Kannapat schätzt an seiner Arbeit, dass er direkt von dem Entwickler lernt, der den Großteil des in IronPDF verwendeten Codes schreibt. Neben dem kollegialen Lernen genießt Kannapat auch den sozialen Aspekt der Arbeit bei Iron Software. Wenn er nicht gerade Code oder Dokumentationen schreibt, kann man Kannapat normalerweise beim Spielen auf seiner PS5 oder beim Wiedersehen mit The Last of Us antreffen.
NÄCHSTES > So arbeiten Sie mit Excel-Dateien in C#