Comme les organisations sont de plus en plus basées sur Excel pour stocker et partager des données sensibles, assurer que ces informations restent protégées est la première chose. The Aspose.Cells LowCode Spreadsheet Locker fournit une façon simple d’implémenter des mesures de sécurité robustes avec un effort de codage minimum.

Cet article explore comment utiliser la bibliothèque Aspose.Cells pour sécuriser les documents Excel, couvrant tout, de la protection de niveau de fichier de base à des stratégies multi-échelles plus avancées et des techniques de traitement de pièces.

Caractéristiques clés d’Aspose.Cells LowCode Spreadsheet Locker

  • Protection du niveau des fichiers: Encryptez tout le fichier pour restreindre l’accès basé sur les mots de passe.
  • Protection de niveau de feuille de travail: Contrôler les autorisations d’utilisateur au niveau des feuilles de travaux pour la sécurité granulaire.
  • Protection structurelle: Prévenir les changements non autorisés dans les structures et les layouts du livre de travail.
  • Batch Processing: Protection automatique sur plusieurs documents Excel efficacement.

Niveau de protection des fichiers

Développer votre environnement

Avant de plonger dans le code, assurez-vous que vous avez Aspose.Cells installé dans votre projet. Vous pouvez l’ajouter via NuGet Package Manager ou en téléchargant la bibliothèque directement du site officiel.

Code d’exemple pour la protection du niveau de fichier de base

public void ProtectExcelFile(string inputFile, string outputFile, string password)
{
    // Configure loading options
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions { InputFile = inputFile };
    
    // Configure saving options
    LowCodeSaveOptions saveOptions = new LowCodeSaveOptions {
        OutputFile = outputFile,
        SaveFormat = SaveFormat.Xlsx
    };
    
    // Apply file-level protection
    SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
}

Titre : Test et validation

Après la mise en œuvre de la protection de niveau de fichier de base, il est crucial de valider que les fichiers protégés ne peuvent pas être accessibles sans le mot de passe correct.

Fonction de test d’exemple

public void ValidateFileProtection(string filePath)
{
    try
    {
        // Attempt to open the file with an incorrect password
        new Workbook(filePath, new LoadOptions { Password = "wrongpassword" });
        Console.WriteLine("Warning: File opened with incorrect password!");
    }
    catch (CellsException ex)
    {
        if (ex.Code == ExceptionType.IncorrectPassword)
            Console.WriteLine("Success: Incorrect password rejected.");
        else
            throw;
    }
}

Des stratégies de protection avancées

Stratégie de protection multi-classe

La mise en œuvre d’une stratégie de protection multi-échelles implique la combinaison de cryptage à niveau de fichiers avec des feuilles de travail et des protections structurelles pour fournir une sécurité complète.

Code d’exemple pour la protection multi-laires

public void ApplyMultiLayerProtection(string inputFile, string outputFile, string filePassword)
{
    // Configure loading options
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions { InputFile = inputFile };
    
    using (Workbook workbook = new Workbook(inputFile))
    {
        // Protect workbook structure
        workbook.Settings.WriteProtection.SetPassword("StructurePassword");
        
        // Protect worksheets
        foreach (Worksheet worksheet in workbook.Worksheets)
            worksheet.Protect(ProtectionType.All, "SheetPassword", true);
        
        // Save the intermediate workbook
        workbook.Save("intermediate.xlsx");
    }
    
    LowCodeSaveOptions saveOptions = new LowCodeSaveOptions {
        InputFile = "intermediate.xlsx",
        OutputFile = outputFile,
        SaveFormat = SaveFormat.Xlsx
    };
    
    // Apply file-level encryption
    SpreadsheetLocker.Process(loadOptions, saveOptions, filePassword, null);
    
    if (File.Exists("intermediate.xlsx"))
        File.Delete("intermediate.xlsx");
}

Traitement de batch avec rapport de progrès

Pour les scénarios qui impliquent un grand nombre de fichiers Excel, le traitement des pièces peut simplifier considérablement le processus de protection.

Code d’exemple pour la protection du batch

public void BatchProtectExcelFiles(string[] inputFiles, string outputDirectory, string password)
{
    if (!Directory.Exists(outputDirectory))
        Directory.CreateDirectory(outputDirectory);
    
    int totalFiles = inputFiles.Length;
    int processedFiles = 0;
    int successCount = 0;
    int failCount = 0;
    
    foreach (string inputFile in inputFiles)
    {
        try
        {
            string fileName = Path.GetFileName(inputFile);
            string outputPath = Path.Combine(outputDirectory, $"Protected_{fileName}");
            
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions { InputFile = inputFile };
            LowCodeSaveOptions saveOptions = new LowCodeSaveOptions {
                OutputFile = outputPath,
                SaveFormat = SaveFormat.Xlsx
            };
            
            SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
            successCount++;
            Console.WriteLine($"Protected {fileName} successfully");
        }
        catch (Exception ex)
        {
            failCount++;
            Console.WriteLine($"Failed to protect {Path.GetFileName(inputFile)}: {ex.Message}");
        }
        
        processedFiles++;
        double progressPercentage = (double)processedFiles / totalFiles * 100;
        Console.WriteLine($"Progress: {progressPercentage:F1}% ({processedFiles}/{totalFiles})
    }
    
    Console.WriteLine($"Batch protection complete. Success: {successCount}, Failed: {failCount}");
}

Conclusion

En utilisant Aspose.Cells LowCode Spreadsheet Locker, les organisations peuvent mettre en œuvre des mesures de sécurité robustes pour les documents Excel avec un effort minimal de codage. Cette approche non seulement simplifie la mise en oeuvre de la sécurité des documents mais offre également la flexibilité d’adapter les stratégies de protection basées sur des exigences spécifiques.

Pour plus d’informations et de exemples supplémentaires, consultez le Aspose.Cells.LowCode API de référence.

More in this category