如何在 .NET 中安全化 Excel 文档工作流

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

// Define the path to the Excel file that needs protection
string sourcePath = "path/to/sensitive-document.xlsx";

// Ensure the file exists before proceeding
if (!File.Exists(sourcePath))
{
    throw new FileNotFoundException("The source Excel file was not found.", sourcePath);
}

// Create load options for the source file
LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
{
    InputFile = sourcePath
};

// Create save options for the protected output file
LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
{
    SaveFormat = SaveFormat.Xlsx,
    OutputFile = "path/to/protected-document.xlsx"
};

// Alternatively, use a memory stream for enhanced security
// MemoryStream outputStream = new MemoryStream();
// saveOptions.OutputStream = outputStream;

// Define a strong password for document protection
string securePassword = "YourStrongPassword123!";

// Execute the process to lock the spreadsheet with the password
SpreadsheetLocker.Process(loadOptions, saveOptions, securePassword, null);

Console.WriteLine("Document successfully protected with password.");

// If you used MemoryStream, you might want to save it to a file
// or pass it to another component in your workflow

if (saveOptions.OutputStream is MemoryStream ms)
{
    // Reset stream position to beginning
    ms.Seek(0, SeekOrigin.Begin);
    
    // Save to file if needed
    using (FileStream fileStream = File.Create("path/to/secured-output.xlsx"))
    {
        ms.CopyTo(fileStream);
    }
    
    // Or verify the password protection was applied
    try
    {
        // This should fail if password protection is working
        new Workbook(ms);
        Console.WriteLine("WARNING: Password protection failed!");
    }
    catch (CellsException ex)
    {
        if (ex.Code == ExceptionType.IncorrectPassword)
        {
            Console.WriteLine("Password protection verified successfully.");
        }
        else
        {
            throw;
        }
    }
}

try
{
    // Load options setup
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions
    {
        InputFile = sourcePath
    };
    
    // Save options setup
    LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
    {
        SaveFormat = SaveFormat.Xlsx,
        OutputFile = "path/to/protected-document.xlsx"
    };
    
    // Execute protection process
    SpreadsheetLocker.Process(loadOptions, saveOptions, securePassword, null);
    Console.WriteLine("Document successfully protected.");
}
catch (IOException ex)
{
    Console.WriteLine($"File operation error: {ex.Message}");
    // Log the error details for administrative review
}
catch (CellsException ex)
{
    Console.WriteLine($"Aspose.Cells error: {ex.Message} (Code: {ex.Code})");
    // Handle specific Cells exceptions based on error codes
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
    // Consider more detailed logging for production environments
}

// Example of batch processing with SpreadsheetLocker
public void BatchProtectDocuments(List<string> filePaths, string password)
{
    foreach (string filePath in filePaths)
    {
        try
        {
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions { InputFile = filePath };
            
            // Create output path with "_protected" suffix
            string outputPath = Path.Combine(
                Path.GetDirectoryName(filePath),
                Path.GetFileNameWithoutExtension(filePath) + "_protected" + Path.GetExtension(filePath)
            );
            
            LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
            {
                SaveFormat = SaveFormat.Xlsx,
                OutputFile = outputPath
            };
            
            SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
            Console.WriteLine($"Protected: {filePath} -> {outputPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to protect {filePath}: {ex.Message}");
            // Continue with next file instead of stopping the batch
        }
    }
}

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

namespace SecureDocumentWorkflow
{
    public class SpreadsheetProtectionService
    {
        public void ProtectDocument(string inputPath, string outputPath, string password)
        {
            try
            {
                // Validate inputs
                if (string.IsNullOrEmpty(inputPath))
                    throw new ArgumentNullException(nameof(inputPath));
                
                if (string.IsNullOrEmpty(outputPath))
                    throw new ArgumentNullException(nameof(outputPath));
                
                if (string.IsNullOrEmpty(password))
                    throw new ArgumentException("Password cannot be empty", nameof(password));
                
                if (!File.Exists(inputPath))
                    throw new FileNotFoundException("Source file not found", inputPath);
                
                // Ensure output directory exists
                string outputDir = Path.GetDirectoryName(outputPath);
                if (!string.IsNullOrEmpty(outputDir) && !Directory.Exists(outputDir))
                {
                    Directory.CreateDirectory(outputDir);
                }
                
                // Configure options
                LowCodeLoadOptions loadOptions = new LowCodeLoadOptions { InputFile = inputPath };
                LowCodeSaveOptions saveOptions = new LowCodeSaveOptions
                {
                    SaveFormat = SaveFormat.Xlsx,
                    OutputFile = outputPath
                };
                
                // Execute protection
                SpreadsheetLocker.Process(loadOptions, saveOptions, password, null);
                
                // Verify protection
                VerifyPasswordProtection(outputPath, password);
                
                Console.WriteLine("Document successfully protected and verified.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error protecting document: {ex.Message}");
                throw;
            }
        }
        
        private void VerifyPasswordProtection(string filePath, string expectedPassword)
        {
            try
            {
                // Try to open without password (should fail)
                try
                {
                    new Workbook(filePath);
                    throw new Exception("Password protection verification failed: File opened without password");
                }
                catch (CellsException ex)
                {
                    if (ex.Code != ExceptionType.IncorrectPassword)
                    {
                        throw new Exception($"Unexpected error during verification: {ex.Message}");
                    }
                    // This is expected - file requires password
                }
                
                // Try to open with correct password (should succeed)
                try
                {
                    LoadOptions loadOptions = new LoadOptions { Password = expectedPassword };
                    new Workbook(filePath, loadOptions);
                    // Success - file opens with the provided password
                }
                catch (Exception ex)
                {
                    throw new Exception($"Password verification failed: {ex.Message}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Verification error: {ex.Message}");
                throw;
            }
        }
    }
    
    class Program
    {
        static void Main()
        {
            SpreadsheetProtectionService service = new SpreadsheetProtectionService();
            service.ProtectDocument(
                "source/financial-report.xlsx",
                "protected/financial-report-secured.xlsx",
                "SecureP@ssw0rd!"
            );
        }
    }
}