Làm thế nào để chuyển đổi dữ liệu Excel sang Web-Ready HTML Tables

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

// Path to your source Excel file
string excelFilePath = "data/quarterly-report.xlsx";

// Ensure the file exists
if (!File.Exists(excelFilePath))
{
    Console.WriteLine("Source file not found!");
    return;
}

// Create load options for the Excel file
LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
loadOptions.InputFile = excelFilePath;

// Configure HTML save options with your preferred settings
LowCodeHtmlSaveOptions saveOptions = new LowCodeHtmlSaveOptions();
HtmlSaveOptions htmlOptions = new HtmlSaveOptions();

// Customize HTML output options
htmlOptions.ExportImagesAsBase64 = true; // Embed images directly in HTML
htmlOptions.ExportActiveWorksheetOnly = false; // Convert all worksheets
htmlOptions.ExportHiddenWorksheets = false; // Skip hidden worksheets
htmlOptions.ExportGridLines = false; // Don't show gridlines
htmlOptions.CellNameAttribute = "data-cell"; // Custom attribute for cell reference

// If you want to convert specific worksheets only
htmlOptions.SheetSet = new Aspose.Cells.Rendering.SheetSet(new int[] { 0, 1 }); // Only first and second sheets

// Apply the HTML options to save options
saveOptions.HtmlOptions = htmlOptions;

// Set the output file path
saveOptions.OutputFile = "output/quarterly-report.html";

try
{
    // Execute the conversion process
    HtmlConverter.Process(loadOptions, saveOptions);
    Console.WriteLine("Conversion completed successfully!");
}
catch (Exception ex)
{
    Console.WriteLine($"Conversion failed: {ex.Message}");
}

// If you want to process the HTML output in memory instead of writing to a file
using (MemoryStream memoryStream = new MemoryStream())
{
    // Configure output stream
    LowCodeHtmlSaveOptions memoryOptions = new LowCodeHtmlSaveOptions();
    memoryOptions.HtmlOptions = htmlOptions; // Use the same HTML options as before
    memoryOptions.OutputStream = memoryStream;

    // Process to memory stream
    HtmlConverter.Process(loadOptions, memoryOptions);

    // Get HTML content as string
    memoryStream.Position = 0;
    string htmlContent = Encoding.UTF8.GetString(memoryStream.ToArray());

    // Now you can manipulate the HTML content as needed
    // For example, you could inject it into a webpage:
    Console.WriteLine("HTML content length: " + htmlContent.Length);
    
    // Check if specific elements are present
    if (htmlContent.Contains("data-cell=\"B2\""))
    {
        Console.WriteLine("Custom cell attributes are present in the HTML output.");
    }
}

try
{
    // Basic validation before conversion
    if (string.IsNullOrEmpty(loadOptions.InputFile))
    {
        throw new ArgumentException("Input file path cannot be empty");
    }

    // Check if output directory exists, create if not
    string outputDir = Path.GetDirectoryName(saveOptions.OutputFile);
    if (!string.IsNullOrEmpty(outputDir) && !Directory.Exists(outputDir))
    {
        Directory.CreateDirectory(outputDir);
    }

    // Execute conversion with validation
    HtmlConverter.Process(loadOptions, saveOptions);
    
    // Verify output file was created
    if (File.Exists(saveOptions.OutputFile))
    {
        Console.WriteLine($"HTML file successfully created at: {saveOptions.OutputFile}");
    }
    else
    {
        Console.WriteLine("Warning: Output file was not created.");
    }
}
catch (CellsException cex)
{
    // Handle Aspose.Cells specific exceptions
    Console.WriteLine($"Aspose.Cells error: {cex.Message}");
    // Log additional information
    Console.WriteLine($"Error code: {cex.Code}");
}
catch (IOException ioex)
{
    // Handle file access issues
    Console.WriteLine($"File access error: {ioex.Message}");
}
catch (Exception ex)
{
    // General error handling
    Console.WriteLine($"Error: {ex.Message}");
    Console.WriteLine($"Stack trace: {ex.StackTrace}");
}

// Example of optimized batch processing
public void BatchConvertExcelFilesToHtml(string[] excelFiles, string outputDirectory)
{
    // Create output directory if it doesn't exist
    if (!Directory.Exists(outputDirectory))
    {
        Directory.CreateDirectory(outputDirectory);
    }

    // Configure common HTML options once
    HtmlSaveOptions commonHtmlOptions = new HtmlSaveOptions();
    commonHtmlOptions.ExportImagesAsBase64 = true;
    commonHtmlOptions.ExportGridLines = false;

    // Process files in parallel for better performance
    Parallel.ForEach(excelFiles, excelFile =>
    {
        try
        {
            // Create instance-specific options
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions { InputFile = excelFile };
            LowCodeHtmlSaveOptions saveOptions = new LowCodeHtmlSaveOptions();
            saveOptions.HtmlOptions = commonHtmlOptions;
            
            // Generate output filename
            string fileName = Path.GetFileNameWithoutExtension(excelFile) + ".html";
            saveOptions.OutputFile = Path.Combine(outputDirectory, fileName);
            
            // Process conversion
            HtmlConverter.Process(loadOptions, saveOptions);
            
            Console.WriteLine($"Converted: {excelFile}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error converting {excelFile}: {ex.Message}");
        }
    });
}

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;

namespace ExcelToHtmlConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // Simple conversion with default options
                SimpleHtmlConversion();
                
                // Advanced conversion with custom options
                AdvancedHtmlConversion();
                
                // Memory stream conversion
                MemoryStreamHtmlConversion();
                
                // Batch processing example
                BatchProcessing();
                
                Console.WriteLine("All conversions completed successfully!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }
        
        static void SimpleHtmlConversion()
        {
            // Simple conversion using default settings
            string sourcePath = "data/source.xlsx";
            string outputPath = "output/simple-output.html";
            
            // Ensure output directory exists
            Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
            
            // One-line conversion with default settings
            HtmlConverter.Process(sourcePath, outputPath);
            
            Console.WriteLine($"Simple conversion completed: {outputPath}");
        }
        
        static void AdvancedHtmlConversion()
        {
            // Advanced conversion with custom options
            string sourcePath = "data/complex-report.xlsx";
            
            // Configure load options
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
            loadOptions.InputFile = sourcePath;
            
            // Configure save options
            LowCodeHtmlSaveOptions saveOptions = new LowCodeHtmlSaveOptions();
            HtmlSaveOptions htmlOptions = new HtmlSaveOptions();
            
            // Customize HTML output
            htmlOptions.ExportImagesAsBase64 = true;
            htmlOptions.CellNameAttribute = "data-excel-cell";
            htmlOptions.ExportGridLines = false;
            htmlOptions.ExportHeadings = true;
            htmlOptions.HtmlCrossStringType = HtmlCrossType.Default;
            
            // Only export the first sheet
            htmlOptions.SheetSet = new SheetSet(new int[] { 0 });
            
            // Apply HTML options and set output path
            saveOptions.HtmlOptions = htmlOptions;
            saveOptions.OutputFile = "output/advanced-output.html";
            
            // Process the conversion
            HtmlConverter.Process(loadOptions, saveOptions);
            
            Console.WriteLine($"Advanced conversion completed: {saveOptions.OutputFile}");
        }
        
        static void MemoryStreamHtmlConversion()
        {
            // In-memory conversion example
            string sourcePath = "data/metrics.xlsx";
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
            loadOptions.InputFile = sourcePath;
            
            // Setup HTML options
            LowCodeHtmlSaveOptions saveOptions = new LowCodeHtmlSaveOptions();
            HtmlSaveOptions htmlOptions = new HtmlSaveOptions();
            htmlOptions.CellNameAttribute = "data-ref";
            saveOptions.HtmlOptions = htmlOptions;
            
            // Use memory stream instead of file output
            using (MemoryStream stream = new MemoryStream())
            {
                saveOptions.OutputStream = stream;
                
                // Process to memory
                HtmlConverter.Process(loadOptions, saveOptions);
                
                // Get HTML content as string
                stream.Position = 0;
                string htmlContent = Encoding.UTF8.GetString(stream.ToArray());
                
                // Process HTML content as needed
                Console.WriteLine($"Generated HTML content size: {htmlContent.Length} bytes");
                
                // You could now send this to a web client, save to database, etc.
                File.WriteAllText("output/memory-stream-output.html", htmlContent);
            }
            
            Console.WriteLine("Memory stream conversion completed");
        }
        
        static void BatchProcessing()
        {
            // Get all Excel files in a directory
            string sourceDirectory = "data/batch";
            string outputDirectory = "output/batch";
            
            // Create output directory
            Directory.CreateDirectory(outputDirectory);
            
            // Get all Excel files
            string[] excelFiles = Directory.GetFiles(sourceDirectory, "*.xlsx");
            
            Console.WriteLine($"Starting batch conversion of {excelFiles.Length} files...");
            
            // Process files in parallel
            Parallel.ForEach(excelFiles, excelFile =>
            {
                try
                {
                    // Setup conversion options for this file
                    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
                    loadOptions.InputFile = excelFile;
                    
                    LowCodeHtmlSaveOptions saveOptions = new LowCodeHtmlSaveOptions();
                    saveOptions.OutputFile = Path.Combine(
                        outputDirectory, 
                        Path.GetFileNameWithoutExtension(excelFile) + ".html"
                    );
                    
                    // Execute conversion
                    HtmlConverter.Process(loadOptions, saveOptions);
                    
                    Console.WriteLine($"Converted: {Path.GetFileName(excelFile)}");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Failed to convert {Path.GetFileName(excelFile)}: {ex.Message}");
                }
            });
            
            Console.WriteLine("Batch processing completed");
        }
    }
}