Aspose.Cells Textový převodník pro .NET

Aspose.Cells Text Converter for .NET is a high-performance API tailored for converting Microsoft Excel workbooks (XLS, XLSX, XLSM) into multiple text-based formats—including CSV, TSV, XML, and SQLSCRIPT—and vice versa. Built on the robust Aspose.Cells engine, this plugin streamlines text conversion workflows for data-migration tools, reporting pipelines, ETL processes, and spreadsheet processing services.

Instalace a nastavení

1. ${SheetIndex}: Index listu (ve výchozím nastavení 0‑základní, přizpůsobitelné posunem).
2. Nakonfigurujte licencování na bázi měření, aby se předešlo omezením hodnocení.

Pro podrobnou konfiguraci viz Instalace průvodce. Pro licencování postupujte podle Měřené licencování .

Funkce a vlastnosti

Komplexní podpora formátů

• Vstup: XLS, XLSX, XLSM , CSV, TSV, XML, TXT
• Výstup: CSV, TSV, XML (přizpůsobitelné), SQLSCRIPT (připravené INSERT příkazy pro databázi), XLSX, XLS
• Obousměrná konverze: Převést z Excelu do textových formátů A z textových formátů zpět do Excelu
• Podporuje obousměrné konverze mezi Excel sešity a textovými formáty

Inteligentní detekce formátu

• Automatické určení formátu: Detekuje vstupní a výstupní formáty podle přípon souborů
• Zpracování založené na příponách: Není nutné specifikovat SaveFormat pro běžné konverze
• Inteligentní detekce: Rozpozná .csv, .tsv, .txt, .xlsx, .xls a další automaticky

LowCode API pro zjednodušenou konverzi

• Jednořádkové konverze: Převádějte soubory jedním voláním metody
• Minimální konfigurace: Automatická detekce formátu snižuje boilerplate code
• Optimalizovaný výkon: Zjednodušená cesta provádění pro běžné scénáře
• Jednoduchá integrace: Náhrada typu drop-in pro složitou konverzní logiku

Přizpůsobení oddělovačů a kódování

• Definujte vlastní oddělovače, uvozovkové znaky a escape sekvence pro CSV/TSV
• Řiďte kódování (UTF-8, UTF-16, ISO-8859-1, atd.) pro kompatibilitu
• Zachovat písma, styly, barvy, orámování, okraje, záhlaví a zápatí.

Řízení struktury XML

• Mapujte data listu do XML elementů a atributů pomocí vlastních šablon
• Nastavte kořenové elementy, jmenné prostory a výstup odpovídající schématu
• Podporuje řádkově orientované a buňkově orientované XML reprezentace

Generování SQLSCRIPT

• Automaticky převádí každý řádek na SQL INSERT příkazy
• Přizpůsobte názvy tabulek, seznamy sloupců a formátování hodnot
• Dávkově zpracujte více INSERTů pro optimalizované provádění v relačních databázích

Kontingenční tabulky

• Převod založený na streamu pro velké sešity
• Paralelní převod pomocí vícejádrových systémů
• Lehký pro exporty jednoho listu, vysoká propustnost pro hromadné převody

Výstup založený na proudu: Zapište do paměťových streamů pro zpracování v paměti.

• Jasná hierarchie výjimek pro chyby konverze, porušení formátu a problémy I/O
• Ověřovací hooky pro kontrolu/opravu dat před/po konverzi
• Integrační body pro .NET logovací frameworky

Příklady použití

Základní konverze: CSV do Excelu (LowCode API)

Nejjednodušší způsob, jak převést textový soubor do Excelu pomocí automatické detekce formátu:

using Aspose.Cells.LowCode;

// Convert CSV to XLSX (formats inferred from extensions)
TextConverter.Process("data.csv", "output.xlsx");

Není nutné specifikovat formáty — API automaticky detekuje vstup CSV a výstup XLSX na základě přípon souborů.

Základní konverze: Excel do CSV

Převádějte soubory Excel do formátu CSV stejně snadno:

using Aspose.Cells.LowCode;

// Convert XLSX to CSV (formats inferred from extensions)
TextConverter.Process("spreadsheet.xlsx", "output.csv");

Příklad implementace měřeného licencování

Kompletní aplikace ukazující nastavení licencí a konverzi:

using System;
using Aspose.Cells;
using Aspose.Cells.LowCode;

class ConvertTextToExcel
{
    static void Main()
    {
        // Optional: Configure metered licensing for production use
        // new Metered().SetMeteredKey("PublicKey", "PrivateKey");

        // Convert CSV to XLSX (formats inferred from extensions)
        TextConverter.Process("sample.csv", "output.xlsx");
        
        Console.WriteLine("✓ Conversion completed successfully");
    }
}

Rozpis funkcí: Automatická detekce formátu

LowCode API inteligentně detekuje formáty z přípon souborů:

// CSV to Excel
TextConverter.Process("input.csv", "output.xlsx");   // Detects CSV → XLSX

// TSV to Excel
TextConverter.Process("input.tsv", "output.xlsx");   // Detects TSV → XLSX

// Excel to CSV
TextConverter.Process("input.xlsx", "output.csv");   // Detects XLSX → CSV

// Excel to TSV
TextConverter.Process("input.xlsx", "output.tsv");   // Detects XLSX → TSV

// TXT to Excel
TextConverter.Process("input.txt", "output.xlsx");   // Detects TXT → XLSX

// Excel to TXT
TextConverter.Process("input.xlsx", "output.txt");   // Detects XLSX → TXT

Podporovaná rozšíření:

• Excel: .xlsx, .xls, .xlsm, .xltx, .xltm, .xlsb
• Text: .csv, .tsv, .txt
• XML: .xml
• Ostatní: Automaticky detekováno na základě přípony

Rozpis funkcí: Obousměrná konverze

Textový převodník podporuje konverzi v obou směrech:

Text do Excelu:

// Import CSV data into Excel workbook
TextConverter.Process("sales_data.csv", "sales_report.xlsx");

// Import TSV data into Excel
TextConverter.Process("tab_delimited.tsv", "formatted_data.xlsx");

// Import XML into Excel
TextConverter.Process("data_export.xml", "spreadsheet.xlsx");

Excel do Textu:

// Export Excel data to CSV
TextConverter.Process("inventory.xlsx", "inventory_export.csv");

// Export Excel to tab-delimited file
TextConverter.Process("report.xlsx", "report_data.tsv");

// Export Excel to plain text
TextConverter.Process("notes.xlsx", "notes.txt");

Co je Aspose.Cells Image Converter pro .NET? Zaměřený nástroj pro programatickou konverzi tabulek Excel na obrázky v aplikacích .NET..:

• Migrace dat: Přesunout data mezi Excel a databázovými systémy
• ETL Pipelines: Extrahovat data z Excelu pro zpracování
• Reportování: Převést textové logy do Excelu pro analýzu
• Integrace: Vyměňovat data se systémy, které podporují pouze textové formáty
• Archivace: Převést soubory Excel na prostý text pro dlouhodobé ukládání

Před a po:

Porovnejte zjednodušené LowCode API s tradičním přístupem:

Rozpis funkcí: Výstup založený na souboru vs výstup založený na proudu:

using Aspose.Cells.LowCode;

// One line, automatic format detection
TextConverter.Process("data.csv", "output.xlsx");

Tradiční API (pro pokročilou úpravu):

using Aspose.Cells;

// Load workbook
Workbook workbook = new Workbook("sample.xlsx");

// Configure CSV options
TxtSaveOptions options = new TxtSaveOptions();
options.Separator = ',';
options.Encoding = System.Text.Encoding.UTF8;
options.QuoteType = TxtValueQuoteType.Always;

// Save with custom options
workbook.Save("output.csv", options);

Kdy použít který:

• LowCode API: Standardní konverze, vyžadována automatická detekce, minimální kód
• Tradiční API: Vlastní oddělovače, řízení kódování, možnosti specifické pro formát

Pokročilé: Vlastní možnosti CSV s tradičním API

Pro detailní kontrolu výstupu CSV:

using Aspose.Cells;

// Load your source workbook
Workbook workbook = new Workbook("sample.xlsx");

// Configure CSV export options
TxtSaveOptions csvOptions = new TxtSaveOptions(SaveFormat.Csv);
csvOptions.Separator = ';';  // Use semicolon instead of comma
csvOptions.Encoding = System.Text.Encoding.UTF8;
csvOptions.QuoteType = TxtValueQuoteType.Always;
csvOptions.KeepSeparatorsForBlankRow = false;
csvOptions.ExportAllSheets = false;  // Export only active sheet

// Save the workbook to CSV format
workbook.Save("output.csv", csvOptions);

Pokročilé: TSV konverze s možnostmi

Exportovat do hodnot oddělených tabulátorem s vlastními nastaveními:

using Aspose.Cells;

Workbook workbook = new Workbook("data.xlsx");

TxtSaveOptions tsvOptions = new TxtSaveOptions(SaveFormat.Tsv);
tsvOptions.Separator = '\t';  // Tab character
tsvOptions.Encoding = System.Text.Encoding.UTF8;

workbook.Save("output.tsv", tsvOptions);

Příklad hromadné konverze

Převést více souborů CSV do formátu Excel:

using System;
using Aspose.Cells.LowCode;
using System.IO;
using Aspose.Cells;

string[] csvFiles = Directory.GetFiles(".", "*.csv");

foreach (string csvFile in csvFiles)
{
    try
    {
        string outputFile = Path.GetFileNameWithoutExtension(csvFile) + ".xlsx";

        TextConverter.Process(csvFile, outputFile);

        Console.WriteLine($"✓ Converted: {Path.GetFileName(csvFile)}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"✗ Error converting {csvFile}: {ex.Message}");
    }
}

Console.WriteLine($"Batch conversion complete. Processed {csvFiles.Length} files.");

Integrace ETL pipeline

Integrujte převod textu do pracovních postupů zpracování dat:

using Aspose.Cells.LowCode;
using System.Data;

public class DataPipeline
{
    public void ImportCsvToDatabase(string csvPath, string connectionString)
    {
        // Step 1: Convert CSV to Excel for easier data manipulation
        string excelPath = Path.GetTempFileName() + ".xlsx";
        TextConverter.Process(csvPath, excelPath);
        
        // Step 2: Load Excel and process data
        Workbook workbook = new Workbook(excelPath);
        Worksheet sheet = workbook.Worksheets[0];
        
        // Step 3: Extract data and insert into database
        DataTable dataTable = sheet.Cells.ExportDataTable(0, 0, 
            sheet.Cells.MaxDataRow + 1, 
            sheet.Cells.MaxDataColumn + 1, 
            true);  // First row has headers
        
        // Step 4: Bulk insert into database
        using (SqlConnection conn = new SqlConnection(connectionString))
        {
            conn.Open();
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(conn))
            {
                bulkCopy.DestinationTableName = "ImportedData";
                bulkCopy.WriteToServer(dataTable);
            }
        }
        
        // Clean up
        File.Delete(excelPath);
        
        Console.WriteLine($"✓ Imported {dataTable.Rows.Count} rows from {csvPath}");
    }
}

Není vyžadován diskový I/O

Zpracovávejte nahrávání textových souborů a jejich převody v ASP.NET Core:

[HttpPost("convert-csv-to-excel")]
public IActionResult ConvertCsvToExcel(IFormFile file)
{
    try
    {
        // Save uploaded CSV
        string csvPath = Path.GetTempFileName();
        using (var stream = new FileStream(csvPath, FileMode.Create))
        {
            file.CopyTo(stream);
        }
        
        // Convert to Excel
        string excelPath = Path.ChangeExtension(csvPath, ".xlsx");
        TextConverter.Process(csvPath, excelPath);
        
        // Read result
        byte[] fileBytes = File.ReadAllBytes(excelPath);
        
        // Clean up
        File.Delete(csvPath);
        File.Delete(excelPath);
        
        return File(fileBytes, 
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            Path.GetFileNameWithoutExtension(file.FileName) + ".xlsx");
    }
    catch (Exception ex)
    {
        return StatusCode(500, $"Conversion error: {ex.Message}");
    }
}

Generování SQL skriptů

Převod dat z Excelu na SQL INSERT příkazy:

using Aspose.Cells;
using Aspose.Cells.Saving;

Workbook workbook = new Workbook("sample.xlsx");

SqlScriptSaveOptions sqlOptions = new SqlScriptSaveOptions();
sqlOptions.TableName = "Employees";
sqlOptions.OperatorType = SqlScriptOperatorType.Insert;
sqlOptions.Separator = ';';

workbook.Save("insert_employees.sql", sqlOptions);

${SheetIndex}: Index listu (s aplikovaným posunem)

Optimalizace výkonu

• Použijte LowCode API: Využijte TextConverter.Process() pro optimalizované, jednořádkové konverze.
• Zpracování streamu: Používejte streamy pro velké soubory, abyste minimalizovali využití paměti.
• Dávkové operace: Zpracovávejte více souborů paralelně pro scénáře s vysokou propustností.
• Uvolňování prostředků: Okamžitě uvolňujte objekty sešitu při použití tradičního API.

Detekce formátu

• Přípony souborů: Používejte standardní přípony (.csv, .tsv, .xlsx) pro automatické rozpoznání formátu.
• Explicitní formáty: Použijte tradiční API s SaveFormat enum pro nestandardní rozšíření.
• Validace: Ověřte formát vstupního souboru před konverzí, aby se předešlo chybám.

Pokročilá kontrola stránkování

• Kódování: Přizpůsobte nastavení kódování cílovým systémům, aby nedocházelo k poškození znaků.
• Oddělovače: Vyberte vhodné oddělovače podle obsahu dat (vyhněte se znakům, které se v datech vyskytují).
• Hlavičky: Zajistěte, aby soubory CSV/TSV měly konzistentní řádky hlaviček pro konverzi do Excelu.
• Prázdné řádky: Nakonfigurujte zpracování prázdných řádků, aby nedocházelo k zbytečným mezerám v datech.

Pokrytí formátu

• Měřené licencování: Inicializujte licencování při spuštění aplikace: new Metered().SetMeteredKey("PublicKey", "PrivateKey")
• Zpracování chyb: Zabalte volání konverze do bloků try-catch s konkrétním zpracováním výjimek.
• Bezpečnost vláken: API LowCode je bezpečné pro vlákna; vytvořte samostatné objekty Workbook pro každé vlákno pro tradiční API.
• Logování: Implementujte logování pro metriky konverze (velikost souboru, počet řádků, doba).
• Dočasné soubory: Vyčistit dočasné soubory vytvořené během zpracování webové aplikace.

Strategie integrace

• ETL pracovní postupy: Použijte Text Converter jako první krok v datových pipelinech.
• API koncové body: Vraťte převedené soubory přímo z webových API pomocí streamů.
• Import databáze: Převeďte CSV do Excelu pro validaci dat před vložením do databáze.
• Zpracování šablon: Ukládejte šablony XML/SQLSCRIPT externě pro snadné aktualizace.

Zachovává vzorce, styly, sloučené oblasti a metadata sešitu.

Často kladené otázky

Co je Aspose.Cells Text Converter pro .NET? Zaměřené API pro obousměrnou konverzi mezi tabulkami Excel a textovými formáty, jako jsou CSV, TSV, XML a SQLSCRIPT.

Jak se liší od Aspose.Cells pro .NET? Aspose.Cells is a multifunctional library. The Text Converter provides streamlined APIs specifically for text-focused conversion tasks.

Které formáty jsou podporovány? XLS, XLSX, XLSM, CSV, TSV, XML, TXT, SQLSCRIPT a další.

Mohu převést soubory CSV do Excelu? Ano! Text Converter podporuje obousměrnou konverzi: Excel ↔ CSV, Excel ↔ TSV, Excel ↔ TXT atd.

Jak funguje automatické rozpoznávání formátu? LowCode API odvozuje vstupní a výstupní formáty z přípon souborů (.csv, .xlsx, atd.), čímž eliminuje potřebu explicitně uvádět formáty.

Kdy mám použít LowCode vs Traditional API? Použijte LowCode API (TextConverter.Process()) pro jednoduché, standardní konverze. Použijte tradiční API, když potřebujete vlastní oddělovače, kódování nebo možnosti specifické pro formát.

Lze přizpůsobit nastavení generování textu? Ano, pomocí SaveOptions podtříd, jako jsou TxtSaveOptions, SqlScriptSaveOptions, atd. s tradičním Workbook API.

Musím zadat parametr SaveFormat? Ne s LowCode API—formáty jsou automaticky detekovány z přípon souborů. S tradičním API můžete specifikovat SaveFormat explicitně.

Můžu převést více listů do samostatných CSV souborů? Ano, projděte listy a exportujte každý samostatně, nebo použijte TxtSaveOptions.ExportAllSheets k řízení chování.

Je vyžadováno metered licensing? Metered licensing je volitelné, ale doporučuje se pro produkci, aby se předešlo omezením hodnocení a sledovalo se využití.

Vlastní mapování JSON schématu

Mapovat rozsahy na pole JSON nebo objekty.

• TextConverter: Statická třída poskytující zjednodušené, detekující formát konverzní metody
• Workbook: Tradiční třída API pro načítání a manipulaci se soubory Excel
• TxtSaveOptions: Konfigurace pro export CSV/TSV s vlastními oddělovači a kódováním
• TxtLoadOptions: Konfigurace pro načítání souborů CSV/TSV do Excelu
• SqlScriptSaveOptions: Konfigurace pro generování SQL skriptů
• Metered: Třída pro konfiguraci měřeného licencování

Základní metody

• TextConverter.Process(inputPath, outputPath): Jednořádková konverze s automatickým rozpoznáním formátu
• Workbook.Save(path, SaveFormat): Uložit sešit ve zvoleném formátu
• Workbook.Save(path, SaveOptions): Uložit sešit s vlastními možnostmi
• Metered.SetMeteredKey(publicKey, privateKey): Inicializovat měřenou licenci

Klíčové vlastnosti (TxtSaveOptions)

• Separator: Znak používaný k oddělení hodnot (výchozí: čárka pro CSV, tabulátor pro TSV)
• Encoding: Kódování textu (UTF-8, UTF-16, atd.)
• QuoteType: Jak citovat hodnoty (Vždy, Podle potřeby, Nikdy)
• ExportAllSheets: Exportovat všechny listy nebo jen aktivní list
• KeepSeparatorsForBlankRow: Zahrnout oddělovače pro prázdné řádky

Podporované hodnoty SaveFormat

• SaveFormat.Csv: Hodnoty oddělené čárkou
• SaveFormat.Tsv: Hodnoty oddělené tabulátorem
• SaveFormat.Txt: Prostý text
• SaveFormat.Xml: Formát dat XML