How to Migrate from Adobe PDF Library SDK to IronPDF

High Licensing Costs

The Adobe PDF Library SDK operates at enterprise pricing levels, typically ranging from $10,000 to $50,000+ annually. This cost structure makes the SDK impractical for small to mid-sized businesses, startups, individual developers, and projects where full Adobe engine capabilities aren't essential.

Complex Native SDK Integration

The Adobe PDF Library SDK is built on native C++ code requiring platform-specific binaries. Developers must carefully manage memory, handle explicit initialization and termination patterns, and work through intricate setup procedures. This adds significant development overhead and complicates CI/CD pipelines.

Low-Level API Design

Creating PDFs with Adobe PDF Library SDK involves constructing pages, content streams, text runs, and fonts programmatically. Simple tasks like rendering HTML content become multi-step operations involving coordinate calculations, font embedding, and manual content element management.

Library Lifecycle Management Overhead

Every operation requires wrapping code in Library.Initialize() and Library.Terminate() blocks with careful COM object disposal. Forgetting cleanup steps leads to resource leaks and application instability.

Overkill for Typical Projects

For applications primarily needing HTML-to-PDF conversion, basic document manipulation, or report generation, the full Adobe PDF engine represents significant over-engineering where simpler solutions deliver equivalent results.

Prerequisites

Ensure your environment meets these requirements before beginning migration:

• .NET Framework 4.6.2+ or .NET Core 3.1 / .NET 5-9
• Visual Studio 2019+ or JetBrains Rider
• NuGet Package Manager access
• IronPDF license key (free trial available at ironpdf.com)

Audit Adobe PDF Library SDK Usage

Run these commands in your solution directory to identify all Adobe PDF Library SDK references:

grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .

grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .

Breaking Changes to Anticipate

Step 1: Update NuGet Packages

Remove the Adobe PDF Library SDK package and install IronPDF:

# Remove Adobe PDF Library
dotnet remove package Adobe.PDF.Library.LM.NET

# Install IronPDF
dotnet add package IronPdf

# Remove Adobe PDF Library
dotnet remove package Adobe.PDF.Library.LM.NET

# Install IronPDF
dotnet add package IronPdf

Step 2: Configure the License Key

Replace Adobe's licensing with IronPDF's code-based license key:

// Replace Adobe's Library.LicenseKey with IronPDF license
// Add at application startup, before any IronPDF operations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;

// Replace Adobe's Library.LicenseKey with IronPDF license
// Add at application startup, before any IronPDF operations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;

Step 3: Update Namespace References

Perform a global find-and-replace across your solution:

Step 4: Remove Library Lifecycle Code

One of the most significant simplifications involves removing initialization and termination patterns:

// Adobe PDF Library SDK - REMOVE THIS PATTERN
Library.Initialize();
try
{
    // PDF operations
}
finally
{
    Library.Terminate(); // Must always terminate
}

// IronPDF - Just use directly
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

// Adobe PDF Library SDK - REMOVE THIS PATTERN
Library.Initialize();
try
{
    // PDF operations
}
finally
{
    Library.Terminate(); // Must always terminate
}

// IronPDF - Just use directly
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

Library Lifecycle Methods

Document Creation Methods

Content Creation (Major Paradigm Shift)

Adobe PDF Library SDK requires low-level content construction. IronPDF uses HTML/CSS:

Watermark and Security Methods

Text Extraction

HTML to PDF Conversion

The most dramatic simplification occurs when converting content to PDF. Adobe PDF Library SDK requires manual page construction, font embedding, and coordinate positioning.

Adobe PDF Library SDK Implementation:

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeHtmlToPdf
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            // Adobe PDF Library requires complex setup with HTML conversion parameters
            HTMLConversionParameters htmlParams = new HTMLConversionParameters();
            htmlParams.PaperSize = PaperSize.Letter;
            htmlParams.Orientation = Orientation.Portrait;

            string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

            // Convert HTML to PDF
            Document doc = Document.CreateFromHTML(htmlContent, htmlParams);
            doc.Save(SaveFlags.Full, "output.pdf");
            doc.Dispose();
        }
    }
}

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeHtmlToPdf
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            // Adobe PDF Library requires complex setup with HTML conversion parameters
            HTMLConversionParameters htmlParams = new HTMLConversionParameters();
            htmlParams.PaperSize = PaperSize.Letter;
            htmlParams.Orientation = Orientation.Portrait;

            string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

            // Convert HTML to PDF
            Document doc = Document.CreateFromHTML(htmlContent, htmlParams);
            doc.Save(SaveFlags.Full, "output.pdf");
            doc.Dispose();
        }
    }
}

IronPDF Implementation:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class IronPdfHtmlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        // Convert HTML to PDF with simple API
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class IronPdfHtmlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        // Convert HTML to PDF with simple API
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}

IronPDF eliminates the library lifecycle wrapper, conversion parameter objects, and explicit disposal. The ChromePdfRenderer uses a Chromium-based engine for pixel-perfect CSS and JavaScript support. For advanced scenarios, see the HTML to PDF documentation.

Merging Multiple PDFs

PDF merging demonstrates the API complexity difference clearly.

Adobe PDF Library SDK Implementation:

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeMergePdfs
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            // Open first PDF document
            Document doc1 = new Document("document1.pdf");
            Document doc2 = new Document("document2.pdf");

            // Insert pages from second document into first
            PageInsertParams insertParams = new PageInsertParams();
            insertParams.InsertFlags = PageInsertFlags.None;

            for (int i = 0; i < doc2.NumPages; i++)
            {
                Page page = doc2.GetPage(i);
                doc1.InsertPage(doc1.NumPages - 1, page, insertParams);
            }

            doc1.Save(SaveFlags.Full, "merged.pdf");
            doc1.Dispose();
            doc2.Dispose();
        }
    }
}

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeMergePdfs
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            // Open first PDF document
            Document doc1 = new Document("document1.pdf");
            Document doc2 = new Document("document2.pdf");

            // Insert pages from second document into first
            PageInsertParams insertParams = new PageInsertParams();
            insertParams.InsertFlags = PageInsertFlags.None;

            for (int i = 0; i < doc2.NumPages; i++)
            {
                Page page = doc2.GetPage(i);
                doc1.InsertPage(doc1.NumPages - 1, page, insertParams);
            }

            doc1.Save(SaveFlags.Full, "merged.pdf");
            doc1.Dispose();
            doc2.Dispose();
        }
    }
}

IronPDF Implementation:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class IronPdfMergePdfs
{
    static void Main()
    {
        // Load PDF documents
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs with simple method
        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class IronPdfMergePdfs
{
    static void Main()
    {
        // Load PDF documents
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs with simple method
        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}

Adobe's approach requires page-by-page iteration with insertion parameters. IronPDF provides a single Merge method that accepts multiple documents.

Adding Watermarks

Watermarking illustrates how IronPDF leverages HTML/CSS for styling flexibility.

Adobe PDF Library SDK Implementation:

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeAddWatermark
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            Document doc = new Document("input.pdf");

            // Create watermark with complex API
            WatermarkParams watermarkParams = new WatermarkParams();
            watermarkParams.Opacity = 0.5;
            watermarkParams.Rotation = 45.0;
            watermarkParams.VerticalAlignment = WatermarkVerticalAlignment.Center;
            watermarkParams.HorizontalAlignment = WatermarkHorizontalAlignment.Center;

            WatermarkTextParams textParams = new WatermarkTextParams();
            textParams.Text = "CONFIDENTIAL";

            Watermark watermark = new Watermark(doc, textParams, watermarkParams);

            doc.Save(SaveFlags.Full, "watermarked.pdf");
            doc.Dispose();
        }
    }
}

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeAddWatermark
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            Document doc = new Document("input.pdf");

            // Create watermark with complex API
            WatermarkParams watermarkParams = new WatermarkParams();
            watermarkParams.Opacity = 0.5;
            watermarkParams.Rotation = 45.0;
            watermarkParams.VerticalAlignment = WatermarkVerticalAlignment.Center;
            watermarkParams.HorizontalAlignment = WatermarkHorizontalAlignment.Center;

            WatermarkTextParams textParams = new WatermarkTextParams();
            textParams.Text = "CONFIDENTIAL";

            Watermark watermark = new Watermark(doc, textParams, watermarkParams);

            doc.Save(SaveFlags.Full, "watermarked.pdf");
            doc.Dispose();
        }
    }
}

IronPDF Implementation:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;

class IronPdfAddWatermark
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("input.pdf");

        // Apply text watermark with simple API
        pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
            rotation: 45,
            verticalAlignment: VerticalAlignment.Middle,
            horizontalAlignment: HorizontalAlignment.Center);

        pdf.SaveAs("watermarked.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;

class IronPdfAddWatermark
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("input.pdf");

        // Apply text watermark with simple API
        pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
            rotation: 45,
            verticalAlignment: VerticalAlignment.Middle,
            horizontalAlignment: HorizontalAlignment.Center);

        pdf.SaveAs("watermarked.pdf");
    }
}

IronPDF's HTML-based watermarking provides complete design control through CSS styling, eliminating the need for separate parameter objects.

Password Protection and Encryption

Adobe PDF Library SDK Implementation:

using Datalogics.PDFL;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Library.Initialize();
    try
    {
        using (Document doc = new Document(inputPath))
        {
            PermissionFlags permissions =
                PermissionFlags.PrintDoc |
                PermissionFlags.PrintFidelity;

            EncryptionHandler encHandler = new EncryptionHandler(
                password,      // User password
                password,      // Owner password
                permissions,
                EncryptionMethod.AES256);

            doc.SetEncryptionHandler(encHandler);
            doc.Save(SaveFlags.Full | SaveFlags.Encrypted, outputPath);
        }
    }
    finally
    {
        Library.Terminate();
    }
}

using Datalogics.PDFL;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Library.Initialize();
    try
    {
        using (Document doc = new Document(inputPath))
        {
            PermissionFlags permissions =
                PermissionFlags.PrintDoc |
                PermissionFlags.PrintFidelity;

            EncryptionHandler encHandler = new EncryptionHandler(
                password,      // User password
                password,      // Owner password
                permissions,
                EncryptionMethod.AES256);

            doc.SetEncryptionHandler(encHandler);
            doc.Save(SaveFlags.Full | SaveFlags.Encrypted, outputPath);
        }
    }
    finally
    {
        Library.Terminate();
    }
}

IronPDF Implementation:

using IronPdf;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.SecuritySettings.UserPassword = password;
    pdf.SecuritySettings.OwnerPassword = password;
    pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
    pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

    pdf.SaveAs(outputPath);
}

using IronPdf;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.SecuritySettings.UserPassword = password;
    pdf.SecuritySettings.OwnerPassword = password;
    pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
    pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

    pdf.SaveAs(outputPath);
}

IronPDF uses strongly-typed properties instead of bitwise permission flags and encryption handler objects.

Text Extraction

Adobe PDF Library SDK Implementation:

using Datalogics.PDFL;

public string ExtractText(string pdfPath)
{
    string extractedText = "";

    Library.Initialize();
    try
    {
        using (Document doc = new Document(pdfPath))
        {
            WordFinderConfig config = new WordFinderConfig();
            config.IgnoreCharGaps = true;

            for (int i = 0; i < doc.NumPages; i++)
            {
                using (WordFinder wordFinder = new WordFinder(doc, i, config))
                {
                    IList<Word> words = wordFinder.GetWordList();
                    foreach (Word word in words)
                    {
                        extractedText += word.Text + " ";
                    }
                    extractedText += "\n";
                }
            }
        }
    }
    finally
    {
        Library.Terminate();
    }

    return extractedText;
}

using Datalogics.PDFL;

public string ExtractText(string pdfPath)
{
    string extractedText = "";

    Library.Initialize();
    try
    {
        using (Document doc = new Document(pdfPath))
        {
            WordFinderConfig config = new WordFinderConfig();
            config.IgnoreCharGaps = true;

            for (int i = 0; i < doc.NumPages; i++)
            {
                using (WordFinder wordFinder = new WordFinder(doc, i, config))
                {
                    IList<Word> words = wordFinder.GetWordList();
                    foreach (Word word in words)
                    {
                        extractedText += word.Text + " ";
                    }
                    extractedText += "\n";
                }
            }
        }
    }
    finally
    {
        Library.Terminate();
    }

    return extractedText;
}

IronPDF Implementation:

using IronPdf;

public string ExtractText(string pdfPath)
{
    using var pdf = PdfDocument.FromFile(pdfPath);
    return pdf.ExtractAllText();
}

using IronPdf;

public string ExtractText(string pdfPath)
{
    using var pdf = PdfDocument.FromFile(pdfPath);
    return pdf.ExtractAllText();
}

Adobe's word-by-word iteration becomes a single method call with IronPDF.

Headers and Footers

Adobe PDF Library SDK Implementation:

using Datalogics.PDFL;

public void AddHeaderFooter(string inputPath, string outputPath)
{
    Library.Initialize();
    try
    {
        using (Document doc = new Document(inputPath))
        {
            Font font = new Font("Helvetica", FontCreateFlags.None);

            for (int i = 0; i < doc.NumPages; i++)
            {
                using (Page page = doc.GetPage(i))
                {
                    Content content = page.Content;

                    // Add header
                    Text header = new Text();
                    header.AddRun(new TextRun("Document Header",
                        font, 10, new Point(72, page.MediaBox.Top - 36)));
                    content.AddElement(header);

                    // Add footer with page number
                    Text footer = new Text();
                    footer.AddRun(new TextRun($"Page {i + 1} of {doc.NumPages}",
                        font, 10, new Point(72, 36)));
                    content.AddElement(footer);

                    page.UpdateContent();
                }
            }
            doc.Save(SaveFlags.Full, outputPath);
        }
    }
    finally
    {
        Library.Terminate();
    }
}

using Datalogics.PDFL;

public void AddHeaderFooter(string inputPath, string outputPath)
{
    Library.Initialize();
    try
    {
        using (Document doc = new Document(inputPath))
        {
            Font font = new Font("Helvetica", FontCreateFlags.None);

            for (int i = 0; i < doc.NumPages; i++)
            {
                using (Page page = doc.GetPage(i))
                {
                    Content content = page.Content;

                    // Add header
                    Text header = new Text();
                    header.AddRun(new TextRun("Document Header",
                        font, 10, new Point(72, page.MediaBox.Top - 36)));
                    content.AddElement(header);

                    // Add footer with page number
                    Text footer = new Text();
                    footer.AddRun(new TextRun($"Page {i + 1} of {doc.NumPages}",
                        font, 10, new Point(72, 36)));
                    content.AddElement(footer);

                    page.UpdateContent();
                }
            }
            doc.Save(SaveFlags.Full, outputPath);
        }
    }
    finally
    {
        Library.Terminate();
    }
}

IronPDF Implementation:

using IronPdf;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Document Header",
        FontSize = 10,
        FontFamily = "Helvetica"
    };

    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10,
        FontFamily = "Helvetica"
    };

    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(outputPath);
}

using IronPdf;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Document Header",
        FontSize = 10,
        FontFamily = "Helvetica"
    };

    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10,
        FontFamily = "Helvetica"
    };

    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(outputPath);
}

IronPDF handles page iteration automatically and supports placeholder tokens like {page} and {total-pages}. For more advanced layouts, see the headers and footers documentation.

URL to PDF Conversion

Adobe PDF Library SDK lacks built-in URL rendering capability. IronPDF provides native support:

using IronPdf;

public void ConvertUrlToPdf(string url, string outputPath)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderUrlAsPdf(url);
    pdf.SaveAs(outputPath);
}

using IronPdf;

public void ConvertUrlToPdf(string url, string outputPath)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderUrlAsPdf(url);
    pdf.SaveAs(outputPath);
}

For complete URL conversion options, see the URL to PDF documentation.

Async Support

Adobe PDF Library SDK doesn't support async operations. IronPDF provides full async/await capabilities essential for scalable web applications:

public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}

public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}

Memory Usage Comparison

Optimization Tips

Reuse Renderer Instances:

// Good: Reuse renderer for batch operations
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

// Good: Reuse renderer for batch operations
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

Use Async in Web Applications:

public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}

public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}

Issue: Coordinate-Based Positioning Not Working

Adobe uses PostScript point coordinates. IronPDF uses CSS positioning:

// Adobe: Point-based
new TextRun("Hello", font, 12, new Point(100, 700));

// IronPDF: CSS-based
string html = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>";

// Adobe: Point-based
new TextRun("Hello", font, 12, new Point(100, 700));

// IronPDF: CSS-based
string html = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>";

Issue: Page Size Differences

Adobe uses PostScript points. IronPDF uses enums or custom dimensions:

// Adobe: Points
Rect(0, 0, 612, 792) // Letter

// IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);

// Adobe: Points
Rect(0, 0, 612, 792) // Letter

// IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);

Issue: Font Not Found

Adobe requires manual font embedding. IronPDF handles fonts automatically:

// IronPDF: Use web fonts if needed
string html = @"
<style>
    @import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
    body { font-family: 'Roboto', sans-serif; }
</style>";

// IronPDF: Use web fonts if needed
string html = @"
<style>
    @import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
    body { font-family: 'Roboto', sans-serif; }
</style>";

Issue: SaveFlags Not Available

Adobe uses save flag combinations. IronPDF uses direct save:

// Adobe
doc.Save(SaveFlags.Full | SaveFlags.Incremental, path);

// IronPDF - full save is default
pdf.SaveAs(path);

// Adobe
doc.Save(SaveFlags.Full | SaveFlags.Incremental, path);

// IronPDF - full save is default
pdf.SaveAs(path);