How to Convert PPT to PPTX with Layout Preservation in C#

// Load the legacy PPT file
using (Presentation presentation = new Presentation("legacy-presentation.ppt"))
{
    // Presentation is now loaded and ready for conversion
    Console.WriteLine($"Loaded presentation with {presentation.Slides.Count} slides");
}

using (Presentation presentation = new Presentation("legacy-presentation.ppt"))
{
    // Convert and save as PPTX
    presentation.Save("modernized-presentation.pptx", SaveFormat.Pptx);
    Console.WriteLine("Conversion completed successfully");
}

using Aspose.Slides;
using System;
using System.IO;

public class PptBatchConverter
{
    public static void ConvertPptToPptxBatch(string sourceDirectory, string targetDirectory)
    {
        // Create target directory if it doesn't exist
        if (!Directory.Exists(targetDirectory))
        {
            Directory.CreateDirectory(targetDirectory);
        }

        // Get all PPT files from source directory
        string[] pptFiles = Directory.GetFiles(sourceDirectory, "*.ppt", SearchOption.AllDirectories);
        
        Console.WriteLine($"Found {pptFiles.Length} PPT files to convert");
        
        int successCount = 0;
        int failureCount = 0;

        foreach (string pptFile in pptFiles)
        {
            try
            {
                string fileName = Path.GetFileNameWithoutExtension(pptFile);
                string outputPath = Path.Combine(targetDirectory, fileName + ".pptx");

                // Load and convert the PPT file
                using (Presentation presentation = new Presentation(pptFile))
                {
                    // Verify presentation has slides
                    if (presentation.Slides.Count == 0)
                    {
                        Console.WriteLine($"Warning: {fileName} has no slides, skipping...");
                        continue;
                    }

                    // Save as PPTX
                    presentation.Save(outputPath, SaveFormat.Pptx);
                    
                    successCount++;
                    Console.WriteLine($"✓ Converted: {fileName} ({presentation.Slides.Count} slides)");
                }
            }
            catch (Exception ex)
            {
                failureCount++;
                Console.WriteLine($"✗ Failed: {Path.GetFileName(pptFile)} - {ex.Message}");
            }
        }

        Console.WriteLine($"\nConversion Summary:");
        Console.WriteLine($"Successfully converted: {successCount} files");
        Console.WriteLine($"Failed conversions: {failureCount} files");
    }
}

using Aspose.Slides;
using System.IO;

public static void ConvertPptToP ptxFromStream(Stream inputStream, Stream outputStream)
{
    try
    {
        // Load PPT from input stream
        using (Presentation presentation = new Presentation(inputStream))
        {
            // Verify presentation integrity
            Console.WriteLine($"Loaded presentation with {presentation.Slides.Count} slides");
            Console.WriteLine($"Presentation size: {presentation.Slides[0].SlideSize.Size.Width}x{presentation.Slides[0].SlideSize.Size.Height}");

            // Save as PPTX to output stream
            presentation.Save(outputStream, SaveFormat.Pptx);
            
            Console.WriteLine("Stream-based conversion completed");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Conversion error: {ex.Message}");
        throw;
    }
}

// Example usage with Azure Blob Storage or AWS S3
public static void ConvertFromCloudStorage()
{
    using (MemoryStream inputStream = new MemoryStream())
    using (MemoryStream outputStream = new MemoryStream())
    {
        // Download PPT file to input stream (e.g., from Azure Blob Storage)
        // ... your cloud storage download code here ...

        // Perform conversion
        ConvertPptToPptxFromStream(inputStream, outputStream);

        // Upload PPTX from output stream back to cloud storage
        // ... your cloud storage upload code here ...
    }
}

using Aspose.Slides;

public static void ValidateConversion(string originalPpt, string convertedPptx)
{
    using (Presentation original = new Presentation(originalPpt))
    using (Presentation converted = new Presentation(convertedPptx))
    {
        Console.WriteLine("=== Conversion Validation ===");
        
        // Verify slide count
        if (original.Slides.Count == converted.Slides.Count)
        {
            Console.WriteLine($"✓ Slide count matches: {original.Slides.Count} slides");
        }
        else
        {
            Console.WriteLine($"✗ Slide count mismatch: Original={original.Slides.Count}, Converted={converted.Slides.Count}");
        }

        // Verify slide dimensions
        var origSize = original.Slides[0].SlideSize.Size;
        var convSize = converted.Slides[0].SlideSize.Size;
        
        if (origSize.Width == convSize.Width && origSize.Height == convSize.Height)
        {
            Console.WriteLine($"✓ Slide dimensions preserved: {origSize.Width}x{origSize.Height}");
        }
        else
        {
            Console.WriteLine($"✗ Slide dimensions changed");
        }

        // Check for animations on each slide
        int originalAnimationCount = 0;
        int convertedAnimationCount = 0;

        for (int i = 0; i < original.Slides.Count; i++)
        {
            originalAnimationCount += original.Slides[i].Timeline.MainSequence.Count;
            convertedAnimationCount += converted.Slides[i].Timeline.MainSequence.Count;
        }

        if (originalAnimationCount == convertedAnimationCount)
        {
            Console.WriteLine($"✓ Animations preserved: {originalAnimationCount} animation effects");
        }
        else
        {
            Console.WriteLine($"⚠ Animation count changed: Original={originalAnimationCount}, Converted={convertedAnimationCount}");
        }

        Console.WriteLine("=== Validation Complete ===");
    }
}