PDF 转换为字节数组 C#（开发者教程）

using IronPdf;

// Set your license key
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

// Create a new PDF document from HTML
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Sample Document</h1><p>This is test content.</p>");

// Method 1: Direct conversion to byte array
byte[] pdfBytes = pdf.BinaryData;

// Method 2: Using MemoryStream
using var memoryStream = pdf.Stream;
byte[] pdfBytesFromStream = memoryStream.ToArray();

// Verify the result
Console.WriteLine($"PDF size: {pdfBytes.Length} bytes");

Imports IronPdf

' Set your license key
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

' Create a new PDF document from HTML
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sample Document</h1><p>This is test content.</p>")

' Method 1: Direct conversion to byte array
Dim pdfBytes As Byte() = pdf.BinaryData

' Method 2: Using MemoryStream
Using memoryStream = pdf.Stream
    Dim pdfBytesFromStream As Byte() = memoryStream.ToArray()
End Using

' Verify the result
Console.WriteLine($"PDF size: {pdfBytes.Length} bytes")

using IronPdf;
using System.IO;

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

// Load an existing PDF document
var existingPdf = PdfDocument.FromFile("report.pdf");

// Convert to byte array using BinaryData
byte[] fileBytes = existingPdf.BinaryData;

// Alternative: Using System.IO for direct file reading
byte[] directBytes = File.ReadAllBytes("report.pdf");

// Create PdfDocument from byte array
var loadedPdf = new PdfDocument(directBytes);

// Verify pages were loaded correctly
Console.WriteLine($"Loaded PDF with {loadedPdf.PageCount} pages");

Imports IronPdf
Imports System.IO

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

' Load an existing PDF document
Dim existingPdf As PdfDocument = PdfDocument.FromFile("report.pdf")

' Convert to byte array using BinaryData
Dim fileBytes As Byte() = existingPdf.BinaryData

' Alternative: Using System.IO for direct file reading
Dim directBytes As Byte() = File.ReadAllBytes("report.pdf")

' Create PdfDocument from byte array
Dim loadedPdf As New PdfDocument(directBytes)

' Verify pages were loaded correctly
Console.WriteLine($"Loaded PDF with {loadedPdf.PageCount} pages")

using IronPdf;
using System.IO;

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

// Simulate fetching PDF bytes from a database or API
byte[] GetPdfBytesFromDatabase()
{
    return File.ReadAllBytes("example.pdf");
}

// Retrieve bytes
byte[] pdfBytes = GetPdfBytesFromDatabase();

// Create PdfDocument from byte array
var pdfDocument = new PdfDocument(pdfBytes);

// Perform operations on the restored document
Console.WriteLine($"Restored document has {pdfDocument.PageCount} pages");

// Save the document (with any modifications)
pdfDocument.SaveAs("restored-document.pdf");

// Or get updated bytes for further storage
byte[] updatedBytes = pdfDocument.BinaryData;
Console.WriteLine($"Updated bytes: {updatedBytes.Length}");

Imports IronPdf
Imports System.IO

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

' Simulate fetching PDF bytes from a database or API
Private Function GetPdfBytesFromDatabase() As Byte()
    Return File.ReadAllBytes("example.pdf")
End Function

' Retrieve bytes
Dim pdfBytes As Byte() = GetPdfBytesFromDatabase()

' Create PdfDocument from byte array
Dim pdfDocument As New PdfDocument(pdfBytes)

' Perform operations on the restored document
Console.WriteLine($"Restored document has {pdfDocument.PageCount} pages")

' Save the document (with any modifications)
pdfDocument.SaveAs("restored-document.pdf")

' Or get updated bytes for further storage
Dim updatedBytes As Byte() = pdfDocument.BinaryData
Console.WriteLine($"Updated bytes: {updatedBytes.Length}")

using IronPdf;
using System.IO;

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

var renderer = new ChromePdfRenderer();

// Generate PDF and work with it as a stream
var pdf = renderer.RenderHtmlAsPdf("<h1>Invoice</h1><p>Total: $100</p>");

using var pdfStream = pdf.Stream;
byte[] pdfData = pdfStream.ToArray();

// Use bytes for web response, email attachment, or storage
Console.WriteLine($"PDF data ready: {pdfData.Length} bytes");

// Load PDF from byte array into a new MemoryStream
byte[] storedBytes = pdfData; // Typically retrieved from a database
using var loadStream = new MemoryStream(storedBytes);
var restoredPdf = new PdfDocument(loadStream);
Console.WriteLine($"Restored: {restoredPdf.PageCount} page(s)");

Imports IronPdf
Imports System.IO

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Dim renderer As New ChromePdfRenderer()

' Generate PDF and work with it as a stream
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Invoice</h1><p>Total: $100</p>")

Using pdfStream = pdf.Stream
    Dim pdfData As Byte() = pdfStream.ToArray()

    ' Use bytes for web response, email attachment, or storage
    Console.WriteLine($"PDF data ready: {pdfData.Length} bytes")

    ' Load PDF from byte array into a new MemoryStream
    Dim storedBytes As Byte() = pdfData ' Typically retrieved from a database
    Using loadStream As New MemoryStream(storedBytes)
        Dim restoredPdf As New PdfDocument(loadStream)
        Console.WriteLine($"Restored: {restoredPdf.PageCount} page(s)")
    End Using
End Using

using Microsoft.AspNetCore.Mvc;
using IronPdf;
using System;
using System.Threading.Tasks;

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

// Minimal API endpoint (top-level statements, .NET 10)
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/api/report/{reportId}", async (int reportId) =>
{
    var renderer = new ChromePdfRenderer
    {
        RenderingOptions = new ChromePdfRenderOptions
        {
            MarginTop = 25,
            MarginBottom = 25,
            CssMediaType = PdfCssMediaType.Print,
            EnableJavaScript = true
        }
    };

    try
    {
        var html = $"<h1>Report #{reportId}</h1><p>Generated: {DateTime.UtcNow:yyyy-MM-dd}</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        var pdfBytes = pdf.BinaryData;

        return Results.File(pdfBytes, "application/pdf", $"report-{reportId}.pdf");
    }
    catch (Exception ex)
    {
        return Results.Problem($"PDF generation failed: {ex.Message}");
    }
});

app.Run();

Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Imports System
Imports System.Threading.Tasks

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

' Minimal API endpoint (top-level statements, .NET 10)
Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/api/report/{reportId}", Async Function(reportId As Integer)
    Dim renderer = New ChromePdfRenderer With {
        .RenderingOptions = New ChromePdfRenderOptions With {
            .MarginTop = 25,
            .MarginBottom = 25,
            .CssMediaType = PdfCssMediaType.Print,
            .EnableJavaScript = True
        }
    }

    Try
        Dim html = $"<h1>Report #{reportId}</h1><p>Generated: {DateTime.UtcNow:yyyy-MM-dd}</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        Dim pdfBytes = pdf.BinaryData

        Return Results.File(pdfBytes, "application/pdf", $"report-{reportId}.pdf")
    Catch ex As Exception
        Return Results.Problem($"PDF generation failed: {ex.Message}")
    End Try
End Function)

app.Run()