Test in einer Live-Umgebung
Test in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es brauchen.
PDF steht für Portable Document Format. Es handelt sich um einen Dateityp, der die konventionelle Anzeige eines Dokuments auf vielen verschiedenen Geräten ermöglicht. PDFs werden häufig verwendet, um wichtige Dokumente wie Lebensläufe mit potenziellen Arbeitgebern oder Rechnungen mit Kunden zu teilen.
Trotz ihrer Beliebtheit hat die Verwendung von PDF-Dateien für die Speicherung und den Austausch von Daten auch einige Nachteile. PDFs können zum Beispiel nicht per E-Mail weitergegeben werden, da sie zuerst in einem PDF-Reader geöffnet werden müssen. Selbst wenn dies möglich wäre, würden PDFs nicht so klar aussehen wie ein Word-Dokument, wenn sie auf einem Telefon geöffnet werden. Außerdem können PDF-Dateien nicht wie Word-Dokumente bearbeitet oder aktualisiert werden, es sei denn, Sie haben eine Bearbeitungssoftware auf Ihrem Computer installiert, die die Daten in der Datei erkennen und in eine bearbeitbare Form zurückverwandeln kann. Das bedeutet, dass die PDF-Dateien beim Öffnen gleich aussehen, unabhängig davon, welches Gerät Sie verwenden - ob PC oder Mac. Dies macht PDF-Dateien auf allen Geräten zuverlässig, da sie einen vertrauten Standard implementieren, der in anderen Dokumentenformaten wie JPEG oder GIF nicht zu finden ist.
In diesem Artikel werden wir zwei .NET-PDF-Bibliotheken untersuchen:
IronPDF ist eine .NET-Bibliothek, die mit nur wenigen Zeilen Code Funktionen zum Erstellen, Lesen und Bearbeiten von PDF-Dokumenten bereitstellt. Der folgende Artikel zeigt Ihnen, wie Sie mit IronPDF PDF-Dateien erstellen können. Der Inhalt setzt voraus, dass Sie die Grundlagen von Visual Studio oder C# verstehen und über HTML-Kenntnisse verfügen.
Wir benötigen Visual Studio zum Schreiben, Kompilieren und Ausführen unserer Anwendung, C# zum Schreiben von Logik und Code und HTML zum Formatieren von PDF-Dateien, einschließlich des Hinzufügens von Titeln, Überschriften, Bildern, Absätzen usw. Die IronPDF-Bibliothek unterstützt vollständig .NET Core, .NET 5, Framework und Standard.
Wir können eine PDF-Datei in C# mit nur ein paar Zeilen Code erstellen. Mit Grundkenntnissen in C# und HTML ist dies eine einfache Aufgabe. Weitere Informationen über IronPDF finden Sie auf der Websiteoffizielle Website zu IronPDF-Funktionen.
Die Entwicklung einer Lösung erfordert die Installation derNuGet-Paket für IronPDF. Klicken Sie direkt in der Menüleiste auf "Projekt". Es erscheint eine Dropdown-Liste. Wählen Sie "VerwaltenNuGet-Paketewählen Sie aus dem Dropdown-Menü den Punkt "Übersetzung" aus und wählen Sie ihn aus. Es wird ein Fenster wie das folgende angezeigt:
Wählen Sie die Registerkarte "Durchsuchen", woraufhin ein Fenster wie das folgende erscheint:
Geben Sie "IronPdf" in das Suchfeld ein und drücken Sie "Enter" Das entsprechende Fenster sollte nun erscheinen:
Wählen Sie IronPDF:
Wählen Sie die Schaltfläche "Installieren". Nach erfolgreicher Installation wird das entsprechende Fenster eingeblendet:
Sobald Sie die Schaltfläche "OK" drücken, können Sie loslegen.
Fügen Sie den Namensraum IronPdf
am Anfang der Datei hinzu.
using IronPdf;
using IronPdf;
Imports IronPdf
Ab diesem Punkt beginnt die eigentliche Arbeit. Wir benötigen einen Dateipfad, um das erstellte PDF-Dokument zu speichern. Um dies zu erreichen, verwenden wir SaveFileDialog, das den Benutzer auffordert, einen Dateinamen und einen Dateipfad zu wählen.
private void Save_Click(object sender, EventArgs e)
{
// Code to Select the folder and save the file.
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.InitialDirectory = @"D:\";
saveFileDialog1.Title = "Save Pdf File";
saveFileDialog1.DefaultExt = "pdf";
saveFileDialog1.Filter = "Pdf files (*.pdf)
*.pdf
All files (*.*)
*.*";
saveFileDialog1.FilterIndex = 2;
saveFileDialog1.RestoreDirectory = true;
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
string filename = saveFileDialog1.FileName;
// actual code that will create Pdf files
var HtmlLine = new HtmlToPdf();
HtmlLine.RenderHtmlAsPdf(PdfText.Text).SaveAs(filename);
// MessageBox to display that file save
MessageBox.Show("File Saved Successfully!");
}
}
private void Save_Click(object sender, EventArgs e)
{
// Code to Select the folder and save the file.
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.InitialDirectory = @"D:\";
saveFileDialog1.Title = "Save Pdf File";
saveFileDialog1.DefaultExt = "pdf";
saveFileDialog1.Filter = "Pdf files (*.pdf)
*.pdf
All files (*.*)
*.*";
saveFileDialog1.FilterIndex = 2;
saveFileDialog1.RestoreDirectory = true;
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
string filename = saveFileDialog1.FileName;
// actual code that will create Pdf files
var HtmlLine = new HtmlToPdf();
HtmlLine.RenderHtmlAsPdf(PdfText.Text).SaveAs(filename);
// MessageBox to display that file save
MessageBox.Show("File Saved Successfully!");
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
SaveFileDialog sollte einen Dateidialog öffnen, in dem Sie den Ordner und den Dateinamen an dem Ort auswählen können, an dem Sie ein PDF-Dokument erstellen möchten. Das Ausgangsverzeichnis ist auf das Laufwerk D festgelegt, aber Sie können es auf ein beliebiges Verzeichnis setzen. Da wir es nur mit PDF-Dateien zu tun haben, wurde die Standarderweiterung auf PDF-Dateien gesetzt.
In der "if"-Bedingung wird der eigentliche Code für die Erstellung der PDF-Datei eingefügt. Jetzt können wir sehen, dass es uns gelungen ist, mit nur zwei Codezeilen eine PDF-Datei zu erzeugen. PdfText ist der Name einer Rich-Text-Box, die den Text enthält, der in ein PDF-Dokument geschrieben wird. Der Dateiname ist der Dateipfad und -name, der über die Methode SaveFileDialog ausgewählt wurde.
Sie denken vielleicht, dass der Code zum Lesen von PDF-Dateien komplex und schwierig zu schreiben/zu verstehen ist - aber keine Sorge, IronPDF hat ihn leichter und einfacher gemacht. Dieser Prozess erfordert lediglich zwei Codezeilen!
Fügen Sie den folgenden Code zum Importieren der IronPdf-Bibliothek am Anfang der Datei ein.
using IronPdf;
using System;
using System.Windows.Forms;
using IronPdf;
using System;
using System.Windows.Forms;
Imports IronPdf
Imports System
Imports System.Windows.Forms
Schreiben Sie den folgenden Code innerhalb der Funktion.
private void Read_Click(object sender, EventArgs e)
{
PdfDocument PDF = PdfDocument.FromFile(FilePath.Text);
FileContent.Text = PDF.ExtractAllText();
}
private void Read_Click(object sender, EventArgs e)
{
PdfDocument PDF = PdfDocument.FromFile(FilePath.Text);
FileContent.Text = PDF.ExtractAllText();
}
Private Sub Read_Click(ByVal sender As Object, ByVal e As EventArgs)
Dim PDF As PdfDocument = PdfDocument.FromFile(FilePath.Text)
FileContent.Text = PDF.ExtractAllText()
End Sub
Dadurch werden alle Informationen aus der Datenquelle in den Dokumentbetrachter extrahiert. Alle Berichtskomponenten werden diese Daten als Datenquelle verwenden.
GrapeCity Documents ist ein plattformübergreifendes Dokumentenmanagementsystem, das eine universelle Dokumenten-, Editor- und Reader-Lösung für alle gängigen Dokumentenformate bietet. Ohne ein zusätzliches Programm wie Adobe Acrobat zu benötigen, kann die umfangreiche Bibliothek des .NET-Standards 2.0 zum Lesen, Erzeugen, Ändern und Speichern von PDF-Dateien verwendet werden. Es verfügt über einen robusten Funktionsumfang, mit dem Entwickler PDF-Dateien erstellen können, die erweiterte Schriftarten, Fotos, Grafiken, Strichcodes, Kommentare, Umrisse, Stempel, Wasserzeichen und vieles mehr unterstützen.
In .NET-Standard-Anwendungen können Sie GrapeCityPDF verwenden, um PDF-Dokumente mit einfachen oder komplizierten Geschäftsanforderungen zu erstellen. Außerdem können Sie PDF-Dateien aus beliebigen Quellen laden, ändern und speichern.
Mit GrapeCityPDF können Sie ein PDF als Bild speichern, ohne die Bildqualität zu beeinträchtigen. Außerdem benötigen Sie nur wenige Zeilen Code, um diese Funktion zu implementieren.
GrapeCity Documents PDF Viewer ist ein leichtgewichtiger, programmierbarer Client-Viewer zur Anzeige von PDF-Dateien. Viele der üblichen PDF-Funktionen werden unterstützt.
Die GrapeCityPDF-Bibliothek verfügt über zahlreiche Funktionen, mit denen Sie komplizierte PDF-Dokumente erstellen können, die Informationen wie Text, Grafiken, Fotos, Anmerkungen, Gliederungen und mehr enthalten.
Es gibt zwei Methoden, GrapeCity zu installieren.
Wählen Sie die Schaltfläche gepackte Quelldateien herunterladen, um die aktuellen Beispielquellen herunterzuladen.
Entpacken Sie die Dateien direkt aus der heruntergeladenen ZIP-Datei in ein Verzeichnis auf Ihrem Computer.
Navigieren Sie zu diesem Verzeichnis.
Führen Sie die Batch-Datei run.cmd aus. Dadurch werden die Beispielquellen erstellt. Starten Sie den SupportApi-Dienst und öffnen Sie die URL http://localhost:3003
in Ihrem Standardbrowser.
Das folgende Thema beschreibt die Installation der WinForms Edition. Die folgenden Schritte enthalten eine Anleitung zur Installation der WinForms Edition:
Wenn Sie ein neuer Benutzer sind:
Registrieren Sie sich bei Component One und erstellen Sie ein Konto, indem Sie die erforderlichen Felder ausfüllen.
Die Bestätigung wird an Ihre E-Mail-Adresse geschickt.
Das Installationsprogramm installiert die Steuerelemente und zeigt dabei den Fortschritt an. Solange dieser Bildschirm angezeigt wird, können Sie den Installationsvorgang nicht abbrechen.
using System;
using System.IO;
using System.Drawing;
using System.Text;
using GrapeCity.Documents.Text;
using GrapeCity.Documents.Common;
using GrapeCity.Documents.Drawing;
using GrapeCity.Documents.Pdf;
using GrapeCity.Documents.Pdf.Structure;
using GrapeCity.Documents.Pdf.MarkedContent;
using GrapeCity.Documents.Pdf.Graphics;
using GrapeCity.Documents.Pdf.Annotations;
using GCTEXT = GrapeCity.Documents.Text;
using GCDRAW = GrapeCity.Documents.Drawing;
namespace GcPdfWeb.Samples.Basics
{
// This sample shows how to create a PDF/A-3u compliant document.
public class PdfA
{
public void CreatePDF(Stream stream)
{
var doc = new GcPdfDocument();
var date = new DateTime(1961, 4, 12, 6, 7, 0, DateTimeKind.Utc);
// Mark the document as PDF/A-3u conformant:
doc.ConformanceLevel = PdfAConformanceLevel.PdfA3u;
var fnt = GCTEXT.Font.FromFile(Path.Combine("Resources", "Fonts", "arial.ttf"));
var gap = 36;
// PDF/A-3a requires all content to be tagged so create and populate StructElement when rendering:
StructElement sePart = new StructElement("Part");
doc.StructTreeRoot.Children.Add(sePart);
TextLayout tl = null;
// Add 3 pages with sample content tagged according to PDF/A rules:
for (int pageNo = 1; pageNo <= 3; ++pageNo)
{
// add page
var page = doc.Pages.Add();
var g = page.Graphics;
float y = 72;
if (doc.Pages.Count == 1)
{
// Create paragraph element:
var seParagraph = new StructElement("P") { DefaultPage = page };
// Add it to Part element:
sePart.Children.Add(seParagraph);
tl = g.CreateTextLayout();
tl.MarginAll = 72;
tl.MaxWidth = page.Size.Width;
tl.DefaultFormat.Font = fnt;
tl.DefaultFormat.FontBold = true;
tl.DefaultFormat.FontSize = 20;
tl.Append("PDF/A-3A Document");
// PerformLayout is done automatically in a new TextLayout or after a Clear():
//tl.PerformLayout(true);
// Draw TextLayout within tagged content:
g.BeginMarkedContent(new TagMcid("P", 0));
g.DrawTextLayout(tl, PointF.Empty);
g.EndMarkedContent();
y = tl.ContentRectangle.Bottom + gap;
seParagraph.ContentItems.Add(new McidContentItemLink(0));
}
// Add some sample paragraphs tagged according to PDF/A rules:
for (int i = 1; i <= 3; ++i)
{
// Create paragraph element:
var seParagraph = new StructElement("P") { DefaultPage = page };
// Add it to Part element:
sePart.Children.Add(seParagraph);
var sb = new StringBuilder();
sb.Append(string.Format("Paragraph {0} on page {1}: ", i, pageNo));
sb.Append(Common.Util.LoremIpsum(1, 2, 4, 5, 10));
var para = sb.ToString();
tl.Clear();
tl.DefaultFormat.FontSize = 14;
tl.DefaultFormat.FontBold = false;
tl.MarginTop = y;
tl.Append(para);
// Draw TextLayout within tagged content:
g.BeginMarkedContent(new TagMcid("P", i));
g.DrawTextLayout(tl, PointF.Empty);
g.EndMarkedContent();
y += tl.ContentHeight + gap;
// Add content item to paragraph StructElement:
seParagraph.ContentItems.Add(new McidContentItemLink(i));
// PDF/A-3 allows embedding files into document, but they should be associated with some document element
// add embedded file associated with seParagraph:
var ef1 = EmbeddedFileStream.FromBytes(doc, Encoding.UTF8.GetBytes(para));
// ModificationDate and MimeType should be specified in case of PDF/A:
ef1.ModificationDate = date;
ef1.MimeType = "text/plain";
var fn = string.Format("Page{0}_Paragraph{1}.txt", pageNo, i);
var fs1 = FileSpecification.FromEmbeddedStream(fn, ef1);
// UnicodeFile.FileName should be specified for PDF/A compliance:
fs1.UnicodeFile.FileName = fs1.File.FileName;
// Relationship should be specified in case of PDF/A:
fs1.Relationship = AFRelationship.Unspecified;
doc.EmbeddedFiles.Add(fn, fs1);
seParagraph.AssociatedFiles.Add(fs1);
}
}
// PDF/A-3 allows transparency drawing in PDF file, add some:
var gpage = doc.Pages [0].Graphics;
gpage.FillRectangle(new RectangleF(20, 20, 200, 200), Color.FromArgb(40, Color.Red));
// PDF/A-3 allows using FormXObjects, add one with transparency:
var r = new RectangleF(0, 0, 144, 72);
var fxo = new FormXObject(doc, r);
var gfxo = fxo.Graphics;
gfxo.FillRectangle(r, Color.FromArgb(40, Color.Violet));
TextFormat tf = new TextFormat()
{
Font = fnt,
FontSize = 16,
ForeColor = Color.FromArgb(100, Color.Black),
};
gfxo.DrawString("FormXObject", tf, r, TextAlignment.Center, ParagraphAlignment.Center);
gfxo.DrawRectangle(r, Color.Blue, 3);
gpage.DrawForm(fxo, new RectangleF(300, 250, r.Width, r.Height), null, ImageAlign.ScaleImage);
// PDF/A-3 allows using embedded files, but each embedded file must be associated with a document's element:
EmbeddedFileStream ef = EmbeddedFileStream.FromFile(doc, Path.Combine("Resources", "WordDocs", "ProcurementLetter.docx"));
// ModificationDate and MimeType should be specified for EmbeddedFile in PDF/A:
ef.ModificationDate = date;
ef.MimeType = "application/msword";
var fs = FileSpecification.FromEmbeddedFile(ef);
fs.UnicodeFile.FileName = fs.File.FileName;
fs.Relationship = AFRelationship.Unspecified;
doc.EmbeddedFiles.Add("ProcurementLetter.docx", fs);
// Associate embedded file with the document:
doc.AssociatedFiles.Add(fs);
// Add an attachment associated with an annotation:
var sa = new StampAnnotation()
{
UserName = "Minerva",
Font = fnt,
Rect = new RectangleF(300, 36, 220, 72),
};
sa.Flags
= AnnotationFlags.Print;
// Use a FormXObject to represent the stamp annotation:
var stampFxo = new FormXObject(doc, new RectangleF(PointF.Empty, sa.Rect.Size));
var gstampFxo = stampFxo.Graphics;
gstampFxo.FillRectangle(stampFxo.Bounds, Color.FromArgb(40, Color.Green));
gstampFxo.DrawString("Stamp Annotation\nassociated with minerva.jpg", tf, stampFxo.Bounds, TextAlignment.Center, ParagraphAlignment.Center);
gstampFxo.DrawRectangle(stampFxo.Bounds, Color.Green, 3);
//
sa.AppearanceStreams.Normal.Default = stampFxo;
doc.Pages [0].Annotations.Add(sa);
ef = EmbeddedFileStream.FromFile(doc, Path.Combine("Resources", "Images", "minerva.jpg"));
ef.ModificationDate = date;
ef.MimeType = "image/jpeg";
fs = FileSpecification.FromEmbeddedFile(ef);
fs.UnicodeFile.FileName = fs.File.FileName;
fs.Relationship = AFRelationship.Unspecified;
doc.EmbeddedFiles.Add("minerva.jpg", fs);
sa.AssociatedFiles.Add(fs);
// Mark the document as conforming to Tagged PDF conventions (required for PDF/A):
doc.MarkInfo.Marked = true;
// Metadata.CreatorTool and DocumentInfo.Creator should be the same for a PDF/A document:
doc.Metadata.CreatorTool = doc.DocumentInfo.Creator;
// A title should be specified for PDF/A document:
doc.Metadata.Title = "GcPdf Document";
doc.ViewerPreferences.DisplayDocTitle = true;
// Done:
doc.Save(stream);
}
}
}
using System;
using System.IO;
using System.Drawing;
using System.Text;
using GrapeCity.Documents.Text;
using GrapeCity.Documents.Common;
using GrapeCity.Documents.Drawing;
using GrapeCity.Documents.Pdf;
using GrapeCity.Documents.Pdf.Structure;
using GrapeCity.Documents.Pdf.MarkedContent;
using GrapeCity.Documents.Pdf.Graphics;
using GrapeCity.Documents.Pdf.Annotations;
using GCTEXT = GrapeCity.Documents.Text;
using GCDRAW = GrapeCity.Documents.Drawing;
namespace GcPdfWeb.Samples.Basics
{
// This sample shows how to create a PDF/A-3u compliant document.
public class PdfA
{
public void CreatePDF(Stream stream)
{
var doc = new GcPdfDocument();
var date = new DateTime(1961, 4, 12, 6, 7, 0, DateTimeKind.Utc);
// Mark the document as PDF/A-3u conformant:
doc.ConformanceLevel = PdfAConformanceLevel.PdfA3u;
var fnt = GCTEXT.Font.FromFile(Path.Combine("Resources", "Fonts", "arial.ttf"));
var gap = 36;
// PDF/A-3a requires all content to be tagged so create and populate StructElement when rendering:
StructElement sePart = new StructElement("Part");
doc.StructTreeRoot.Children.Add(sePart);
TextLayout tl = null;
// Add 3 pages with sample content tagged according to PDF/A rules:
for (int pageNo = 1; pageNo <= 3; ++pageNo)
{
// add page
var page = doc.Pages.Add();
var g = page.Graphics;
float y = 72;
if (doc.Pages.Count == 1)
{
// Create paragraph element:
var seParagraph = new StructElement("P") { DefaultPage = page };
// Add it to Part element:
sePart.Children.Add(seParagraph);
tl = g.CreateTextLayout();
tl.MarginAll = 72;
tl.MaxWidth = page.Size.Width;
tl.DefaultFormat.Font = fnt;
tl.DefaultFormat.FontBold = true;
tl.DefaultFormat.FontSize = 20;
tl.Append("PDF/A-3A Document");
// PerformLayout is done automatically in a new TextLayout or after a Clear():
//tl.PerformLayout(true);
// Draw TextLayout within tagged content:
g.BeginMarkedContent(new TagMcid("P", 0));
g.DrawTextLayout(tl, PointF.Empty);
g.EndMarkedContent();
y = tl.ContentRectangle.Bottom + gap;
seParagraph.ContentItems.Add(new McidContentItemLink(0));
}
// Add some sample paragraphs tagged according to PDF/A rules:
for (int i = 1; i <= 3; ++i)
{
// Create paragraph element:
var seParagraph = new StructElement("P") { DefaultPage = page };
// Add it to Part element:
sePart.Children.Add(seParagraph);
var sb = new StringBuilder();
sb.Append(string.Format("Paragraph {0} on page {1}: ", i, pageNo));
sb.Append(Common.Util.LoremIpsum(1, 2, 4, 5, 10));
var para = sb.ToString();
tl.Clear();
tl.DefaultFormat.FontSize = 14;
tl.DefaultFormat.FontBold = false;
tl.MarginTop = y;
tl.Append(para);
// Draw TextLayout within tagged content:
g.BeginMarkedContent(new TagMcid("P", i));
g.DrawTextLayout(tl, PointF.Empty);
g.EndMarkedContent();
y += tl.ContentHeight + gap;
// Add content item to paragraph StructElement:
seParagraph.ContentItems.Add(new McidContentItemLink(i));
// PDF/A-3 allows embedding files into document, but they should be associated with some document element
// add embedded file associated with seParagraph:
var ef1 = EmbeddedFileStream.FromBytes(doc, Encoding.UTF8.GetBytes(para));
// ModificationDate and MimeType should be specified in case of PDF/A:
ef1.ModificationDate = date;
ef1.MimeType = "text/plain";
var fn = string.Format("Page{0}_Paragraph{1}.txt", pageNo, i);
var fs1 = FileSpecification.FromEmbeddedStream(fn, ef1);
// UnicodeFile.FileName should be specified for PDF/A compliance:
fs1.UnicodeFile.FileName = fs1.File.FileName;
// Relationship should be specified in case of PDF/A:
fs1.Relationship = AFRelationship.Unspecified;
doc.EmbeddedFiles.Add(fn, fs1);
seParagraph.AssociatedFiles.Add(fs1);
}
}
// PDF/A-3 allows transparency drawing in PDF file, add some:
var gpage = doc.Pages [0].Graphics;
gpage.FillRectangle(new RectangleF(20, 20, 200, 200), Color.FromArgb(40, Color.Red));
// PDF/A-3 allows using FormXObjects, add one with transparency:
var r = new RectangleF(0, 0, 144, 72);
var fxo = new FormXObject(doc, r);
var gfxo = fxo.Graphics;
gfxo.FillRectangle(r, Color.FromArgb(40, Color.Violet));
TextFormat tf = new TextFormat()
{
Font = fnt,
FontSize = 16,
ForeColor = Color.FromArgb(100, Color.Black),
};
gfxo.DrawString("FormXObject", tf, r, TextAlignment.Center, ParagraphAlignment.Center);
gfxo.DrawRectangle(r, Color.Blue, 3);
gpage.DrawForm(fxo, new RectangleF(300, 250, r.Width, r.Height), null, ImageAlign.ScaleImage);
// PDF/A-3 allows using embedded files, but each embedded file must be associated with a document's element:
EmbeddedFileStream ef = EmbeddedFileStream.FromFile(doc, Path.Combine("Resources", "WordDocs", "ProcurementLetter.docx"));
// ModificationDate and MimeType should be specified for EmbeddedFile in PDF/A:
ef.ModificationDate = date;
ef.MimeType = "application/msword";
var fs = FileSpecification.FromEmbeddedFile(ef);
fs.UnicodeFile.FileName = fs.File.FileName;
fs.Relationship = AFRelationship.Unspecified;
doc.EmbeddedFiles.Add("ProcurementLetter.docx", fs);
// Associate embedded file with the document:
doc.AssociatedFiles.Add(fs);
// Add an attachment associated with an annotation:
var sa = new StampAnnotation()
{
UserName = "Minerva",
Font = fnt,
Rect = new RectangleF(300, 36, 220, 72),
};
sa.Flags
= AnnotationFlags.Print;
// Use a FormXObject to represent the stamp annotation:
var stampFxo = new FormXObject(doc, new RectangleF(PointF.Empty, sa.Rect.Size));
var gstampFxo = stampFxo.Graphics;
gstampFxo.FillRectangle(stampFxo.Bounds, Color.FromArgb(40, Color.Green));
gstampFxo.DrawString("Stamp Annotation\nassociated with minerva.jpg", tf, stampFxo.Bounds, TextAlignment.Center, ParagraphAlignment.Center);
gstampFxo.DrawRectangle(stampFxo.Bounds, Color.Green, 3);
//
sa.AppearanceStreams.Normal.Default = stampFxo;
doc.Pages [0].Annotations.Add(sa);
ef = EmbeddedFileStream.FromFile(doc, Path.Combine("Resources", "Images", "minerva.jpg"));
ef.ModificationDate = date;
ef.MimeType = "image/jpeg";
fs = FileSpecification.FromEmbeddedFile(ef);
fs.UnicodeFile.FileName = fs.File.FileName;
fs.Relationship = AFRelationship.Unspecified;
doc.EmbeddedFiles.Add("minerva.jpg", fs);
sa.AssociatedFiles.Add(fs);
// Mark the document as conforming to Tagged PDF conventions (required for PDF/A):
doc.MarkInfo.Marked = true;
// Metadata.CreatorTool and DocumentInfo.Creator should be the same for a PDF/A document:
doc.Metadata.CreatorTool = doc.DocumentInfo.Creator;
// A title should be specified for PDF/A document:
doc.Metadata.Title = "GcPdf Document";
doc.ViewerPreferences.DisplayDocTitle = true;
// Done:
doc.Save(stream);
}
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
GrapeCityPDF ist keine fortgeschrittene Bibliothek für PDF-Dateien - im Vergleich zu IronPDF verfügt sie über eine begrenzte Anzahl von Funktionen.
Die 30-Tage-Geld-zurück-Garantie: Sobald Sie die Lizenz erworben haben, erhalten Sie eine 30-tägige Geld-zurück-Garantie. Sollte die Lizenz nicht Ihren Anforderungen entsprechen, garantiert Ihnen IronPDF die Rückerstattung Ihres Geldes innerhalb von 30 Tagen.
Einfache Integration: Die Integration von IronPDF in ein laufendes Projekt und Ihre Umgebung ist ein nahtloser Prozess, der mit einer einzigen Codezeile abgeschlossen wird. Dies kann bei der Integration mit der NuGet-Paket-Methode erreicht werden oder direkt online heruntergeladen und in Ihre Umgebung integriert werden.
Dauerlizenzierung: Jede Lizenz wird nur einmal erworben und muss nicht erneuert werden.
Kostenloser Support und Produkt-Updates: Jede Lizenz beinhaltet einen Rund-um-die-Uhr-Support direkt durch das Team, das hinter dem Produkt steht, sowie ein Jahr lang kostenlose Produkt-Updates. Es ist jederzeit möglich, Erweiterungen zu kaufen. Die Erweiterungen können vor dem Kauf besichtigt werden.
Sofortige Lizenzen: Sobald die Zahlung eingegangen ist, werden registrierte Lizenzschlüssel verschickt.
Alle Lizenzen sind unbefristet und gelten für Staging, Entwicklung und Produktion.
Unbefristete Lizenz
Dieses Paket ermöglicht es einem einzelnen Softwareentwickler in einem Unternehmen, Iron Software an einem Ort zu nutzen. Iron Software kann in einer einzelnen Intranetanwendung, einer Webanwendung oder einem Desktop-Softwareprogramm eingesetzt werden. Es ist verboten, Lizenzen außerhalb einer Organisation oder einer Agentur/Kundenbeziehung weiterzugeben, da sie nicht übertragbar sind. Dieser Lizenztyp, wie auch alle anderen Lizenztypen, schließt ausdrücklich alle Rechte aus, die nicht ausdrücklich im Rahmen der Vereinbarung gewährt werden, ohne OEM-Weitergabe und Nutzung der Iron Software als SaaS ohne den Erwerb einer zusätzlichen Abdeckung.
Preisgestaltung: ab $749 pro Jahr.
Unbefristete Lizenz
Diese Lizenz erlaubt es einer bestimmten Anzahl von Softwareentwicklern in einem Unternehmen, Iron Software an zahlreichen Standorten zu nutzen, maximal jedoch zehn. Iron Software kann in beliebig vielen Websites, Intranetanwendungen oder Desktop-Softwareanwendungen verwendet werden. Lizenzen sind nicht übertragbar, daher ist die Weitergabe außerhalb einer Organisation oder einer Agentur-/Kundenbeziehung verboten. Dieser Lizenztyp, wie auch alle anderen Lizenztypen, schließt ausdrücklich alle Rechte aus, die nicht ausdrücklich im Rahmen der Vereinbarung gewährt werden, einschließlich der OEM-Weitergabe und der Nutzung der Iron Software als SaaS ohne Erwerb einer zusätzlichen Abdeckung. Diese Lizenz kann in ein einzelnes Projekt integriert werden, bis zu einer Höchstzahl von 10.
Preisgestaltung: Ab $999 pro Jahr.
Unbefristete Lizenz
Dies ermöglicht es Ihnen, eine unbegrenzte Anzahl von Softwareentwicklern in einer einzigen Organisation zu haben, die Iron Software an einer unbegrenzten Anzahl von Standorten einsetzen können. Iron Software kann in beliebig vielen Intranetanwendungen, Desktop-Softwareanwendungen oder Websites verwendet werden. Die Lizenzen sind nicht übertragbar und können nicht außerhalb einer Organisation oder einer Agentur-/Kundenbeziehung weitergegeben werden. Dieser Lizenztyp, wie auch alle anderen Lizenztypen, schließt ausdrücklich alle Rechte aus, die nicht im Rahmen der Vereinbarung gewährt werden, einschließlich der OEM-Weitergabe und der Nutzung der Iron Software als SaaS ohne Erwerb einer zusätzlichen Abdeckung.
Preisgestaltung: Beginnt bei $2999 pro Jahr.
Lizenzfreie Weitergabe: Dies erlaubt Ihnen, die Iron Software als Teil verschiedener kommerzieller Produkte zu vertreiben(ohne Lizenzgebühren zahlen zu müssen) basierend auf der Anzahl der Projekte, die von der Basislizenz abgedeckt werden. Dies ermöglicht die Bereitstellung von Iron Software im Rahmen von SaaS-Softwarediensten, die auf der Anzahl der von der Basislizenz abgedeckten Projekte basiert.
Preisgestaltung: Beginnt bei $1599 pro Jahr.
1 Vertriebsstandort
Dieses Paket enthält eine Entwicklerlizenz und nur einen Vertriebsstandort ohne Support und Wartung.
Preisgestaltung: Beginnt bei $999 pro Jahr.
Unbegrenzte Vertriebsstandorte
Dieses Paket enthält eine Entwicklerlizenz mit einer unbegrenzten Anzahl von Vertriebsstandorten. Support und Wartung sind nicht inbegriffen. GrapeCity unterstützt nicht die SaaS und OEM.
Preisgestaltung: Beginnt bei $2799 pro Jahr.
Unbegrenzte Vertriebsstandorte
Dieses Paket enthält fünf Entwicklerlizenzen mit unbegrenzten Vertriebsstandorten ohne Support und Wartung. GrapeCity unterstützt kein SaaS und OEM.
Preisgestaltung: Beginnt bei $5799 pro Jahr.
Das IronPDF Lite One-Developer-Paket wird mit 1 Jahr Support geliefert und kostet etwa $749. Während GrapeCity Documents for PDF, ein One-Developer-Paket enthält und $999 ohne Support kostet. Das IronPDF Professional Package, das das 10-Entwickler-Paket und ein Jahr Support beinhaltet, kostet $999. GrapeCity hingegen bietet kein 10-Entwickler-Paket an, sondern nur ein 5-Entwickler-Paket, das $5799 kostet.
Die IronPDF Lite- und Professional-Pakete bieten SaaS-Service oder OEM sowie eine 5-Jahres-Supportoption. Das Lite-Paket für einen Entwickler bietet fünf Jahre Support, SaaS und OEM-Services und kostet 2897 US-Dollar. GrapeCity bietet zwar kein SaaS, keinen OEM-Service und keine 5-Jahres-Supportoption an. Das Iron Professional 10-Entwicklerpaket umfasst 5 Jahre Support, Saas- und OEM-Services und kostet 3397 US-Dollar. GrapeCity hat zwar kein 10-Entwickler-Paket.
GrapeCity Documents for PDF ermöglicht Entwicklern den Export/Import, die Erstellung von AcroForms(PDF-Formulare)und PDFs in zahlreichen Desktop-Anwendungen ausführen. Mit GrapeCity Dokumente für PDF(GcPdf)sind Sie auf dem besten Weg, Ihren Kunden komplette PDF-Lösungen anzubieten.
Wir empfehlen IronPDF, da das Produkt eine höhere Genauigkeit bietet. Bei Mitbewerbern, die ähnliche Funktionen ausführen, kann es zu Ungenauigkeiten kommen, wie z. B. dass einige Bilder nicht konvertiert werden können, was zu unbekannten Zeichen führt. IronPDF hingegen liefert genaue Ergebnisse.
IronPDF-Pakete bieten eine wettbewerbsfähige Lizenzierung und Unterstützung ohne laufende Kosten. IronPDF beginnt bei $749 mit Paketen, die eine größere Bandbreite an Funktionen beinhalten. GrapeCity PDF kostet ab $1649 pro Jahr. IronPDF unterstützt auch mehrere Plattformen zu einem einzigen Preis!
Wenn Sie noch kein IronPDF-Kunde sind, können Sie die kostenlose Testversion nutzen, um alle verfügbaren Funktionen zu testen. Wenn Sie die komplette Iron Suite kaufen, erhalten Sie alle fünf Produkte zum Preis von zwei. Für weitere Einzelheiten zuIronPDF-Lizenzierungbesuchen Sie bitte die Website von Iron SoftwareIron Suite Produktseite um die vollständigen Informationen zum Paket einzusehen.
9 .NET API-Produkte für Ihre Bürodokumente