Pliki CSV (Przecinek Separated Values) są powszechnie stosowane w aplikacjach biznesowych, od raportów finansowych po eksport danych klientów. Format CSV na pierwszy rzut oka wydaje się prosty, ale parsowanie go w kodzie produkcyjnym może szybko stać się trudne, gdy mamy do czynienia z polami w cudzysłowie, wieloma typami separatorów, osadzonymi znakami nowej linii oraz koniecznością konwersji surowego tekstu na obiekty .NET o silnym typowaniu. Biblioteka IronXL .NET zapewnia obsługę plików CSV na poziomie korporacyjnym, umożliwiająca programistom konwersję danych CSV do formatu Excel, XML lub innych formatów przy minimalnym nakładzie kodu.
Ten przewodnik pokazuje, jak działa IronXL jako czytnik plików CSV w języku C# i jak można go zaimplementować w aplikacjach .NET 10. Wypróbuj IronXL samodzielnie dzięki bezpłatnej licencji próbnej i śledź instrukcje, aby dowiedzieć się, jak radzi sobie z zadaniami związanymi z plikami CSV i Excel.
Włączenie IronXL do projektu zajmuje tylko chwilę. Można go zainstalować za pomocą menedżera pakietów NuGet w Visual Studio lub z wiersza poleceń, korzystając z interfejsu CLI .NET lub konsoli menedżera pakietów NuGet w PowerShell. Oba podejścia instalują ten sam pakiet i działają z każdym typem projektu .NET 10.
Więcej szczegółów na temat opcji instalacji i konfiguracji można znaleźć w dokumentacji instalacyjnej IronXL.
Po zainstalowaniu odczytanie pierwszego pliku CSV wymaga bardzo niewielkiej ilości kodu. W poniższym przykładzie wykorzystano instrukcje najwyższego poziomu .NET 10:
using IronXL;
// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read a specific cell
string cellValue = sheet["A1"].StringValue;
// Iterate through all rows and cells
foreach (var row in sheet.Rows)
{
foreach (var cell in row)
{
Console.WriteLine(cell.StringValue);
}
}Imports IronXL
' Load CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read a specific cell
Dim cellValue As String = sheet("A1").StringValue
' Iterate through all rows and cells
For Each row In sheet.Rows
For Each cell In row
Console.WriteLine(cell.StringValue)
Next
NextMetoda WorkBook.LoadCSV zajmuje się identyfikacją nagłówków, tworzy wewnętrzną strukturę danych i wykonuje efektywne pod względem pamięci parsowanie -- upraszczając zarządzanie danymi od pierwszej linii kodu.
W rzeczywistych plikach CSV nie zawsze stosuje się przecinki. Średniki, pionowe kreski i tabulatory są powszechnie stosowanymi alternatywami, zwłaszcza w międzynarodowych zbiorach danych, gdzie przecinki służą jako separatory dziesiętne. IronXL obsługuje dowolne separatory dzięki elastycznym opcjom ładowania.
using IronXL;
// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
fileFormat: ExcelFileFormat.XLSX,
listSeparator: ";");
// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
fileFormat: ExcelFileFormat.XLSX,
listSeparator: "\t");
// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
fileFormat: ExcelFileFormat.XLSX,
listSeparator: "|");
// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();
Console.WriteLine($"Total sales: {totalSales}");Imports IronXL
' Load CSV with semicolon delimiter (common in European data exports)
Dim workbook As WorkBook = WorkBook.LoadCSV("european-data.csv", fileFormat:=ExcelFileFormat.XLSX, listSeparator:=";")
' Load tab-separated values (TSV)
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv", fileFormat:=ExcelFileFormat.XLSX, listSeparator:=vbTab)
' Load pipe-delimited file
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("log_export.csv", fileFormat:=ExcelFileFormat.XLSX, listSeparator:="|")
' Access data normally after loading
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim totalSales As Decimal = sheet("B2:B10").Sum()
Console.WriteLine($"Total sales: {totalSales}")Parametr listSeparator akceptuje dowolny ciąg znaków, dając pełną kontrolę nad zachowaniem parsowania. IronXL zachowuje wartości kolumn i typy danych podczas parsowania -- wartości numeryczne pozostają liczbami, daty pozostają jako obiekty DateTime, a formuły zachowują swoje relacje.
W przypadku plików o niespójnym formatowaniu mechanizm obsługi błędów IronXL radzi sobie z nieprawidłowymi wierszami bez powodowania awarii aplikacji, dzięki czemu prawidłowe dane są nadal przetwarzane, nawet jeśli poszczególne wiersze są problematyczne.
IronXL obsługuje ładowanie następujących typów separatorów podczas odczytu plików CSV:
| Separator | Znak | Typowy przypadek użycia |
|---|---|---|
| Przecinek | , | Standardowy eksport do pliku CSV, lokalizacja amerykańska |
| Średnik | ; | Eksport do lokalizacji europejskich (gdzie przecinek jest separatorem dziesiętnym) |
| Tab | \t | Wartości rozdzielone tabulatorami (TSV), eksporty baz danych |
| Pionowa kreska | | | Pliki dziennika, eksporty systemowe |
| Niestandardowy ciąg znaków | Wszelkie | Własne formaty danych, wieloznakowe separatory |
Przekształcanie wierszy CSV w obiekty silnie typowane upraszcza przetwarzanie danych i umożliwia operacje LINQ. IronXL ułatwia to mapowanie dzięki metodom dostępu do komórek. Poniższy kod pokazuje, jak zamapować plik CSV na listę obiektów typu za pomocą instrukcji najwyższego poziomu w .NET 10:
using IronXL;
// Define a typed model matching your CSV structure
public record Product(string Name, decimal Price, int Stock, DateTime? LastUpdated);
// Load and parse CSV file
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
var products = new List<Product>();
// Start from row 2 to skip the header row
for (int row = 2; row <= sheet.RowCount; row++)
{
products.Add(new Product(
Name: sheet[$"A{row}"].StringValue,
Price: sheet[$"B{row}"].DecimalValue,
Stock: sheet[$"C{row}"].IntValue,
LastUpdated: sheet[$"D{row}"].DateTimeValue
));
}
// Use LINQ for analysis after loading
var lowStock = products.Where(p => p.Stock < 10).ToList();
var highValue = products.Where(p => p.Price > 100m).OrderByDescending(p => p.Price).ToList();
Console.WriteLine($"Products with low stock: {lowStock.Count}");
Console.WriteLine($"High-value products: {highValue.Count}");Imports IronXL
' Define a typed model matching your CSV structure
Public Class Product
Public Property Name As String
Public Property Price As Decimal
Public Property Stock As Integer
Public Property LastUpdated As DateTime?
Public Sub New(name As String, price As Decimal, stock As Integer, lastUpdated As DateTime?)
Me.Name = name
Me.Price = price
Me.Stock = stock
Me.LastUpdated = lastUpdated
End Sub
End Class
' Load and parse CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim products As New List(Of Product)()
' Start from row 2 to skip the header row
For row As Integer = 2 To sheet.RowCount
products.Add(New Product(
Name:=sheet($"A{row}").StringValue,
Price:=sheet($"B{row}").DecimalValue,
Stock:=sheet($"C{row}").IntValue,
LastUpdated:=sheet($"D{row}").DateTimeValue
))
Next
' Use LINQ for analysis after loading
Dim lowStock = products.Where(Function(p) p.Stock < 10).ToList()
Dim highValue = products.Where(Function(p) p.Price > 100D).OrderByDescending(Function(p) p.Price).ToList()
Console.WriteLine($"Products with low stock: {lowStock.Count}")
Console.WriteLine($"High-value products: {highValue.Count}")Właściwości wartości typizowanych w IronXL -- StringValue, DecimalValue, IntValue, DateTimeValue -- bezpiecznie obsługują konwersje, zwracając wartości domyślne dla nieprawidłowych danych zamiast wyrzucać wyjątki. To defensywne podejście gwarantuje, że aplikacje obsługują niedoskonałe dane bez zakłóceń. Naturalnie współgra z typami rekordów C#, które zostały wprowadzone w C# 9 i zapewniają zwięzły, niezmienny model danych dla mapowanych wierszy CSV.
Strona funkcji IronXL zawiera pełny przegląd typów akcesorów wartości dostępnych do odczytu danych komórek.
Gdy dane CSV są załadowane do WorkSheet, można z nimi pracować używając selektorów zakresu lub konwertować je na obiekty do zapytań LINQ. W przypadku prostych operacji na kolumnach dostęp oparty na zakresach jest najprostszą metodą:
using IronXL;
WorkBook workbook = WorkBook.LoadCSV("sales-data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read entire columns using range notation
var productNames = sheet["A2:A100"]
.Select(cell => cell.StringValue)
.Where(name => !string.IsNullOrEmpty(name))
.ToList();
// Aggregate numeric columns directly
decimal totalRevenue = sheet["C2:C100"].Sum();
decimal averageOrder = sheet["C2:C100"].Avg();
Console.WriteLine($"Products loaded: {productNames.Count}");
Console.WriteLine($"Total revenue: {totalRevenue:C}");
Console.WriteLine($"Average order value: {averageOrder:C}");Imports IronXL
Dim workbook As WorkBook = WorkBook.LoadCSV("sales-data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read entire columns using range notation
Dim productNames = sheet("A2:A100") _
.Select(Function(cell) cell.StringValue) _
.Where(Function(name) Not String.IsNullOrEmpty(name)) _
.ToList()
' Aggregate numeric columns directly
Dim totalRevenue As Decimal = sheet("C2:C100").Sum()
Dim averageOrder As Decimal = sheet("C2:C100").Avg()
Console.WriteLine($"Products loaded: {productNames.Count}")
Console.WriteLine($"Total revenue: {totalRevenue:C}")
Console.WriteLine($"Average order value: {averageOrder:C}")To podejście oparte na zakresach pozwala uniknąć iteracji wiersz po wierszu w przypadku prostych agregacji, co poprawia wydajność w przypadku większych plików. Pełną listę obsługiwanych operacji na zakresach można znaleźć w dokumentacji IronXL.
Wiele procesów biznesowych wymaga danych CSV w formacie Excel do zaawansowanej analizy, formatowania lub dystrybucji. IronXL sprawia, że konwersja ta jest prosta, przy jednoczesnym zachowaniu integralności wszystkich danych.
using IronXL;
// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;
// Apply formatting before saving
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";
// Apply currency format to price column
sheet["B2:B1000"].FormatString = "$#,##0.00";
// Apply date format to date column
sheet["D2:D1000"].FormatString = "yyyy-MM-dd";
// Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx");
Console.WriteLine("Conversion complete: monthly-report.xlsx");Imports IronXL
' Load CSV file
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("monthly-report.csv")
Dim sheet As WorkSheet = csvWorkbook.DefaultWorkSheet
' Apply formatting before saving
sheet("A1:D1").Style.Font.Bold = True
sheet("A1:D1").Style.BackgroundColor = "#4472C4"
sheet("A1:D1").Style.Font.Color = "#FFFFFF"
' Apply currency format to price column
sheet("B2:B1000").FormatString = "$#,##0.00"
' Apply date format to date column
sheet("D2:D1000").FormatString = "yyyy-MM-dd"
' Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx")
Console.WriteLine("Conversion complete: monthly-report.xlsx")Konwersja zachowuje precyzję liczbową, formaty dat oraz znaki specjalne, które często powodują problemy przy ręcznych metodach konwersji. IronXL automatycznie optymalizuje strukturę wynikowego pliku Excel, tworząc wydajne pliki, które otwierają się szybko nawet w przypadku dużych zbiorów danych.
Aby uzyskać dodatkową kontrolę nad formatem wyjściowym, przewodnik dotyczący eksportu obejmuje opcje eksportu do formatów XLSX, XLS, CSV i PDF. Możesz również dowiedzieć się, jak pisać pliki Excel i tworzyć je od podstaw.
Gdy trzeba załadować dane CSV do DataSet do dalszego przetwarzania lub wstawienia do bazy danych, IronXL zapewnia bezpośrednie wsparcie konwersji. Szczegółowe wyjaśnienie znajduje się w przewodniku "Excel to DataSet":
using IronXL;
using System.Data;
WorkBook workbook = WorkBook.LoadCSV("customer-export.csv");
// Convert entire workbook to DataSet
DataSet dataSet = workbook.ToDataSet();
// The first sheet becomes the first DataTable
DataTable customerTable = dataSet.Tables[0];
Console.WriteLine($"Rows loaded: {customerTable.Rows.Count}");
Console.WriteLine($"Columns: {customerTable.Columns.Count}");
// Process with standard ADO.NET
foreach (DataRow row in customerTable.Rows)
{
string name = row["Name"]?.ToString() ?? string.Empty;
string email = row["Email"]?.ToString() ?? string.Empty;
Console.WriteLine($"Customer: {name} <{email}>");
}Imports IronXL
Imports System.Data
Dim workbook As WorkBook = WorkBook.LoadCSV("customer-export.csv")
' Convert entire workbook to DataSet
Dim dataSet As DataSet = workbook.ToDataSet()
' The first sheet becomes the first DataTable
Dim customerTable As DataTable = dataSet.Tables(0)
Console.WriteLine($"Rows loaded: {customerTable.Rows.Count}")
Console.WriteLine($"Columns: {customerTable.Columns.Count}")
' Process with standard ADO.NET
For Each row As DataRow In customerTable.Rows
Dim name As String = If(row("Name")?.ToString(), String.Empty)
Dim email As String = If(row("Email")?.ToString(), String.Empty)
Console.WriteLine($"Customer: {name} <{email}>")
NextTo podejście integruje się bezpośrednio z przepływami pracy ADO.NET i jest przydatne podczas przesyłania danych CSV do SQL Server, SQLite lub innych relacyjnych baz danych za pośrednictwem standardowych adapterów danych. Ponieważ DataSet i DataTable są podstawowymi typami .NET, ta ścieżka nie wymaga dodatkowych zależności poza samym IronXL.
Przetwarzanie dużych plików CSV — zawierających dziesiątki tysięcy wierszy lub więcej — wymaga zwrócenia uwagi na sposób uzyskiwania dostępu do danych oraz zarządzanie pamięcią. IronXL zawiera funkcje, które pomagają w pracy z dużymi plikami.
Aby uzyskać optymalną wydajność przy pracy z dużymi zbiorami danych, należy stosować operacje na zakresach zamiast uzyskiwać dostęp do poszczególnych komórek pojedynczo. Operacje na zakresach są przetwarzane bardziej efektywnie przez wewnętrzny silnik IronXL:
using IronXL;
WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;
Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns");
// Efficient: read entire range at once
var allData = sheet[$"A1:{GetColumnLetter(colCount)}{rowCount}"]
.Select(cell => cell.StringValue)
.ToList();
// Efficient: aggregate a column without row-by-row iteration
decimal columnSum = sheet[$"B2:B{rowCount}"].Sum();
Console.WriteLine($"Column B total: {columnSum}");
static string GetColumnLetter(int col)
{
string result = string.Empty;
while (col > 0)
{
col--;
result = (char)('A' + col % 26) + result;
col /= 26;
}
return result;
}Imports IronXL
Dim workbook As WorkBook = WorkBook.LoadCSV("large-dataset.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim rowCount As Integer = sheet.RowCount
Dim colCount As Integer = sheet.ColumnCount
Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns")
' Efficient: read entire range at once
Dim allData = sheet($"A1:{GetColumnLetter(colCount)}{rowCount}") _
.Select(Function(cell) cell.StringValue) _
.ToList()
' Efficient: aggregate a column without row-by-row iteration
Dim columnSum As Decimal = sheet($"B2:B{rowCount}").Sum()
Console.WriteLine($"Column B total: {columnSum}")
Private Shared Function GetColumnLetter(col As Integer) As String
Dim result As String = String.Empty
While col > 0
col -= 1
result = ChrW(AscW("A"c) + col Mod 26) & result
col \= 26
End While
Return result
End FunctionIronXL automatycznie obsługuje różne formaty kodowania tekstu (UTF-8, UTF-16, ASCII) podczas ładowania plików CSV, zapewniając prawidłowe wyświetlanie znaków międzynarodowych w wartościach kolumn bez dodatkowej konfiguracji. Jest to szczególnie ważne w przypadku plików eksportowanych z systemów w regionach, gdzie powszechnie stosuje się BOM UTF-8 lub alternatywne kodowania.
Podczas przetwarzania plików CSV z niezaufanych lub zmiennych źródeł, umieszczenie operacji w blokach try-catch zapewnia dodatkową warstwę bezpieczeństwa:
using IronXL;
string filePath = "user-uploaded-data.csv";
try
{
WorkBook workbook = WorkBook.LoadCSV(filePath);
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}");
for (int row = 2; row <= sheet.RowCount; row++)
{
string value = sheet[$"A{row}"].StringValue;
if (!string.IsNullOrWhiteSpace(value))
{
Console.WriteLine(value);
}
}
}
catch (IronXL.Exceptions.IronXLException ex)
{
Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}");
}
catch (IOException ex)
{
Console.WriteLine($"File access error: {ex.Message}");
}Imports IronXL
Module Module1
Sub Main()
Dim filePath As String = "user-uploaded-data.csv"
Try
Dim workbook As WorkBook = WorkBook.LoadCSV(filePath)
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}")
For row As Integer = 2 To sheet.RowCount
Dim value As String = sheet($"A{row}").StringValue
If Not String.IsNullOrWhiteSpace(value) Then
Console.WriteLine(value)
End If
Next
Catch ex As IronXL.Exceptions.IronXLException
Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}")
Catch ex As IOException
Console.WriteLine($"File access error: {ex.Message}")
End Try
End Sub
End ModulePoradniki IronXL obejmują wzorce importu danych z różnych źródeł, w tym plików, strumieni i tablic bajtów.
IronXL działa niezależnie od pakietu Microsoft Office, dzięki czemu nadaje się do środowisk serwerowych i wdrożeń w chmurze. Niezależnie od tego, czy wdrażasz na Windows, Linux, macOS, w kontenerach Docker, czy w funkcjach chmury na Azure lub AWS, IronXL zapewnia spójne wyniki na wszystkich platformach bez zmian w konfiguracji.
Ta wielopłatformowa funkcjonalność jest cenna w architekturach mikrousług, gdzie lekkie kontenery obsługują zadania przetwarzania danych. Przegląd funkcji IronXL zawiera pełną listę obsługiwanych środowisk i platform uruchomieniowych.
IronXL wymaga klucza licencyjnego do użytkowania w środowiskach produkcyjnych. Dostępna jest bezpłatna licencja próbna do oceny, a licencje komercyjne są dostępne dla indywidualnych programistów, zespołów i organizacji.
Zastosuj klucz licencyjny w swojej aplikacji przed wykonaniem jakichkolwiek wywołań IronXL:
using IronXL;
// Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
// Verify the license is active
if (IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE"))
{
Console.WriteLine("IronXL license is active.");
}
// Now use IronXL normally
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows.");Imports IronXL
' Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
' Verify the license is active
If IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE") Then
Console.WriteLine("IronXL license is active.")
End If
' Now use IronXL normally
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {sheet.RowCount} rows.")Aby zapoznać się z opcjami wersji próbnej i licencjonowania, odwiedź stronę licencyjną IronXL.
IronXL zmienia odczytywanie plików CSV w języku C# z żmudnego zadania parsowania w prostą operację. Biblioteka obsługuje typowe skrajne przypadki, w których ręczne parsowanie daje błędy — wbudowane przecinki, znaki nowej linii wewnątrz pól w cudzysłowie, niespójne separatory, różnice w kodowaniu i nieprawidłowo sformatowane wiersze — bez konieczności pisania niestandardowego kodu dla każdego scenariusza. Niezależnie od tego, czy potrzebujesz szybkiego, jednorazowego importu danych, czy też potoku produkcyjnego przetwarzającego tysiące plików dziennie, ten sam interfejs API działa w obu kontekstach.
Ręczne parsowanie CSV z string.Split lub StreamReader szybko się łamie, gdy pola w cudzysłowie zawierają znak separatora lub gdy w polach pojawiają się łamania linii. IronXL domyślnie obsługuje te przypadki poprawnie, zgodnie ze specyfikacją CSV dotyczącą obsługi pól w cudzysłowie i sekwencji escape.
Kluczowe zalety, które wyróżniają IronXL w pracy z plikami CSV w .NET 10:
listSeparatorStringValue, DecimalValue, IntValue i DateTimeValue zwracają bezpieczne wartości domyślne zamiast wyrzucać błędy dla złych danychDataSet / DataTable do operacji z ADO.NET i bazami danychDokumentacja IronXL oraz przewodnik po formatowaniu komórek zawierają dalsze szczegóły dotyczące formatowania, obsługi formuł oraz zaawansowanych operacji w skoroszytach.
Gotowy do pewnego obchodzenia się z plikami CSV? Zacznij od bezpłatnej wersji próbnej i poznaj pełen zestaw funkcji IronXL.
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.
