Erstellen Sie PdfDocument Objekte aus Ihren Byte-Arrays und verwenden Sie PdfDocument.Merge(), um diese zu einem einzigen PDF zu kombinieren, ohne auf die Festplatte zu speichern. Diese Methode behandelt die komplexe PDF-Struktur automatisch, sodass Sie Dokumente, die in Datenbanken gespeichert oder von APIs empfangen wurden, zusammenführen können, ohne jemals temporäre Dateien zu schreiben.
Die Arbeit mit als Byte-Arrays gespeicherten PDF-Dateien ist in modernen C#-Anwendungen üblich. Ob Sie PDF-Dokumente aus einer Datenbank abrufen, von Webdiensten empfangen oder im Arbeitsspeicher verarbeiten – die Möglichkeit, mehrere PDF-Dateien zu einer einzigen zusammenzuführen , ohne sie auf der Festplatte zu speichern, ist für die Arbeitsabläufe in Enterprise unerlässlich. IronPDF macht dies mit einer intuitiven API unkompliziert. In diesem Artikel erfahren Sie, wie Sie PDF-Byte-Arrays in C# zusammenführen, indem Sie verschiedene Ansätze untersuchen, einschließlich MemoryStream Handhabung und realer Datenbankmuster.
Ein Byte-Array sind rohe Binärdaten, die eine PDF-Datei im Speicher repräsentieren. Bei der Arbeit mit PDF-Dokumenten in C# stößt man häufig auf Fälle, in denen die Dateien als Byte-Arrays und nicht auf der Festplatte vorliegen. Dies kommt besonders häufig vor beim Abrufen von Dokumenten aus Datenbanken, in denen PDFs als Binärspalten gespeichert sind, oder beim Empfangen von Dokumenten von REST-APIs.
Die MemoryStream-Funktionalität in .NET – dokumentiert in der Microsoft MemoryStream-Referenz – ermöglicht eine effiziente Handhabung dieser Byte-Arrays, insbesondere in Kombination mit einer geeigneten Speicherverwaltung für große Dokumente. Anstatt temporäre Dateien zu schreiben, können Sie PDFs vollständig im Arbeitsspeicher laden, verarbeiten und speichern – das ist schneller, sauberer und vermeidet Probleme mit Dateisystemberechtigungen.
Das einfache Verketten zweier PDF-Byte-Arrays funktioniert nicht. Im Gegensatz zu einfachen Textdateien weisen PDF-Dateien komplexe interne Strukturen mit Kopfzeilen, Querverweistabellen und spezifischen Formatierungskonventionen auf. Die ISO 32000 PDF-Spezifikation definiert komplexe Regeln zur Dokumentstruktur, einschließlich Metadaten, Einbettung von Schriftarten und Verschlüsselungsebenen. Das direkte Zusammenfügen der Bytes führt zu einer beschädigten Datei. Sie benötigen eine geeignete PDF-Bibliothek, um diese Byte-Arrays zu parsen und korrekt zusammenzufügen, wobei die gesamte Struktur erhalten bleibt.
IronPDF bewältigt diese gesamte Komplexität intern. Mit nur wenigen Codezeilen können Sie PDF-Dokumente zusammenführen und dabei Schriftarten, Bilder und Formatierungen genau so beibehalten, wie sie in den Quelldateien vorhanden waren.
Diese Vorgehensweise funktioniert gut, wenn:
Dokumente werden in einer SQL Server- oder PostgreSQL-Datenbank als Binärspalten gespeichert. Ihre Anwendung empfängt PDF-Daten von einer externen API oder einem Microservice. Sie verarbeiten Datei-Uploads in ASP.NET , ohne sie auf der Festplatte zu speichern. Sie arbeiten in einer Cloud-Umgebung wie Azure Functions oder AWS Lambda, in der der temporäre Dateispeicher eingeschränkt ist.
Bei der Arbeit mit Azure Blob Storage oder ähnlichen Cloud-Diensten ist die Manipulation von Byte-Arrays unerlässlich, da man die Rohbytes herunterlädt, verarbeitet und das Ergebnis wieder hochlädt – und das alles, ohne das Dateisystem zu berühren.
Für den Einstieg müssen Sie das IronPDF NuGet Paket zu Ihrem Projekt hinzufügen. Das Paket ist auf NuGet verfügbar. Sie können es entweder über die Paket-Manager-Konsole oder die .NET Befehlszeilenschnittstelle installieren:
Ausführliche Installationsoptionen, einschließlich Docker-Bereitstellung oder Linux-Setup , finden Sie im erweiterten Installationsleitfaden . Bei der Bereitstellung in einer minimalen Umgebung reduziert IronPDF Slim den Bereitstellungsaufwand erheblich.
Nach der Installation fügen Sie die folgenden Namespaces am Anfang Ihrer C#-Datei hinzu:
using IronPdf;
using System.IO;
using System.Collections.Generic;Imports IronPdf
Imports System.IO
Imports System.Collections.GenericIronPDF unterstützt die Plattformen Windows, macOS und Linux . Es lässt sich ohne zusätzliche Konfiguration in ASP.NET Core , Blazor, Konsolenanwendungen und Cloud-Umgebungen integrieren.
Hier ist ein vollständiges Beispiel, das zeigt, wie man zwei PDF-Byte-Arrays zu einem einzigen PDF-Dokument zusammenführt:
// Simulate two PDF byte arrays (in practice, these come from a database or API)
byte[] pdfBytes1 = File.ReadAllBytes("document1.pdf");
byte[] pdfBytes2 = File.ReadAllBytes("document2.pdf");
// Create PdfDocument objects from byte arrays
var pdf1 = new PdfDocument(pdfBytes1);
var pdf2 = new PdfDocument(pdfBytes2);
// Merge the two PDF documents
PdfDocument combinedPdf = PdfDocument.Merge(pdf1, pdf2);
// Convert the combined PDF back to a byte array
byte[] mergedPdfBytes = combinedPdf.BinaryData;
// Optionally save the merged PDF to disk
File.WriteAllBytes("merged.pdf", mergedPdfBytes);Imports System.IO
' Simulate two PDF byte arrays (in practice, these come from a database or API)
Dim pdfBytes1 As Byte() = File.ReadAllBytes("document1.pdf")
Dim pdfBytes2 As Byte() = File.ReadAllBytes("document2.pdf")
' Create PdfDocument objects from byte arrays
Dim pdf1 As New PdfDocument(pdfBytes1)
Dim pdf2 As New PdfDocument(pdfBytes2)
' Merge the two PDF documents
Dim combinedPdf As PdfDocument = PdfDocument.Merge(pdf1, pdf2)
' Convert the combined PDF back to a byte array
Dim mergedPdfBytes As Byte() = combinedPdf.BinaryData
' Optionally save the merged PDF to disk
File.WriteAllBytes("merged.pdf", mergedPdfBytes)Die PdfDocument Klasse akzeptiert rohe Byte-Arrays direkt in ihrem Konstruktor. Sobald Sie zwei PdfDocument Instanzen haben, kombiniert PdfDocument.Merge() diese zu einem einzigen Dokument. Die BinaryData Eigenschaft liefert Ihnen dann das Ergebnis als Byte-Array, bereit zur Speicherung in einer Datenbank oder zur Übertragung über eine API.
Die PdfDocument-API bietet über das einfache Zusammenführen hinausgehende umfangreiche Funktionalitäten, darunter Seitenmanipulation , Textextraktion und Formularverarbeitung . Sobald Sie ein zusammengeführtes Dokument haben, können Sie jede dieser Operationen anwenden, bevor Sie das endgültige Byte-Array extrahieren.
Das Ergebnis ist ein einziges PDF, das alle Seiten aus beiden Quelldokumenten in der Reihenfolge enthält, in der sie an Merge() übergeben wurden. Seitenzahlen, Schriftarten, Bilder und eingebettete Inhalte bleiben erhalten. Das zusammengeführte Dokument verhält sich identisch zu jedem anderen PDF – Sie können es paginieren, kommentieren, signieren oder komprimieren, indem Sie die gleichen IronPDF Methoden verwenden, die Sie auch auf jedes andere Dokument anwenden würden.
Wenn Sie ein Byte-Array an den PdfDocument Konstruktor übergeben, parst IronPDF die Binärdaten und erstellt eine Speicherabbildung der PDF-Struktur. Die PdfDocument.Merge() Methode kombiniert dann mehrere Dokumente, indem sie Seiten aus jeder Quelle der Reihe nach anhängt, die Querverweistabelle neu aufbaut und alle Schriftarten- oder Ressourcennamenskonflikte zwischen den Dokumenten löst.
Deshalb lassen sich Byte-Arrays nicht einfach verketten – die Querverweistabelle in der ersten PDF-Datei verweist auf Offsets innerhalb dieser Datei. Nach der Verkettung sind diese Offsets ungültig, da sie in der zweiten Datei verschoben wurden. IronPDF rekonstruiert die gesamte Struktur korrekt, was zu einem gültigen, wohlgeformten PDF führt.
IronPDF bietet eine List Überladung zum Zusammenführen beliebiger Dokumentanzahlen in einer einzigen Operation. Dies ist effizienter als das Verketten mehrerer Zusammenführungen von zwei Dokumenten:
// Load four PDFs as byte arrays
List<byte[]> pdfByteArrays = new List<byte[]>
{
File.ReadAllBytes("example1.pdf"),
File.ReadAllBytes("example2.pdf"),
File.ReadAllBytes("example3.pdf"),
File.ReadAllBytes("example4.pdf")
};
// Convert each byte array to a PdfDocument
List<PdfDocument> pdfsToMerge = new List<PdfDocument>();
for (int i = 0; i < pdfByteArrays.Count; i++)
{
pdfsToMerge.Add(new PdfDocument(pdfByteArrays[i]));
}
// Merge all documents in one call
PdfDocument combinedPdf = PdfDocument.Merge(pdfsToMerge);
byte[] finalPdfBytes = combinedPdf.BinaryData;
// Apply compression if the result is large
if (finalPdfBytes.Length > 1024 * 1024 * 10) // 10 MB
{
combinedPdf.CompressImages(90);
finalPdfBytes = combinedPdf.BinaryData;
}Imports System.IO
' Load four PDFs as byte arrays
Dim pdfByteArrays As New List(Of Byte()) From {
File.ReadAllBytes("example1.pdf"),
File.ReadAllBytes("example2.pdf"),
File.ReadAllBytes("example3.pdf"),
File.ReadAllBytes("example4.pdf")
}
' Convert each byte array to a PdfDocument
Dim pdfsToMerge As New List(Of PdfDocument)()
For i As Integer = 0 To pdfByteArrays.Count - 1
pdfsToMerge.Add(New PdfDocument(pdfByteArrays(i)))
Next
' Merge all documents in one call
Dim combinedPdf As PdfDocument = PdfDocument.Merge(pdfsToMerge)
Dim finalPdfBytes As Byte() = combinedPdf.BinaryData
' Apply compression if the result is large
If finalPdfBytes.Length > 1024 * 1024 * 10 Then ' 10 MB
combinedPdf.CompressImages(90)
finalPdfBytes = combinedPdf.BinaryData
End IfDieser Ansatz lässt sich auf beliebig viele Dokumente skalieren. Jedes PDF wird in ein PdfDocument Objekt geladen, zu einer Liste hinzugefügt und dann in einem einzigen Aufruf zusammengeführt. Bei großen Ausgabedateien reduziert die PDF-Komprimierung die endgültige Dateigröße, ohne dass dabei nennenswerte Qualitätseinbußen entstehen.
Der MemoryStream Ansatz gibt Ihnen mehr Kontrolle bei der Integration mit anderen .NET-Bibliotheken, die mit Streams statt mit Byte-Arrays arbeiten. Es ist auch dann nützlich, wenn bereits ein Datenstrom verfügbar ist (z. B. aus einer HTTP-Antwort oder einem Blob-Storage-SDK):
using (var stream1 = new MemoryStream(pdfBytes1))
using (var stream2 = new MemoryStream(pdfBytes2))
{
var pdf1 = new PdfDocument(stream1);
var pdf2 = new PdfDocument(stream2);
var merged = PdfDocument.Merge(pdf1, pdf2);
// Add metadata to the merged document
merged.MetaData.Author = "Your Application";
merged.MetaData.Title = "Merged Document";
merged.MetaData.CreationDate = DateTime.Now;
byte[] result = merged.BinaryData;
}Imports System.IO
Using stream1 As New MemoryStream(pdfBytes1)
Using stream2 As New MemoryStream(pdfBytes2)
Dim pdf1 = New PdfDocument(stream1)
Dim pdf2 = New PdfDocument(stream2)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
' Add metadata to the merged document
merged.MetaData.Author = "Your Application"
merged.MetaData.Title = "Merged Document"
merged.MetaData.CreationDate = DateTime.Now
Dim result As Byte() = merged.BinaryData
End Using
End UsingSie können das zusammengeführte Dokument anreichern, indem Sie Metadaten festlegen , Wasserzeichen hinzufügen oder digitale Signaturen anwenden, bevor Sie die endgültigen Bytes extrahieren. Für Compliance-Szenarien empfiehlt sich die Konvertierung in PDF/A für die Langzeitarchivierung oder die Einhaltung der PDF/UA- Vorgaben für Barrierefreiheitsanforderungen.
Streambasierte Verarbeitung bietet ein besseres Speichermanagement für größere PDF-Dateien und lässt sich nahtlos in Cloud-Speicher-SDKs integrieren. Dieser Ansatz ist besonders praktisch für asynchrone Muster in Diensten mit hohem Durchsatz.
Ein häufiges Anwendungsbeispiel aus der Praxis ist das Abrufen von PDF-Byte-Arrays aus einer SQL-Datenbank und deren bedarfsgerechte Kombination. Hier ist ein produktionsreifes Beispiel mit Fehlerbehandlung:
public string MergePdfDocumentsFromDatabase(List<int> documentIds)
{
List<PdfDocument> documents = new List<PdfDocument>();
try
{
foreach (int id in documentIds)
{
// Fetch PDF byte array from database
byte[] pdfData = GetPdfFromDatabase(id); // Replace with your data access logic
if (pdfData == null || pdfData.Length == 0)
{
Console.WriteLine($"Warning: Document {id} is empty or not found");
continue;
}
documents.Add(new PdfDocument(pdfData));
}
if (documents.Count == 0)
{
return "Error: No valid documents found to merge";
}
// Merge all documents
PdfDocument mergedDocument = PdfDocument.Merge(documents);
// Add page numbers to the footer
mergedDocument.AddHtmlFooters(new HtmlHeaderFooter()
{
HtmlFragment = "<center>Page {page} of {total-pages}</center>",
DrawDividerLine = true
});
// Save back to the database
byte[] resultBytes = mergedDocument.BinaryData;
SaveMergedPdfToDatabase(resultBytes);
return "Document successfully combined and saved.";
}
catch (Exception ex)
{
Console.WriteLine($"Error merging PDFs: {ex.Message}");
return $"Merge failed: {ex.Message}";
}
}Imports System
Public Function MergePdfDocumentsFromDatabase(documentIds As List(Of Integer)) As String
Dim documents As New List(Of PdfDocument)()
Try
For Each id As Integer In documentIds
' Fetch PDF byte array from database
Dim pdfData As Byte() = GetPdfFromDatabase(id) ' Replace with your data access logic
If pdfData Is Nothing OrElse pdfData.Length = 0 Then
Console.WriteLine($"Warning: Document {id} is empty or not found")
Continue For
End If
documents.Add(New PdfDocument(pdfData))
Next
If documents.Count = 0 Then
Return "Error: No valid documents found to merge"
End If
' Merge all documents
Dim mergedDocument As PdfDocument = PdfDocument.Merge(documents)
' Add page numbers to the footer
mergedDocument.AddHtmlFooters(New HtmlHeaderFooter() With {
.HtmlFragment = "<center>Page {page} of {total-pages}</center>",
.DrawDividerLine = True
})
' Save back to the database
Dim resultBytes As Byte() = mergedDocument.BinaryData
SaveMergedPdfToDatabase(resultBytes)
Return "Document successfully combined and saved."
Catch ex As Exception
Console.WriteLine($"Error merging PDFs: {ex.Message}")
Return $"Merge failed: {ex.Message}"
End Try
End FunctionDieses Muster geht elegant mit fehlenden oder leeren Datensätzen um, indem es diese überspringt und mit gültigen Dokumenten fortfährt. Dem zusammengeführten Ergebnis werden über HTML-Kopf- und Fußzeilen Seitenzahlen hinzugefügt, bevor es zurück in die Datenbank geschrieben wird. Für eine erweiterte Navigation können Sie Lesezeichen hinzufügen , um den Lesern die Navigation in einem langen, zusammengeführten Dokument zu erleichtern.
Das oben beschriebene Muster funktioniert für Rechnungen, Berichte, Verträge oder beliebige Dokumente, die als Binärspalten gespeichert sind. Wichtigste Vorteile:
Beim Erstellen von PDF-Merge-Workflows sollten verschiedene Fehlerquellen vermieden werden:
pdfData != null && pdfData.Length > 0, bevor Sie eine PdfDocument konstruieren.PdfDocument Objekte nach dem Zusammenführen.Hier ist ein zuverlässiges Muster mit Eingabevalidierung:
public bool TryMergePdfByteArrays(byte[] pdfBytes1, byte[] pdfBytes2, out byte[] mergedBytes)
{
mergedBytes = null;
try
{
if (pdfBytes1 == null || pdfBytes1.Length == 0)
throw new ArgumentException("First PDF byte array is null or empty");
if (pdfBytes2 == null || pdfBytes2.Length == 0)
throw new ArgumentException("Second PDF byte array is null or empty");
using var pdf1 = new PdfDocument(pdfBytes1);
using var pdf2 = new PdfDocument(pdfBytes2);
if (pdf1.PageCount == 0)
throw new InvalidOperationException("First PDF has no pages");
if (pdf2.PageCount == 0)
throw new InvalidOperationException("Second PDF has no pages");
var mergedPdf = PdfDocument.Merge(pdf1, pdf2);
mergedBytes = mergedPdf.BinaryData;
return true;
}
catch (Exception ex)
{
Console.WriteLine($"PDF merge failed: {ex.Message}");
return false;
}
}Imports System
Public Function TryMergePdfByteArrays(pdfBytes1 As Byte(), pdfBytes2 As Byte(), ByRef mergedBytes As Byte()) As Boolean
mergedBytes = Nothing
Try
If pdfBytes1 Is Nothing OrElse pdfBytes1.Length = 0 Then
Throw New ArgumentException("First PDF byte array is null or empty")
End If
If pdfBytes2 Is Nothing OrElse pdfBytes2.Length = 0 Then
Throw New ArgumentException("Second PDF byte array is null or empty")
End If
Using pdf1 As New PdfDocument(pdfBytes1)
Using pdf2 As New PdfDocument(pdfBytes2)
If pdf1.PageCount = 0 Then
Throw New InvalidOperationException("First PDF has no pages")
End If
If pdf2.PageCount = 0 Then
Throw New InvalidOperationException("Second PDF has no pages")
End If
Dim mergedPdf = PdfDocument.Merge(pdf1, pdf2)
mergedBytes = mergedPdf.BinaryData
Return True
End Using
End Using
Catch ex As Exception
Console.WriteLine($"PDF merge failed: {ex.Message}")
Return False
End Try
End FunctionDie using Anweisungen sorgen dafür, dass PdfDocument Objekte korrekt entsorgt werden, um nicht verwaltete Ressourcen freizugeben, auch wenn eine Ausnahme auftritt. Das TryXxx Muster gibt einen booleschen Erfolgsindikator zurück statt zu werfen, was es einfach macht, es von höherer Ebene Code aufzurufen, der mit mehreren Dokumenten arbeitet.
Mehrere Gewohnheiten verringern das Risiko von Produktionsausfällen:
using zur Entsorgung: IronPDF-Dokumente halten native Ressourcen. Entsorgen Sie sie immer, entweder mit using Anweisungen oder durch explizite Dispose() Aufrufe.| Ansatz | Am besten für | Speichernutzung | Flexibilität |
|---|---|---|---|
| Direktes Byte-Array (zwei Dateien) | Einfaches Zusammenführen zweier Dokumente | Niedrig | Grundlegendes |
| List<PdfDocument> overload | Stapelverarbeitung vieler Dateien | Mittel | Hoch |
| MemoryStream-Konstruktor | Streambasierte Integrationen | Niedrig | Hoch |
| Datenbankabrufmuster | Workflows für Produktionsdokumente | Mittel | Sehr hoch |
IronPDF bietet eine vollumfängliche kostenlose Testversion , damit Sie das Zusammenführen von PDFs in Ihrer tatsächlichen Anwendung testen können, bevor Sie sich für eine Lizenz entscheiden. Die Testversion beinhaltet die vollständige API – Zusammenführen, Aufteilen, Konvertieren, Kommentieren, Signieren und mehr – ohne Funktionseinschränkungen während der Evaluierungsphase.
Für den Produktiveinsatz reichen die Lizenzoptionen von Einzelentwicklerlizenzen bis hin zu Enterprise , die unbegrenzte Bereitstellungen abdecken. Organisationen, die mit einem hohen Arbeitsaufkommen arbeiten, können OEM-Lizenzen für Weiterverteilungsszenarien in Betracht ziehen.
Neben dem Zusammenführen von Dateien deckt IronPDF den gesamten PDF-Verarbeitungszyklus ab: HTML-zu-PDF-Konvertierung , PDF-Bearbeitung , Formularerstellung und -ausfüllung , Textextraktion , digitale Signaturen und Sicherheitsmanagement . Sobald der Merge-Workflow funktioniert, lassen sich diese Funktionen ohne zusätzliche Abhängigkeiten nahtlos integrieren.
Auf der IronPDF -Tutorialseite finden Sie vollständige Anleitungen für jede wichtige Funktion. Detaillierte Dokumentationen zu jeder Klasse und Methode finden Sie in der API-Referenz .
Mit NuGet installieren
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
