Introduction

Šiame straipsnyje parodyta, kaip įgyvendinti verslui skirtą „Excel“ formato migracijos strategiją naudojant „Aspose.Cells LowCode Converters“ .NET programose, o „LowCodes Converters“ siūlo supaprastintą požiūrį į didelio masto dokumentų migracijų projektus, nereikalaujant išsamios kodavimo ar gilios žinios apie Excel vidaus struktūras.

Realaus pasaulio problemos

Organizacijos dažnai sukaupia tūkstančius “Excel” dokumentų įvairiuose formatuose per departamentus, sukuriant suderinamumo problemas atnaujinant sistemas ar standartizuojant procesus. IT vadybininkai ir migracijos specialistai susiduria su iššūkiais, palaikydami duomenų vientisumą, išsaugodami formules ir formatavimą, užtikrinant saugumo laikymąsi ir valdant didelio masto konvertavimų poveikį.

Sprendimo apžvalga

Naudodami „Aspose.Cells LowCode Converters“, mes galime įgyvendinti išsamią migracijos strategiją, kuri efektyviai konvertuoja dokumentus tarp formatų, išlaikydama kritinius verslo duomenis.Šis sprendimas idealus IT direktoriams ir migracijų specialistams, kurie turi organizuoti sudėtingą, įmonei skirtą dokumentų standartizaciją su minimaliu veiklos sutrikimu.

Prerequisites

Prieš įgyvendinant sprendimą, įsitikinkite, kad turite:

  • „Visual Studio 2019“ arba vėliau
  • .NET 6.0 arba naujesnė (kompatyvi su .Net Framework 4.6.2+)
  • Aspose.Cells .NET paketui, įdiegtam naudojant NuGet
  • Pagrindinis C# programavimo supratimas
PM> Install-Package Aspose.Cells

Žingsnis po žingsnio įgyvendinimas

1 žingsnis: Įdiegti ir konfigūruoti Aspose.Cells

Į savo projektą pridėkite Aspose.Cells paketą ir įtraukti reikiamus pavadinimų erdves:

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

2 žingsnis: sukurkite savo migracijos sistemą

Sukurkite centralizuotą migracijos paslaugų klasę, kuri tvarkys skirtingus konvertavimo tipus:

public class ExcelMigrationService
{
    private readonly string _sourceDirectory;
    private readonly string _outputDirectory;
    private readonly string _logPath;
    
    public ExcelMigrationService(string sourceDirectory, string outputDirectory, string logPath)
    {
        _sourceDirectory = sourceDirectory;
        _outputDirectory = outputDirectory;
        _logPath = logPath;
        
        // Ensure output directory exists
        if (!Directory.Exists(_outputDirectory))
            Directory.CreateDirectory(_outputDirectory);
            
        // Ensure result subdirectories exist
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "xlsx"));
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "pdf"));
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "html"));
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "json"));
    }
    
    // Methods to be implemented
}

3 žingsnis: Įdiegti Migracijos formatą su SpreadsheetConverter

Pridėti konvertavimo metodus, kad galėtumėte migruoti Excel formatus:

public void MigrateToModernFormat(string inputFile, SaveFormat targetFormat)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "xlsx", $"{fileName}.xlsx");
        
        // Configure options for conversion
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
        lcsopts.SaveFormat = targetFormat;
        lcsopts.OutputFile = outputFile;
        
        // Execute the conversion
        SpreadsheetConverter.Process(lclopts, lcsopts);
        
        LogConversion($"Converted {inputFile} to {outputFile} successfully.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error converting {inputFile}: {ex.Message}");
        throw;
    }
}

public void BatchConvertDirectory(SaveFormat targetFormat)
{
    string[] excelFiles = Directory.GetFiles(_sourceDirectory, "*.xls*", SearchOption.AllDirectories);
    int successCount = 0;
    int failureCount = 0;
    
    foreach (string file in excelFiles)
    {
        try
        {
            MigrateToModernFormat(file, targetFormat);
            successCount++;
        }
        catch
        {
            failureCount++;
        }
    }
    
    LogConversion($"Batch conversion completed. Success: {successCount}, Failures: {failureCount}");
}

4 žingsnis: PDF konvertavimas į archyvą

PDF konvertavimo įgyvendinimas archyvų reikalavimams:

public void ConvertToPdf(string inputFile, bool onePagePerSheet = true)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "pdf", $"{fileName}.pdf");
        
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodePdfSaveOptions lcsopts = new LowCodePdfSaveOptions();
        PdfSaveOptions pdfOpts = new PdfSaveOptions();
        pdfOpts.OnePagePerSheet = onePagePerSheet;
        lcsopts.PdfOptions = pdfOpts;
        lcsopts.OutputFile = outputFile;
        
        PdfConverter.Process(lclopts, lcsopts);
        
        LogConversion($"Converted {inputFile} to PDF successfully.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error converting {inputFile} to PDF: {ex.Message}");
        throw;
    }
}

public void BatchConvertToPdf(bool onePagePerSheet = true)
{
    string[] excelFiles = Directory.GetFiles(_sourceDirectory, "*.xls*", SearchOption.AllDirectories);
    
    foreach (string file in excelFiles)
    {
        try
        {
            ConvertToPdf(file, onePagePerSheet);
        }
        catch
        {
            // Failures are logged in the ConvertToPdf method
        }
    }
}

5 žingsnis: HTML konvertavimas į interneto prieigą

Sukurkite HTML konvertavimą žiniatinklio dokumentų prieigai:

public void ConvertToHtml(string inputFile, string cellNameAttribute = null)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "html", $"{fileName}.html");
        
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodeHtmlSaveOptions lcsopts = new LowCodeHtmlSaveOptions();
        HtmlSaveOptions htmlOpts = new HtmlSaveOptions();
        
        if (!string.IsNullOrEmpty(cellNameAttribute))
            htmlOpts.CellNameAttribute = cellNameAttribute;
            
        // Configure to export only the first sheet
        htmlOpts.SheetSet = new Aspose.Cells.Rendering.SheetSet(new int[] { 0 });
        lcsopts.HtmlOptions = htmlOpts;
        lcsopts.OutputFile = outputFile;
        
        HtmlConverter.Process(lclopts, lcsopts);
        
        LogConversion($"Converted {inputFile} to HTML successfully.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error converting {inputFile} to HTML: {ex.Message}");
        throw;
    }
}

6 žingsnis: Įdiegti JSON konvertavimą duomenų integracijai

Pridėti JSON konvertavimą duomenų integracijai su šiuolaikinėmis sistemomis:

public string ConvertToJson(string inputFile)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "json", $"{fileName}.json");
        
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
        lcsopts.OutputFile = outputFile;
        
        JsonConverter.Process(lclopts, lcsopts);
        
        LogConversion($"Converted {inputFile} to JSON successfully.");
        return outputFile;
    }
    catch (Exception ex)
    {
        LogConversion($"Error converting {inputFile} to JSON: {ex.Message}");
        throw;
    }
}

7 žingsnis: Pridėti saugumą su „SpreadsheetLocker“

Įdiegti slaptažodžio apsaugą jautriems dokumentams:

public void SecureDocument(string inputFile, string password)
{
    try
    {
        string fileName = Path.GetFileNameWithoutExtension(inputFile);
        string outputFile = Path.Combine(_outputDirectory, "secured", $"{fileName}_secured.xlsx");
        
        // Ensure secured directory exists
        Directory.CreateDirectory(Path.Combine(_outputDirectory, "secured"));
        
        LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
        lclopts.InputFile = inputFile;
        
        LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
        lcsopts.SaveFormat = SaveFormat.Xlsx;
        lcsopts.OutputFile = outputFile;
        
        SpreadsheetLocker.Process(lclopts, lcsopts, password, null);
        
        LogConversion($"Secured {inputFile} with password protection successfully.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error securing {inputFile}: {ex.Message}");
        throw;
    }
}

8 žingsnis: konsolidacijos įgyvendinimo dokumentas

Pridėti galimybes derinti dokumentus ataskaitų konsolidacijai:

public void MergeDocuments(List<string> inputFiles, string outputFileName)
{
    try
    {
        string outputFile = Path.Combine(_outputDirectory, $"{outputFileName}.xlsx");
        
        LowCodeMergeOptions lcmOpts = new LowCodeMergeOptions();
        lcmOpts.LoadOptionsProvider = new CustomMergerSourceProvider(inputFiles);
        
        LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
        lcsopts.OutputFile = outputFile;
        lcsopts.SaveFormat = SaveFormat.Xlsx;
        lcmOpts.SaveOptions = lcsopts;
        
        SpreadsheetMerger.Process(lcmOpts);
        
        LogConversion($"Successfully merged {inputFiles.Count} documents into {outputFile}.");
    }
    catch (Exception ex)
    {
        LogConversion($"Error merging documents: {ex.Message}");
        throw;
    }
}

private class CustomMergerSourceProvider : AbstractLowCodeLoadOptionsProvider
{
    private readonly List<string> _sourceFiles;
    private int _currentIndex = -1;
    
    public CustomMergerSourceProvider(List<string> sourceFiles)
    {
        _sourceFiles = sourceFiles;
    }
    
    public override bool MoveNext()
    {
        _currentIndex++;
        return _currentIndex < _sourceFiles.Count;
    }
    
    public override LowCodeLoadOptions Current
    {
        get
        {
            LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
            lclopts.InputFile = _sourceFiles[_currentIndex];
            return lclopts;
        }
    }
}

9 žingsnis: pridėti prisijungimo funkciją

Visapusiškas audito maršrutų registravimas:

private void LogConversion(string message)
{
    string logEntry = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}";
    File.AppendAllText(_logPath, logEntry + Environment.NewLine);
    Console.WriteLine(logEntry);
}

10 žingsnis: pilnas įgyvendinimo pavyzdys

Štai pilnas darbo pavyzdys, kuris parodo visą procesą:

using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace EnterpriseExcelMigration
{
    class Program
    {
        static void Main(string[] args)
        {
            // Define paths
            string sourceDirectory = @"C:\SourceExcelFiles";
            string outputDirectory = @"C:\MigratedFiles";
            string logPath = @"C:\Logs\migration_log.txt";
            
            try
            {
                // Initialize migration service
                ExcelMigrationService migrationService = new ExcelMigrationService(
                    sourceDirectory, outputDirectory, logPath);
                
                Console.WriteLine("Starting enterprise Excel migration process...");
                
                // Convert all Excel files to XLSX format
                migrationService.BatchConvertDirectory(SaveFormat.Xlsx);
                
                // Create PDF versions for archival
                migrationService.BatchConvertToPdf(true);
                
                // Generate HTML for web access (sample file)
                string sampleFile = Path.Combine(sourceDirectory, "financial_report.xls");
                if (File.Exists(sampleFile))
                {
                    migrationService.ConvertToHtml(sampleFile, "CellIdentifier");
                }
                
                // Extract data from critical files to JSON for system integration
                List<string> criticalFiles = new List<string>
                {
                    Path.Combine(sourceDirectory, "quarterly_data.xlsx"),
                    Path.Combine(sourceDirectory, "annual_report.xls")
                };
                
                foreach (string file in criticalFiles)
                {
                    if (File.Exists(file))
                    {
                        migrationService.ConvertToJson(file);
                    }
                }
                
                // Secure sensitive documents
                string sensitiveFile = Path.Combine(sourceDirectory, "employee_data.xlsx");
                if (File.Exists(sensitiveFile))
                {
                    migrationService.SecureDocument(sensitiveFile, "SecurePassword123!");
                }
                
                // Merge quarterly reports into annual summary
                List<string> quarterlyReports = new List<string>
                {
                    Path.Combine(sourceDirectory, "Q1_report.xlsx"),
                    Path.Combine(sourceDirectory, "Q2_report.xlsx"),
                    Path.Combine(sourceDirectory, "Q3_report.xlsx"),
                    Path.Combine(sourceDirectory, "Q4_report.xlsx")
                };
                
                // Only proceed if all files exist
                if (quarterlyReports.TrueForAll(File.Exists))
                {
                    migrationService.MergeDocuments(quarterlyReports, "Annual_Summary");
                }
                
                Console.WriteLine("Migration process completed successfully.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Migration process failed: {ex.Message}");
                File.AppendAllText(logPath, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - CRITICAL ERROR: {ex.Message}{Environment.NewLine}");
            }
            
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

Naudokite atvejus ir paraiškas

Verslo formatų standartizacija

Didžiosios organizacijos dažnai turi migruoti iš įvairių paveldimų “Excel” formatus (.xls, .xlsm, ir tt) į šiuolaikinį XLSX formatą, siekiant pagerinti suderinamumą su dabartinėmis sistemomis ir saugumo funkcijomis. Aspose.Cells LowCode Converters leidžia IT komandoms apdoroti tūkstančius dokumentų per keletą skyrių, išlaikant formules, formatuojant ir makrus, kaip tinkama.

Reglamentavimo laikymasis ir archyvas

Finansų institucijos ir reguliuojamos pramonės šakos turi išlaikyti saugius, nepakeičiamus skirstymo duomenų archyvus. Konvertuojant kritinius Excel dokumentus į slaptažodžiu apsaugotus PDF su Aspose.Cells teikiamas saugus archyvo sprendimas, kuris atitinka atitikties reikalavimus, tuo pačiu užtikrinant dokumentų vientisumą ir užkertant kelią nepriimtiniems pakeitimams.

Sistemos modernizavimas ir integracija

Atnaujinant verslo sistemas, organizacijoms reikia ištraukti duomenis iš paveldimų „Excel“ formatus, kad būtų integruojami su šiuolaikinėmis duomenų bazėmis ir programomis. „Aspose.Cells“ JSON konvertavimo pajėgumai leidžia beprasmišką duomenų ekstrakciją ir transformaciją naudoti žiniatinklio programose, verslo žvalgybos įrankiuose ir kitose moderniose platformose be rankinio duomenų įvedimo.

Bendrieji iššūkiai ir sprendimai

1 iššūkis: sudėtingų formulių ir formatavimo išsaugojimas

Išsprendimas: Aspose.Cells palaiko formulės vientisumą ir sudėtingą formatuojimą formato konvertavimo metu. „SpreadsheetConverter“ išsaugo skaičiavimus, sąlyginį formatavimą ir kitas pažangias „Excel“ funkcijas nereikalaujant rankinio įsikišimo.

2 iššūkis: didelių dokumentų kiekio tvarkymas

Išsprendimas: Įdiegti paketų apdorojimą su klaidų izoliacija, siekiant užtikrinti, kad viename dokumente nepavyksta sustabdyti visos migracijos.

3 iššūkis: failų dydžio ir našumo valdymas

Išsprendimas: Konfigūruokite konvertavimo parinktis, kad optimizuotumėte išleidimo dydį ir našumą. „PDF“ generavimui „OnePagePerSheet“ parinktį galima konfiguruoti remiantis dokumentų reikalavimais, o HTML konversiją galima apriboti konkrečiomis darbalaukėmis, siekiant pagerinti atrankos rezultatus.

Veiksmingumo apžvalgos

  • Duomenų apdorojimas tvarkomis dydžiais, kad būtų išvengta atminties apribojimų
  • Įdiegti kelias grėsmes, skirtas nepriklausomų dokumentų lygiagrečiai apdorojimui
  • Apsvarstykite serverio išteklių paskirstymą didelio masto migracijoms su tūkstančiais failų
  • Naudokite atminties srautus aukštos įtakos scenarijams, kur disko I/O gali tapti buteliuku

Geriausios praktikos

  • Atlikti išsamią prieš migraciją analizę, siekiant nustatyti dokumentų sudėtingumą ir galimas problemas
  • Visapusiško patvirtinimo įgyvendinimas siekiant užtikrinti duomenų vientisumą po migracijos
  • Sukurkite išsamią audito maršrutą su tvirtą registraciją, kad būtų laikomasi reguliavimo
  • Sukurkite aiškią grįžtamojo ryšio strategiją, jei nustatomos migracijos problemos
  • Migracijos procesą išbandykite atstovaujančiu mėginiu prieš pilną įgyvendinimą

Išplėstiniai scenarijai

Siekiant sudėtingesnių reikalavimų, apsvarstykite šiuos pažangius įgyvendinimus:

1 scenarijus: pritaikytas šablonas pagrįstas konvertavimas

Organizacijoms, turinčioms standartinius „Excel“ šablonus, kuriems reikia specializuotos apdorojimo:

public void ProcessTemplatedDocuments(string templateFile, List<string> dataFiles, SaveFormat outputFormat)
{
    // Load the template
    Workbook templateWorkbook = new Workbook(templateFile);
    
    foreach (string dataFile in dataFiles)
    {
        try
        {
            // Load data document
            Workbook dataWorkbook = new Workbook(dataFile);
            
            // Custom processing logic to extract data and apply to template
            // ...
            
            // Save using LowCode converters
            string outputFile = Path.Combine(_outputDirectory, 
                $"{Path.GetFileNameWithoutExtension(dataFile)}_processed.xlsx");
                
            LowCodeSaveOptions lcsopts = new LowCodeSaveOptions();
            lcsopts.SaveFormat = outputFormat;
            lcsopts.OutputFile = outputFile;
            
            // Custom processing complete, save the workbook
            MemoryStream ms = new MemoryStream();
            templateWorkbook.Save(ms, SaveFormat.Xlsx);
            ms.Position = 0;
            
            // Convert to final format if needed
            LowCodeLoadOptions lclopts = new LowCodeLoadOptions();
            lclopts.LoadFromStream = ms;
            
            SpreadsheetConverter.Process(lclopts, lcsopts);
            
            LogConversion($"Processed template with data from {dataFile}");
        }
        catch (Exception ex)
        {
            LogConversion($"Error processing template with {dataFile}: {ex.Message}");
        }
    }
}

2 scenarijus: padidėjusi migracija su pokyčių aptikimu

Dėl nuolatinių migracijos procesų, kuriems reikia aptikti ir apdoroti tik pakeistus failus:

public void PerformIncrementalMigration(string changeLogPath)
{
    Dictionary<string, DateTime> previousMigration = LoadChangeLog(changeLogPath);
    Dictionary<string, DateTime> currentMigration = new Dictionary<string, DateTime>();
    List<string> filesToMigrate = new List<string>();
    
    // Identify changed or new files
    foreach (string file in Directory.GetFiles(_sourceDirectory, "*.xls*", SearchOption.AllDirectories))
    {
        DateTime lastModified = File.GetLastWriteTime(file);
        currentMigration[file] = lastModified;
        
        if (!previousMigration.ContainsKey(file) || previousMigration[file] < lastModified)
        {
            filesToMigrate.Add(file);
        }
    }
    
    // Process only changed files
    foreach (string file in filesToMigrate)
    {
        try
        {
            MigrateToModernFormat(file, SaveFormat.Xlsx);
            ConvertToPdf(file);
            ConvertToJson(file);
        }
        catch (Exception ex)
        {
            LogConversion($"Error during incremental migration of {file}: {ex.Message}");
        }
    }
    
    // Save current state for next incremental migration
    SaveChangeLog(changeLogPath, currentMigration);
    
    LogConversion($"Incremental migration completed. Processed {filesToMigrate.Count} modified files.");
}

private Dictionary<string, DateTime> LoadChangeLog(string changeLogPath)
{
    Dictionary<string, DateTime> result = new Dictionary<string, DateTime>();
    
    if (File.Exists(changeLogPath))
    {
        foreach (string line in File.ReadAllLines(changeLogPath))
        {
            string[] parts = line.Split('|');
            if (parts.Length == 2 && DateTime.TryParse(parts[1], out DateTime timestamp))
            {
                result[parts[0]] = timestamp;
            }
        }
    }
    
    return result;
}

private void SaveChangeLog(string changeLogPath, Dictionary<string, DateTime> changeLog)
{
    List<string> lines = new List<string>();
    
    foreach (var entry in changeLog)
    {
        lines.Add($"{entry.Key}|{entry.Value:yyyy-MM-dd HH:mm:ss}");
    }
    
    File.WriteAllLines(changeLogPath, lines);
}

Conclusion

Įdiegdami „Aspose.Cells LowCode Converters for Excel“ formatų migraciją, IT vadovai ir migracijos specialistai gali efektyviai standartizuoti dokumentų formatus visoje įmonėje ir užtikrinti nesąžiningą suderinamumą su šiuolaikinėmis sistemomis.

Norėdami gauti daugiau informacijos ir papildomų pavyzdžių, žr. Aspose.Cells.LowCode API nuoroda.

More in this category