Konvertieren von PDF in Byte-Array in C#

using IronPdf;

// Configure renderer with optimization settings
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

// Create a new PDF document from HTML
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 with additional processing
using (var memoryStream = pdf.Stream)
{
    // Optional: Apply compression before converting to bytes
    byte[] pdfBytesFromStream = memoryStream.ToArray();
}

// Verify conversion and display size
System.Console.WriteLine($"PDF size: {pdfBytes.Length} bytes");

// Optional: Convert to Base64 for text-safe transmission
string base64Pdf = Convert.ToBase64String(pdfBytes);

Imports IronPdf

' Configure renderer with optimization settings
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.PrintHtmlBackgrounds = True

' Create a new PDF document from HTML
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 with additional processing
Using memoryStream = pdf.Stream
    ' Optional: Apply compression before converting to bytes
    Dim pdfBytesFromStream As Byte() = memoryStream.ToArray()
End Using

' Verify conversion and display size
System.Console.WriteLine($"PDF size: {pdfBytes.Length} bytes")

' Optional: Convert to Base64 for text-safe transmission
Dim base64Pdf As String = Convert.ToBase64String(pdfBytes)

using IronPdf;
using System.IO;
using System;

try
{
    // Load an existing PDF document with error handling
    var existingPdf = PdfDocument.FromFile("report.pdf");

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

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

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

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

    // Additional validation: Check file structure
    if (loadedPdf.PageCount == 0)
    {
        throw new InvalidOperationException("PDF contains no pages");
    }

    // Optional: Extract metadata for verification
    var metadata = loadedPdf.MetaData;
    Console.WriteLine($"Title: {metadata.Title}");
    Console.WriteLine($"Author: {metadata.Author}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error processing PDF: {ex.Message}");
    // Implement appropriate error handling
}

Imports IronPdf
Imports System.IO
Imports System

Try
    ' Load an existing PDF document with error handling
    Dim existingPdf = PdfDocument.FromFile("report.pdf")

    ' Convert to byte array
    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 with validation
    Dim loadedPdf = New PdfDocument(directBytes)

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

    ' Additional validation: Check file structure
    If loadedPdf.PageCount = 0 Then
        Throw New InvalidOperationException("PDF contains no pages")
    End If

    ' Optional: Extract metadata for verification
    Dim metadata = loadedPdf.MetaData
    Console.WriteLine($"Title: {metadata.Title}")
    Console.WriteLine($"Author: {metadata.Author}")
Catch ex As Exception
    Console.WriteLine($"Error processing PDF: {ex.Message}")
    ' Implement appropriate error handling
End Try

using IronPdf;
using System;
using System.Data.SqlClient;

// Example: Retrieve from SQL Server database
byte[] pdfBytes = GetPdfBytesFromDatabase(documentId: 123);

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

// Perform operations on the restored document
// Add watermark
pdfDocument.ApplyWatermark("<h2 style='color:red'>CONFIDENTIAL</h2>", 
    opacity: 50, 
    rotation: -45);

// Add page numbers
pdfDocument.AddTextHeaders("{page} of {total-pages}", 
    IronPdf.Rendering.PdfCssMediaType.Print);

// Save the modified PDF
pdfDocument.SaveAs("modified-document.pdf");

// Or get updated bytes for storage
byte[] updatedBytes = pdfDocument.BinaryData;

// Store back to database
SaveToDatabase(documentId: 123, pdfData: updatedBytes);

// Example database retrieval method
byte[] GetPdfBytesFromDatabase(int documentId)
{
    using (var connection = new SqlConnection("YourConnectionString"))
    {
        var command = new SqlCommand(
            "SELECT PdfData FROM Documents WHERE Id = @id", 
            connection);
        command.Parameters.AddWithValue("@id", documentId);

        connection.Open();
        return (byte[])command.ExecuteScalar();
    }
}

// Example database save method
void SaveToDatabase(int documentId, byte[] pdfData)
{
    using (var connection = new SqlConnection("YourConnectionString"))
    {
        var command = new SqlCommand(
            "UPDATE Documents SET PdfData = @data WHERE Id = @id", 
            connection);
        command.Parameters.AddWithValue("@id", documentId);
        command.Parameters.AddWithValue("@data", pdfData);

        connection.Open();
        command.ExecuteNonQuery();
    }
}

Imports IronPdf
Imports System
Imports System.Data.SqlClient

' Example: Retrieve from SQL Server database
Dim pdfBytes As Byte() = GetPdfBytesFromDatabase(documentId:=123)

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

' Perform operations on the restored document
' Add watermark
pdfDocument.ApplyWatermark("<h2 style='color:red'>CONFIDENTIAL</h2>", opacity:=50, rotation:=-45)

' Add page numbers
pdfDocument.AddTextHeaders("{page} of {total-pages}", IronPdf.Rendering.PdfCssMediaType.Print)

' Save the modified PDF
pdfDocument.SaveAs("modified-document.pdf")

' Or get updated bytes for storage
Dim updatedBytes As Byte() = pdfDocument.BinaryData

' Store back to database
SaveToDatabase(documentId:=123, pdfData:=updatedBytes)

' Example database retrieval method
Function GetPdfBytesFromDatabase(documentId As Integer) As Byte()
    Using connection As New SqlConnection("YourConnectionString")
        Dim command As New SqlCommand("SELECT PdfData FROM Documents WHERE Id = @id", connection)
        command.Parameters.AddWithValue("@id", documentId)

        connection.Open()
        Return CType(command.ExecuteScalar(), Byte())
    End Using
End Function

' Example database save method
Sub SaveToDatabase(documentId As Integer, pdfData As Byte())
    Using connection As New SqlConnection("YourConnectionString")
        Dim command As New SqlCommand("UPDATE Documents SET PdfData = @data WHERE Id = @id", connection)
        command.Parameters.AddWithValue("@id", documentId)
        command.Parameters.AddWithValue("@data", pdfData)

        connection.Open()
        command.ExecuteNonQuery()
    End Using
End Sub

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using Microsoft.Extensions.Caching.Memory;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly IMemoryCache _cache;
    private readonly ChromePdfRenderer _renderer;

    public PdfController(IMemoryCache cache)
    {
        _cache = cache;
        _renderer = new ChromePdfRenderer();

        // Configure for web optimization
        _renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
        _renderer.RenderingOptions.MarginTop = 40;
        _renderer.RenderingOptions.MarginBottom = 40;
        _renderer.RenderingOptions.EnableJavaScript = true;
        _renderer.RenderingOptions.WaitFor.RenderDelay(200);
    }

    [HttpGet("report/{reportId}")]
    public async Task<IActionResult> GenerateReport(string reportId)
    {
        // Check cache first
        if (_cache.TryGetValue($"pdf_{reportId}", out byte[] cachedPdf))
        {
            return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf");
        }

        try
        {
            // Generate report data
            var reportData = await GetReportDataAsync(reportId);
            var html = GenerateReportHtml(reportData);

            // Create PDF with headers/footers
            var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

            // Add headers
            pdf.AddTextHeaders(new TextHeaderFooter
            {
                CenterText = reportData.Title,
                LeftText = "{date}",
                RightText = "{page} of {total-pages}",
                DrawDividerLine = true
            });

            // Convert to bytes
            byte[] pdfBytes = pdf.BinaryData;

            // Cache for 5 minutes
            var cacheOptions = new MemoryCacheEntryOptions()
                .SetSlidingExpiration(TimeSpan.FromMinutes(5));
            _cache.Set($"pdf_{reportId}", pdfBytes, cacheOptions);

            // Return file with proper headers
            Response.Headers.Add("Content-Disposition", 
                $"inline; filename=report_{reportId}.pdf");
            Response.Headers.Add("X-Content-Type-Options", "nosniff");

            return File(pdfBytes, "application/pdf");
        }
        catch (Exception ex)
        {
            // Log error
            return StatusCode(500, "Error generating PDF");
        }
    }

    [HttpPost("merge")]
    public async Task<IActionResult> MergePdfs([FromBody] MergeRequest request)
    {
        if (request.PdfBytes == null || request.PdfBytes.Count < 2)
        {
            return BadRequest("At least 2 PDFs required for merging");
        }

        // Convert byte arrays to PdfDocuments
        var pdfs = request.PdfBytes
            .Select(bytes => new PdfDocument(bytes))
            .ToList();

        // Merge PDFs
        var mergedPdf = PdfDocument.Merge(pdfs);

        // Apply consistent formatting
        mergedPdf.AddTextFooters(new TextHeaderFooter
        {
            CenterText = "Merged Document - Page {page}",
            FontSize = 10
        });

        // Clean up
        pdfs.ForEach(pdf => pdf.Dispose());

        byte[] resultBytes = mergedPdf.BinaryData;
        mergedPdf.Dispose();

        return File(resultBytes, "application/pdf", "merged.pdf");
    }

    private string GenerateReportHtml(ReportData data)
    {
        return $@"
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    @media print {{
                        .page-break {{ page-break-after: always; }}
                    }}
                    body {{ 
                        font-family: Arial, sans-serif; 
                        line-height: 1.6;
                    }}
                    table {{ 
                        width: 100%; 
                        border-collapse: collapse; 
                    }}
                    th, td {{ 
                        border: 1px solid #ddd; 
                        padding: 8px; 
                    }}
                </style>
            </head>
            <body>
                <h1>{data.Title}</h1>
                <p>Generated: {DateTime.Now:yyyy-MM-dd HH:mm}</p>
                {data.HtmlContent}
            </body>
            </html>";
    }
}

public class MergeRequest
{
    public List<byte[]> PdfBytes { get; set; }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports System.Threading.Tasks
Imports Microsoft.Extensions.Caching.Memory

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _cache As IMemoryCache
    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New(cache As IMemoryCache)
        _cache = cache
        _renderer = New ChromePdfRenderer()

        ' Configure for web optimization
        _renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
        _renderer.RenderingOptions.MarginTop = 40
        _renderer.RenderingOptions.MarginBottom = 40
        _renderer.RenderingOptions.EnableJavaScript = True
        _renderer.RenderingOptions.WaitFor.RenderDelay(200)
    End Sub

    <HttpGet("report/{reportId}")>
    Public Async Function GenerateReport(reportId As String) As Task(Of IActionResult)
        ' Check cache first
        Dim cachedPdf As Byte() = Nothing
        If _cache.TryGetValue($"pdf_{reportId}", cachedPdf) Then
            Return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf")
        End If

        Try
            ' Generate report data
            Dim reportData = Await GetReportDataAsync(reportId)
            Dim html = GenerateReportHtml(reportData)

            ' Create PDF with headers/footers
            Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)

            ' Add headers
            pdf.AddTextHeaders(New TextHeaderFooter With {
                .CenterText = reportData.Title,
                .LeftText = "{date}",
                .RightText = "{page} of {total-pages}",
                .DrawDividerLine = True
            })

            ' Convert to bytes
            Dim pdfBytes As Byte() = pdf.BinaryData

            ' Cache for 5 minutes
            Dim cacheOptions = New MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(5))
            _cache.Set($"pdf_{reportId}", pdfBytes, cacheOptions)

            ' Return file with proper headers
            Response.Headers.Add("Content-Disposition", $"inline; filename=report_{reportId}.pdf")
            Response.Headers.Add("X-Content-Type-Options", "nosniff")

            Return File(pdfBytes, "application/pdf")
        Catch ex As Exception
            ' Log error
            Return StatusCode(500, "Error generating PDF")
        End Try
    End Function

    <HttpPost("merge")>
    Public Async Function MergePdfs(<FromBody> request As MergeRequest) As Task(Of IActionResult)
        If request.PdfBytes Is Nothing OrElse request.PdfBytes.Count < 2 Then
            Return BadRequest("At least 2 PDFs required for merging")
        End If

        ' Convert byte arrays to PdfDocuments
        Dim pdfs = request.PdfBytes.Select(Function(bytes) New PdfDocument(bytes)).ToList()

        ' Merge PDFs
        Dim mergedPdf = PdfDocument.Merge(pdfs)

        ' Apply consistent formatting
        mergedPdf.AddTextFooters(New TextHeaderFooter With {
            .CenterText = "Merged Document - Page {page}",
            .FontSize = 10
        })

        ' Clean up
        pdfs.ForEach(Sub(pdf) pdf.Dispose())

        Dim resultBytes As Byte() = mergedPdf.BinaryData
        mergedPdf.Dispose()

        Return File(resultBytes, "application/pdf", "merged.pdf")
    End Function

    Private Function GenerateReportHtml(data As ReportData) As String
        Return $"
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    @media print {{
                        .page-break {{ page-break-after: always; }}
                    }}
                    body {{ 
                        font-family: Arial, sans-serif; 
                        line-height: 1.6;
                    }}
                    table {{ 
                        width: 100%; 
                        border-collapse: collapse; 
                    }}
                    th, td {{ 
                        border: 1px solid #ddd; 
                        padding: 8px; 
                    }}
                </style>
            </head>
            <body>
                <h1>{data.Title}</h1>
                <p>Generated: {DateTime.Now:yyyy-MM-dd HH:mm}</p>
                {data.HtmlContent}
            </body>
            </html>"
    End Function
End Class

Public Class MergeRequest
    Public Property PdfBytes As List(Of Byte())
End Class