2022年的PDF查看器工具

using IronPdf;

// Production-ready HTML to PDF conversion with error handling
public class PdfGenerator
{
    private readonly ChromePdfRenderer _renderer;

    public PdfGenerator()
    {
        _renderer = new ChromePdfRenderer();

        // Configure for production use
        _renderer.RenderingOptions.MarginTop = 25;
        _renderer.RenderingOptions.MarginBottom = 25;
        _renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;

        // Performance optimization
        _renderer.RenderingOptions.RenderDelay = 500; // Wait for JavaScript
        _renderer.RenderingOptions.Timeout = 60000; // 60-second timeout
    }

    public byte[] GeneratePdfFromHtml(string html, string baseUrl = null)
    {
        try
        {
            // Set base URL for relative asset resolution
            if (!string.IsNullOrEmpty(baseUrl))
            {
                _renderer.RenderingOptions.BaseUrl = new Uri(baseUrl);
            }

            // Generate PDF with proper encoding
            var pdf = _renderer.RenderHtmlAsPdf(html);

            // Apply compression for smaller file size
            pdf.CompressImages(90);

            return pdf.BinaryData;
        }
        catch (Exception ex)
        {
            // Log error details for debugging
            Console.WriteLine($"PDF generation failed: {ex.Message}");
            throw;
        }
    }
}

Imports IronPdf

' Production-ready HTML to PDF conversion with error handling
Public Class PdfGenerator
    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()

        ' Configure for production use
        _renderer.RenderingOptions.MarginTop = 25
        _renderer.RenderingOptions.MarginBottom = 25
        _renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
        _renderer.RenderingOptions.PrintHtmlBackgrounds = True

        ' Performance optimization
        _renderer.RenderingOptions.RenderDelay = 500 ' Wait for JavaScript
        _renderer.RenderingOptions.Timeout = 60000 ' 60-second timeout
    End Sub

    Public Function GeneratePdfFromHtml(html As String, Optional baseUrl As String = Nothing) As Byte()
        Try
            ' Set base URL for relative asset resolution
            If Not String.IsNullOrEmpty(baseUrl) Then
                _renderer.RenderingOptions.BaseUrl = New Uri(baseUrl)
            End If

            ' Generate PDF with proper encoding
            Dim pdf = _renderer.RenderHtmlAsPdf(html)

            ' Apply compression for smaller file size
            pdf.CompressImages(90)

            Return pdf.BinaryData
        Catch ex As Exception
            ' Log error details for debugging
            Console.WriteLine($"PDF generation failed: {ex.Message}")
            Throw
        End Try
    End Function
End Class

using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.Layout.Properties;
using iText.Kernel.Font;
using iText.IO.Font;

public class ITextPdfGenerator
{
    public void CreatePdfWithHeaderFooter(string outputPath)
    {
        // Initialize writer and document
        PdfWriter writer = new PdfWriter(outputPath);
        PdfDocument pdfDoc = new PdfDocument(writer);
        Document document = new Document(pdfDoc);

        // Configure page size and margins
        pdfDoc.SetDefaultPageSize(PageSize.A4);
        document.SetMargins(72, 72, 72, 72);

        // Create font for consistency
        PdfFont font = PdfFontFactory.CreateFont(FontConstants.HELVETICA);

        // Add event handler for headers/footers (requires understanding event system)
        pdfDoc.AddEventHandler(PdfDocumentEvent.END_PAGE, new HeaderFooterEventHandler());

        // Add content
        Paragraph title = new Paragraph("Document Title")
            .SetFont(font)
            .SetFontSize(18)
            .SetTextAlignment(TextAlignment.CENTER);
        document.Add(title);

        // Multiple steps required for basic formatting
        for (int i = 0; i < 5; i++)
        {
            Paragraph para = new Paragraph($"Section {i + 1} content goes here.")
                .SetFont(font)
                .SetFontSize(12)
                .SetTextAlignment(TextAlignment.JUSTIFIED);
            document.Add(para);
        }

        document.Close();
    }

    // Separate class required for header/footer handling
    private class HeaderFooterEventHandler : IEventHandler
    {
        public void HandleEvent(Event @event)
        {
            PdfDocumentEvent docEvent = (PdfDocumentEvent)@event;
            PdfDocument pdfDoc = docEvent.GetDocument();
            PdfPage page = docEvent.GetPage();

            // Complex implementation for simple headers/footers
            // ... additional code required
        }
    }
}

Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports iText.Layout.Properties
Imports iText.Kernel.Font
Imports iText.IO.Font

Public Class ITextPdfGenerator
    Public Sub CreatePdfWithHeaderFooter(outputPath As String)
        ' Initialize writer and document
        Dim writer As New PdfWriter(outputPath)
        Dim pdfDoc As New PdfDocument(writer)
        Dim document As New Document(pdfDoc)

        ' Configure page size and margins
        pdfDoc.SetDefaultPageSize(PageSize.A4)
        document.SetMargins(72, 72, 72, 72)

        ' Create font for consistency
        Dim font As PdfFont = PdfFontFactory.CreateFont(FontConstants.HELVETICA)

        ' Add event handler for headers/footers (requires understanding event system)
        pdfDoc.AddEventHandler(PdfDocumentEvent.END_PAGE, New HeaderFooterEventHandler())

        ' Add content
        Dim title As New Paragraph("Document Title") _
            .SetFont(font) _
            .SetFontSize(18) _
            .SetTextAlignment(TextAlignment.CENTER)
        document.Add(title)

        ' Multiple steps required for basic formatting
        For i As Integer = 0 To 4
            Dim para As New Paragraph($"Section {i + 1} content goes here.") _
                .SetFont(font) _
                .SetFontSize(12) _
                .SetTextAlignment(TextAlignment.JUSTIFIED)
            document.Add(para)
        Next

        document.Close()
    End Sub

    ' Separate class required for header/footer handling
    Private Class HeaderFooterEventHandler
        Implements IEventHandler

        Public Sub HandleEvent([event] As [Event]) Implements IEventHandler.HandleEvent
            Dim docEvent As PdfDocumentEvent = CType([event], PdfDocumentEvent)
            Dim pdfDoc As PdfDocument = docEvent.GetDocument()
            Dim page As PdfPage = docEvent.GetPage()

            ' Complex implementation for simple headers/footers
            ' ... additional code required
        End Sub
    End Class
End Class

using IronPdf;

// Simple approach with built-in placeholders
var renderer = new ChromePdfRenderer();

// Text headers with merge fields
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "{pdf-title}",
    LeftText = "{date}",
    RightText = "Page {page} of {total-pages}",
    FontSize = 11,
    FontFamily = "Arial"
};

// HTML headers for complex layouts
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    Height = 25,
    HtmlFragment = @"
        <div style='display: flex; justify-content: space-between; width: 100%;'>
            <img src='logo.png' style='height: 20px;' />
            <span>Confidential Document</span>
            <span>{page}/{total-pages}</span>
        </div>",
    BaseUrl = new Uri(@"C:\assets\")
};

var pdf = renderer.RenderHtmlAsPdf("<h1>Document Content</h1>");
pdf.SaveAs("document-with-headers.pdf");

Imports IronPdf

' Simple approach with built-in placeholders
Dim renderer = New ChromePdfRenderer()

' Text headers with merge fields
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .CenterText = "{pdf-title}",
    .LeftText = "{date}",
    .RightText = "Page {page} of {total-pages}",
    .FontSize = 11,
    .FontFamily = "Arial"
}

' HTML headers for complex layouts
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .Height = 25,
    .HtmlFragment = "
        <div style='display: flex; justify-content: space-between; width: 100%;'>
            <img src='logo.png' style='height: 20px;' />
            <span>Confidential Document</span>
            <span>{page}/{total-pages}</span>
        </div>",
    .BaseUrl = New Uri("C:\assets\")
}

Dim pdf = renderer.RenderHtmlAsPdf("<h1>Document Content</h1>")
pdf.SaveAs("document-with-headers.pdf")

using IronPdf;

// Enterprise-grade security implementation
public class SecurePdfGenerator
{
    public void CreateSecurePdf(string content, string outputPath)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(content);

        // Apply 256-bit AES encryption
        pdf.SecuritySettings.OwnerPassword = GenerateStrongPassword();
        pdf.SecuritySettings.UserPassword = "user_password";

        // Granular permission control
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
        pdf.SecuritySettings.AllowUserEditing = false;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;
        pdf.SecuritySettings.AllowUserFormData = true; // Allow form filling only
        pdf.SecuritySettings.AllowUserAnnotations = false;

        // Compliance features
        pdf.SecuritySettings.MakePdfDocumentReadOnly = true;

        // Add digital signature for integrity
        pdf.SignWithDigitalSignature(new PdfSignature("cert.pfx", "password")
        {
            SigningContact = "security@company.com",
            SigningLocation = "Corporate HQ",
            SigningReason = "Document Integrity"
        });

        pdf.SaveAs(outputPath);
    }

    private string GenerateStrongPassword()
    {
        // Implementation for strong password generation
        return System.Web.Security.Membership.GeneratePassword(32, 8);
    }
}

Imports IronPdf

' Enterprise-grade security implementation
Public Class SecurePdfGenerator
    Public Sub CreateSecurePdf(content As String, outputPath As String)
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(content)

        ' Apply 256-bit AES encryption
        pdf.SecuritySettings.OwnerPassword = GenerateStrongPassword()
        pdf.SecuritySettings.UserPassword = "user_password"

        ' Granular permission control
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint
        pdf.SecuritySettings.AllowUserEditing = False
        pdf.SecuritySettings.AllowUserCopyPasteContent = False
        pdf.SecuritySettings.AllowUserFormData = True ' Allow form filling only
        pdf.SecuritySettings.AllowUserAnnotations = False

        ' Compliance features
        pdf.SecuritySettings.MakePdfDocumentReadOnly = True

        ' Add digital signature for integrity
        pdf.SignWithDigitalSignature(New PdfSignature("cert.pfx", "password") With {
            .SigningContact = "security@company.com",
            .SigningLocation = "Corporate HQ",
            .SigningReason = "Document Integrity"
        })

        pdf.SaveAs(outputPath)
    End Sub

    Private Function GenerateStrongPassword() As String
        ' Implementation for strong password generation
        Return System.Web.Security.Membership.GeneratePassword(32, 8)
    End Function
End Class

// Optimized configuration for high-volume processing
var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        RenderDelay = 0, // No delay for static content
        Timeout = 30000, // 30-second timeout
        CssMediaType = PdfCssMediaType.Screen,
        EnableJavaScript = false, // Disable if not needed
        GrayScale = true, // Reduce file size for B&W documents
    }
};

// Reuse renderer instance for multiple operations
foreach (var html in htmlDocuments)
{
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{Guid.NewGuid()}.pdf");
}

' Optimized configuration for high-volume processing
Dim renderer As New ChromePdfRenderer With {
    .RenderingOptions = New ChromePdfRenderOptions With {
        .RenderDelay = 0, ' No delay for static content
        .Timeout = 30000, ' 30-second timeout
        .CssMediaType = PdfCssMediaType.Screen,
        .EnableJavaScript = False, ' Disable if not needed
        .GrayScale = True ' Reduce file size for B&W documents
    }
}

' Reuse renderer instance for multiple operations
For Each html In htmlDocuments
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs($"output_{Guid.NewGuid()}.pdf")
Next

using Azure.Storage.Blobs;
using IronPdf;

public class CloudPdfGenerator
{
    private readonly BlobServiceClient _blobClient;
    private readonly ChromePdfRenderer _renderer;

    public CloudPdfGenerator(string connectionString)
    {
        _blobClient = new BlobServiceClient(connectionString);
        _renderer = new ChromePdfRenderer();
    }

    public async Task<string> GenerateAndStorePdf(string html, string containerName)
    {
        // Generate PDF in memory
        var pdf = _renderer.RenderHtmlAsPdf(html);
        var pdfBytes = pdf.BinaryData;

        // Upload to blob storage
        var container = _blobClient.GetBlobContainerClient(containerName);
        var blobName = $"documents/{Guid.NewGuid()}.pdf";
        var blobClient = container.GetBlobClient(blobName);

        using (var stream = new MemoryStream(pdfBytes))
        {
            await blobClient.UploadAsync(stream, overwrite: true);
        }

        return blobClient.Uri.ToString();
    }
}

Imports Azure.Storage.Blobs
Imports IronPdf
Imports System.IO
Imports System.Threading.Tasks

Public Class CloudPdfGenerator
    Private ReadOnly _blobClient As BlobServiceClient
    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New(connectionString As String)
        _blobClient = New BlobServiceClient(connectionString)
        _renderer = New ChromePdfRenderer()
    End Sub

    Public Async Function GenerateAndStorePdf(html As String, containerName As String) As Task(Of String)
        ' Generate PDF in memory
        Dim pdf = _renderer.RenderHtmlAsPdf(html)
        Dim pdfBytes = pdf.BinaryData

        ' Upload to blob storage
        Dim container = _blobClient.GetBlobContainerClient(containerName)
        Dim blobName = $"documents/{Guid.NewGuid()}.pdf"
        Dim blobClient = container.GetBlobClient(blobName)

        Using stream As New MemoryStream(pdfBytes)
            Await blobClient.UploadAsync(stream, overwrite:=True)
        End Using

        Return blobClient.Uri.ToString()
    End Function
End Class