Praca z różnymi formatami Excel często wymaga odczytywania danych i ich programowej rekonfiguracji. W tym artykule nauczymy się, jak odczytywać plik CSV i analizować dane z arkusza kalkulacyjnego Excel w C# używając IronXL, idealnego narzędzia do tego zadania.
CSV to proste format danych, ale mogą występować wiele różnic; może być trudne do odczytania programowo w naszych projektach C#, ponieważ używa kilku separatorów do rozróżniania między wierszami a kolumnami danych. Ten artykuł pokaże, jak używać biblioteki IronXL do odczytu plików CSV.
Zanim będziesz mógł korzystać z IronXL do odczytu plików CSV w MVC, ASP.NET lub .NET Core, musisz go zainstalować. Oto szybkie przeprowadzenie.
Wyszukaj IronXL w Menedżerze pakietów NuGet w Visual Studio
Kiedy potrzebujesz odczytać pliki CSV w C#, IronXL jest idealnym narzędziem. Można odczytać plik CSV z przecinkami lub dowolnym innym separatorem, jak pokazano poniżej w segmentach kodu.
// Load a CSV file and interpret it as an Excel-like workbook
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
// Access the default worksheet in the workbook
WorkSheet ws = workbook.DefaultWorkSheet;
// Save the workbook to a new Excel file
workbook.SaveAs("Csv_To_Excel.xlsx");' Load a CSV file and interpret it as an Excel-like workbook
Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
' Access the default worksheet in the workbook
Dim ws As WorkSheet = workbook.DefaultWorkSheet
' Save the workbook to a new Excel file
workbook.SaveAs("Csv_To_Excel.xlsx")Wynik:
Wyjście pliku CSV z separatorem przecinka
Objaśnienie kodu:
A WorkBook object is created. Metoda LoadCSV dla obiektu WorkBook jest następnie używana do zdefiniowania nazwy pliku CSV, jego formatu oraz separatorów używanych w odczytywanym pliku CSV. W tym przypadku przecinki są używane jako separatory.
Następnie tworzony jest obiekt WorkSheet. To tutaj zostanie umieszczona zawartość pliku CSV. Plik jest zapisywany pod nową nazwą i w nowym formacie.
Dane wyświetlone w Microsoft Excel
Użyj IronXL w swoim projekcie, aby w prosty sposób pracować z formatami plików Excel w C#. Możesz zainstalować IronXL poprzez bezpośrednie pobranie. Alternatywnie możesz użyć Instalacji NuGet dla Visual Studio. Oprogramowanie jest darmowe do celów rozwojowych.
WorkBook i uzyskaj dostęp do WorkSheetWorkBook to klasa IronXL, której obiekt zapewnia pełny dostęp do pliku Excel i wszystkich jego funkcji. Na przykład, jeśli chcemy odczytać plik Excel, używamy kodu:
// Load the Excel file
WorkBook wb = WorkBook.Load("sample.xlsx"); // Excel file path' Load the Excel file
Dim wb As WorkBook = WorkBook.Load("sample.xlsx") ' Excel file pathAby uzyskać dostęp do konkretnego arkusza pliku Excel, IronXL dostarcza klasę WorkSheet.
// Access a specific worksheet by name
WorkSheet ws = wb.GetWorkSheet("Sheet1"); // by sheet name' Access a specific worksheet by name
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1") ' by sheet namePo uzyskaniu arkusza Excel ws, można z niego wydobyć dowolny rodzaj danych i wykonywać na nim wszystkie funkcje Excela. Dostęp do danych z arkusza Excel ws odbywa się w następujący sposób:
using IronXL;
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Iterate through a range of cells and display their values
foreach (var cell in ws["A2:A10"])
{
Console.WriteLine("Value is: {0}", cell.Text);
}
Console.ReadKey();
}
}Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Iterate through a range of cells and display their values
For Each cell In ws("A2:A10")
Console.WriteLine("Value is: {0}", cell.Text)
Next cell
Console.ReadKey()
End Sub
End ClassKorzystając z IronXL, jest bardzo łatwo operować na arkuszu Excel WorkSheet jako DataTable.
DataTable dt = ws.ToDataTable(true); // Converts the worksheet to a DataTable, using the first row as column namesDim dt As DataTable = ws.ToDataTable(True) ' Converts the worksheet to a DataTable, using the first row as column namesUżyj następujących przestrzeni nazw:
using IronXL;
using System.Data;Imports IronXL
Imports System.DataNapisz następujący kod:
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel file Name
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Parse worksheet into datatable
DataTable dt = ws.ToDataTable(true); // Parse Sheet1 of sample.xlsx file into DataTable
// Iterate through rows and columns to display their values
foreach (DataRow row in dt.Rows) // Access rows
{
for (int i = 0; i < dt.Columns.Count; i++) // Access columns of corresponding row
{
Console.Write(row[i] + " ");
}
Console.WriteLine();
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") ' Your Excel file Name
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Parse worksheet into datatable
Dim dt As DataTable = ws.ToDataTable(True) ' Parse Sheet1 of sample.xlsx file into DataTable
' Iterate through rows and columns to display their values
For Each row As DataRow In dt.Rows ' Access rows
For i As Integer = 0 To dt.Columns.Count - 1 ' Access columns of corresponding row
Console.Write(row(i) & " ")
Next i
Console.WriteLine()
Next row
End Sub
End Class
Wyjście konsoli z obiektu DataTable
W tym przykładzie przyjrzymy się, jak używać pliku Excel jako DataSet.
class Program
{
static void Main(string[] args)
{
// Load the workbook and convert it to a DataSet
WorkBook wb = WorkBook.Load("sample.xlsx");
DataSet ds = wb.ToDataSet(); // Parse WorkBook wb into DataSet
// Iterate through tables to display their names
foreach (DataTable dt in ds.Tables)
{
Console.WriteLine(dt.TableName);
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and convert it to a DataSet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ds As DataSet = wb.ToDataSet() ' Parse WorkBook wb into DataSet
' Iterate through tables to display their names
For Each dt As DataTable In ds.Tables
Console.WriteLine(dt.TableName)
Next dt
End Sub
End Class
Uzyskaj nazwę arkusza z obiektu DataSet
Przyjrzyjmy się innemu przykładowi, jak uzyskać wartość każdej komórki na wszystkich arkuszach Excel. Tutaj możemy uzyskać wartość każdej komórki na każdym arkuszu w pliku Excel.
class Program
{
static void Main(string[] args)
{
// Load the workbook and convert it to a DataSet
WorkBook wb = WorkBook.Load("Weather.xlsx");
DataSet ds = wb.ToDataSet(); // Treat the complete Excel file as DataSet
// Iterate through each table and its rows and columns
foreach (DataTable dt in ds.Tables) // Treat Excel WorkSheet as DataTable
{
foreach (DataRow row in dt.Rows) // Corresponding Sheet's Rows
{
for (int i = 0; i < dt.Columns.Count; i++) // Sheet columns of corresponding row
{
Console.Write(row[i] + " ");
}
Console.WriteLine();
}
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and convert it to a DataSet
Dim wb As WorkBook = WorkBook.Load("Weather.xlsx")
Dim ds As DataSet = wb.ToDataSet() ' Treat the complete Excel file as DataSet
' Iterate through each table and its rows and columns
For Each dt As DataTable In ds.Tables ' Treat Excel WorkSheet as DataTable
For Each row As DataRow In dt.Rows ' Corresponding Sheet's Rows
For i As Integer = 0 To dt.Columns.Count - 1 ' Sheet columns of corresponding row
Console.Write(row(i) & " ")
Next i
Console.WriteLine()
Next row
Next dt
End Sub
End Class
Wyjście konsoli z obiektu Dataset
Pliki CSV mają mnóstwo problemów z tym, jak są obsługiwane łamanie linii w polach, lub jak pola mogą być ujęte w cudzysłowy, które całkowicie blokują podejście prostego rozdzielania stringów. Niedawno odkryłem następujące opcje przy konwersji CSV w C# .NET poprzez określenie dostosowywanego separatora zamiast użycia string.Split(',') do oddzielania wartości przecinkiem.
Ten proces przesuwa czytnik do kolejnego pliku. Odczytujemy pliki pól CSV w TryGetField. Używamy funkcji odczytu na polach pól plików CSV jako rekordów.
// Load a CSV file, specify the file format and delimiter
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
// Access the default worksheet from the workbook
WorkSheet ws = workbook.DefaultWorkSheet;
// Convert worksheet to DataTable
DataTable dt = ws.ToDataTable(true); // Parse Sheet1 of sample.xlsx file into DataTable
// Iterate through rows and columns to display their values
foreach (DataRow row in dt.Rows) // Access rows
{
for (int i = 0; i < dt.Columns.Count; i++) // Access columns of corresponding row
{
Console.Write(row[i] + " ");
}
Console.WriteLine();
}' Load a CSV file, specify the file format and delimiter
Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
' Access the default worksheet from the workbook
Dim ws As WorkSheet = workbook.DefaultWorkSheet
' Convert worksheet to DataTable
Dim dt As DataTable = ws.ToDataTable(True) ' Parse Sheet1 of sample.xlsx file into DataTable
' Iterate through rows and columns to display their values
For Each row As DataRow In dt.Rows ' Access rows
For i As Integer = 0 To dt.Columns.Count - 1 ' Access columns of corresponding row
Console.Write(row(i) & " ")
Next i
Console.WriteLine()
Next row
Wyjście konsoli z DataTable
Teraz możemy łatwo uzyskać dowolny rodzaj danych, korzystając z różnych metod, z otwartego arkusza Excel WorkSheet. W poniższym przykładzie możemy zobaczyć, jak uzyskać dostęp do konkretnej wartości komórki i przekonwertować ją na string:
// Access the data by cell addressing
string val = ws["Cell Address"].ToString();' Access the data by cell addressing
Dim val As String = ws("Cell Address").ToString()W powyższej linii ws jest WorkSheet, który został zdefiniowany w Kroku 2. Jest to 'proste' podejście, ale można przeczytać więcej i zobaczyć różne przykłady jak uzyskać dostęp do danych pliku Excel.
Podczas używania arkuszy kalkulacyjnych Excel do budowy aplikacji często analizujemy wyniki na podstawie danych i musimy parsować dane z pliku Excel w C# na wymagany format, aby uzyskać odpowiednie wyniki. Parsowanie danych na różne formaty jest łatwe w środowisku C# przy użyciu IronXL; zobacz poniższe kroki.
using IronXL;
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Parse Excel cell value into string
string str_val = ws["B3"].Value.ToString();
// Parse Excel cell value into Int32
Int32 int32_val = ws["G3"].Int32Value;
// Parse Excel cell value into Decimal
decimal decimal_val = ws["E5"].DecimalValue;
// Output parsed values to the console
Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);
Console.ReadKey();
}
}Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Parse Excel cell value into string
Dim str_val As String = ws("B3").Value.ToString()
' Parse Excel cell value into Int32
Dim int32_val As Int32 = ws("G3").Int32Value
' Parse Excel cell value into Decimal
Dim decimal_val As Decimal = ws("E5").DecimalValue
' Output parsed values to the console
Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val)
Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val)
Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val)
Console.ReadKey()
End Sub
End ClassTeraz przechodzimy do tego, jak parsować dane pliku Excel. Najpierw przyjrzymy się, jak radzić sobie z danymi liczbowymi Excel, a następnie jak przekształcić je w nasz wymagany format.
Tabela pod summująca dla każdego typu danych
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Parse Excel cell value into string
string str_val = ws["B3"].Value.ToString();
// Parse Excel cell value into Int32
Int32 int32_val = ws["G3"].Int32Value;
// Parse Excel cell value into Decimal
decimal decimal_val = ws["E5"].DecimalValue;
// Output parsed values to the console
Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);
Console.ReadKey();
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Parse Excel cell value into string
Dim str_val As String = ws("B3").Value.ToString()
' Parse Excel cell value into Int32
Dim int32_val As Int32 = ws("G3").Int32Value
' Parse Excel cell value into Decimal
Dim decimal_val As Decimal = ws("E5").DecimalValue
' Output parsed values to the console
Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val)
Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val)
Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val)
Console.ReadKey()
End Sub
End ClassTen kod wyświetli następujące wyjście:
Wyjście konsoli z poprawnym typem danych
I możemy zobaczyć wartości z pliku Excel sample.xlsx tutaj:
Wyświetlenie poprawnego typu danych w Excel
Aby przekonwertować dane z pliku Excel na typ danych Boolean, IronXL dostarcza funkcję BoolValue. Można to użyć w następujący sposób:
// Access a cell value as a boolean
bool Val = ws["Cell Address"].BoolValue;' Access a cell value as a boolean
Dim Val As Boolean = ws("Cell Address").BoolValueclass Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Convert a range into an array
var array = ws["B6:F6"].ToArray();
// Get the count of items in the array
int item = array.Count();
// Get the first item as a string
string total_items = array[0].Value.ToString();
// Output information about the array to the console
Console.WriteLine("First item in the array: {0}", item);
Console.WriteLine("Total items from B6 to F6: {0}", total_items);
Console.ReadKey();
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Convert a range into an array
Dim array = ws("B6:F6").ToArray()
' Get the count of items in the array
Dim item As Integer = array.Count()
' Get the first item as a string
Dim total_items As String = array(0).Value.ToString()
' Output information about the array to the console
Console.WriteLine("First item in the array: {0}", item)
Console.WriteLine("Total items from B6 to F6: {0}", total_items)
Console.ReadKey()
End Sub
End ClassWorkSheet Excela na DataTableJedną z doskonałych funkcji IronXL jest to, że możemy łatwo przekonwertować konkretny WorkSheet Excela na DataTable. Do tego celu możemy użyć funkcji .ToDataTable() IronXL, jak poniżej:
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Parse Sheet1 of sample.xlsx file into DataTable
// Setting 'true' makes the first row in Excel as the column names in DataTable
DataTable dt = ws.ToDataTable(true);
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Parse Sheet1 of sample.xlsx file into DataTable
' Setting 'true' makes the first row in Excel as the column names in DataTable
Dim dt As DataTable = ws.ToDataTable(True)
End Sub
End ClassJeśli chcemy przekonwertować cały plik Excel na DataSet, to do tego celu możemy użyć funkcji .ToDataSet() w IronXL.
class Program
{
static void Main(string[] args)
{
// Load an entire workbook into a DataSet
WorkBook wb = WorkBook.Load("sample.xlsx");
// Convert workbook to DataSet
DataSet ds = wb.ToDataSet();
// We can also get a DataTable from the DataSet which corresponds to a WorkSheet
DataTable dt = ds.Tables[0];
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load an entire workbook into a DataSet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
' Convert workbook to DataSet
Dim ds As DataSet = wb.ToDataSet()
' We can also get a DataTable from the DataSet which corresponds to a WorkSheet
Dim dt As DataTable = ds.Tables(0)
End Sub
End ClassIronXL dostarcza inteligentnej metody do odczytywania danych z pliku Excel w określonym zakresie. Zakres można zastosować zarówno do wierszy, jak i kolumn.
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Get specified range values by loop
foreach (var item in ws["B3:B8"])
{
Console.WriteLine("Value is: {0}", item);
}
Console.ReadKey();
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Get specified range values by loop
For Each item In ws("B3:B8")
Console.WriteLine("Value is: {0}", item)
Next item
Console.ReadKey()
End Sub
End ClassPowyższy kod wyświetla następujący wynik:
Wyjście konsoli do uzyskania dostępu do wszystkich wartości w zakresie B3:B8
I generuje wartości z pliku Excel sample.xlsx:
Wyświetlane dane z sample.xlsx
Ponadto, IronXL jest również kompatybilny z wieloma metodami Excel do interakcji z komórkami, w tym stylowaniem i obramowaniem, funkcjami matematycznymi, formatowaniem warunkowym lub tworzeniem wykresów z dostępnych danych.
W procesie tworzenia aplikacji musimy podejmować decyzje oparte na typie danych logicznych w plikach Excel.
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Traverse a range and output boolean values
foreach (var item in ws["G1:G10"])
{
Console.WriteLine("Condition is: {0}", item.BoolValue);
}
Console.ReadKey();
}
}Module Program
Sub Main(args As String())
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Traverse a range and output boolean values
For Each item In ws("G1:G10")
Console.WriteLine("Condition is: {0}", item.BoolValue)
Next
Console.ReadKey()
End Sub
End ModuleZ tego uzyskujemy wyjście:
Wyjście konsoli z pobierania danych logicznych
I plik Excel sample.xlsx z wartościami od C1 do C10:
Próbka Excel do porównania z wyjściem konsoli
Jest prosto odczytać cały arkusz Excel, korzystając z indeksów wierszy i kolumn. Dla tego celu używamy dwóch pętli: jednej do przechodzenia przez wszystkie wiersze, a drugiej do przechodzenia przez wszystkie kolumny określonego wiersza. Następnie możemy łatwo uzyskać wszystkie wartości komórek w całym arkuszu Excel.
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel File Name
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Traverse all rows of Excel WorkSheet
for (int i = 0; i < ws.Rows.Count(); i++)
{
// Traverse all columns of specific Row
for (int j = 0; j < ws.Columns.Count(); j++)
{
// Get the values
string val = ws.Rows[i].Columns[j].Value.ToString();
Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j, val);
}
}
Console.ReadKey();
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") ' Your Excel File Name
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Traverse all rows of Excel WorkSheet
For i As Integer = 0 To ws.Rows.Count() - 1
' Traverse all columns of specific Row
For j As Integer = 0 To ws.Columns.Count() - 1
' Get the values
Dim val As String = ws.Rows(i).Columns(j).Value.ToString()
Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j, val)
Next j
Next i
Console.ReadKey()
End Sub
End Class
Wyjście konsoli z odczytywania wszystkich wartości
IronXL jest biblioteką Excel dla C# i .NET, która umożliwia deweloperom odczyt i edycję danych z dokumentów XLS i XLSX bez użycia Microsoft.Office.Interop.Excel.
API pozwala nam intuicyjnie tworzyć, odczytywać, manipulować, zapisywać i eksportować pliki Excel dla:
Dodaj następujące przestrzenie nazw:
using IronXL;
using System;
using System.Linq;Imports IronXL
Imports System
Imports System.LinqTeraz napisz następujący kod w głównej funkcji.
class Program
{
static void Main(string[] args)
{
// Load an Excel file and access the first worksheet
WorkBook workbook = WorkBook.Load("Weather.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();
// Select cells easily in Excel notation and return the calculated value
int cellValue = sheet["A2"].IntValue;
// Read from ranges of cells elegantly
foreach (var cell in sheet["A2:A10"])
{
Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load an Excel file and access the first worksheet
Dim workbook As WorkBook = WorkBook.Load("Weather.xlsx")
Dim sheet As WorkSheet = workbook.WorkSheets.First()
' Select cells easily in Excel notation and return the calculated value
Dim cellValue As Integer = sheet("A2").IntValue
' Read from ranges of cells elegantly
For Each cell In sheet("A2:A10")
Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
Next cell
End Sub
End Class
Wyjście konsoli z każdej komórki
IronXL również w pełni wspiera aplikacje ASP.NET, MVC, Windows, macOS, Linux, iOS oraz Android Mobile.
Oprócz parsowania CSV w C#, IronXL konwertuje pliki CSV do Excel w zaledwie dwóch liniach kodu!
Korzystając z C# lub VB.NET, bardzo łatwo jest używać API Excel IronXL bez potrzeby Interopa. Możesz odczytywać, edytować i tworzyć arkusze Excel lub pracować z innymi formatami Excel takimi jak XLS/XLSX/CSV/TSV. Z wsparciem dla wielu frameworków, możesz kupić 5 produktów w cenie dwóch. Kliknij na naszą stronę cenową po więcej informacji.
5 products of Iron Suite
Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
