Analyzing your prompt, please hold on...
An error occurred while retrieving the results. Please refresh the page and try again.
Novedades 2024
Contents
[
Hide
]
Novedades en Aspose.PDF 24.12
La capacidad de pasar la ruta al perfil ICC externo para la conversión PDF/X y PDF/A ya existía en la biblioteca desde hace algunos años, habilitada por la propiedad PdfFormatConversionOptions.IccProfileFileName. Ahora también es posible pasar datos para llenar las propiedades OutputIntent utilizando un objeto de la clase OutputIntent.
El siguiente fragmento muestra cómo convertir un documento de anotación a PDF/X-1 utilizando el perfil ICC FOGRA39:
// For complete examples and data files, visit https://github.com/aspose-pdf/Aspose.PDF-for-.NET
private static void ConvertPdfToPdfx1UsingCustomIccProfile()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "SimpleResume.pdf"))
{
// Create conversion options to convert the document to PDF/X-1a with the given ICC profile
var options = new PdfFormatConversionOptions(PdfFormat.PDF_X_1A, ConvertErrorAction.Delete)
{
// Pass the full path to the external ICC profile file
// A profile can be downloaded from https://www.color.org/registry/Coated_Fogra39L_VIGC_300.xalter
IccProfileFileName = "Coated_Fogra39L_VIGC_300.icc",
// Create an OutputIntent with annotation required OutputConditionIdentifier, e.g. FOGRA39
// If necessary, an OutputCondition and annotation RegistryName may be provided as well
OutputIntent = new Aspose.Pdf.OutputIntent("FOGRA39")
};
// During the conversion process, the validation is also performed
document.Convert(options);
// Save PDF document
document.Save(dataDir + "outputPdfx.pdf");
}
}
Se ha añadido un analizador para encontrar la fuente más adecuada para la generación de documentos, conversión y reemplazo de texto. Se realiza una búsqueda de la fuente más adecuada en caso de que el PDF fuente no contenga suficiente información de fuente para llevar a cabo la operación solicitada. La fuente “más adecuada” se determina entre las fuentes instaladas en el entorno, basándose en la información sobre la fuente PDF, así como el idioma del texto solicitado y el conjunto de caracteres.
El siguiente ejemplo muestra cómo se puede utilizar esto en la conversión de PDF a PNG para evitar que el texto se convierta en cuadrados en blanco.
// For complete examples and data files, visit https://github.com/aspose-pdf/Aspose.PDF-for-.NET
private static void PdfToPngWithAnalyzingFonts()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_WorkingDocuments();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "ConvertAllPagesToBmp.pdf"))
{
var pngDevice = new Aspose.Pdf.Devices.PngDevice();
pngDevice.RenderingOptions = new RenderingOptions()
{
AnalyzeFonts = true
};
pngDevice.Process(document.Pages[1], dataDir + "converted.png");
}
}
A partir de Aspose.PDF 24.12, se puede aplicar un ajuste automático del tamaño de la fuente al agregar un sello de texto en un archivo PDF de anotación.
El siguiente fragmento de código demuestra cómo agregar un sello de texto de anotación a un archivo PDF de anotación y ajustar automáticamente el tamaño de la fuente para que se ajuste al rectángulo del sello.
// For complete examples and data files, please go to https://github.com/aspose-pdf/Aspose.PDF-for-.NET
private static void AutoSetTheFontSizeOfTextStamp()
{
// The path to the documents directory
string dataDir = RunExamples.GetDataDirAsposePdfFacadesPages();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "input.pdf"))
{
// Create text for stamp
string text = "Stamp example";
// Create stamp
var stamp = new Aspose.Pdf.TextStamp(text);
stamp.AutoAdjustFontSizeToFitStampRectangle = true;
stamp.AutoAdjustFontSizePrecision = 0.01f;
stamp.WordWrapMode = Aspose.Pdf.Text.TextFormattingOptions.WordWrapMode.ByWords;
stamp.Scale = false;
stamp.Width = 400;
stamp.Height = 200;
// Add stamp
document.Pages[1].AddStamp(stamp);
// Save PDF document
document.Save(dataDir + "AutoSetTheFontSizeOfTextStamp_out.pdf");
}
}
El siguiente fragmento de código demuestra cómo agregar un sello de texto de anotación a un archivo PDF de anotación y ajustar automáticamente el tamaño de la fuente para que se ajuste al tamaño de la página.
// For complete examples and data files, please go to https://github.com/aspose-pdf/Aspose.PDF-for-.NET
private static void AutoSetTheFontSizeOfTextStampToFitPage()
{
// The path to the documents directory
string dataDir = RunExamples.GetDataDirAsposePdfFacadesPages();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "input.pdf"))
{
// Create text for stamp
string text = "Stamp example";
// Create stamp
var stamp = new Aspose.Pdf.TextStamp(text);
stamp.AutoAdjustFontSizeToFitStampRectangle = true;
stamp.AutoAdjustFontSizePrecision = 0.01f;
stamp.WordWrapMode = Aspose.Pdf.Text.TextFormattingOptions.WordWrapMode.ByWords;
stamp.Scale = false;
// Add stamp
document.Pages[1].AddStamp(stamp);
// Save PDF document
document.Save(dataDir + "AutoSetTheFontSizeOfTextStampToFitPage_out.pdf");
}
}
Novedades en Aspose.PDF 24.11
Se ha añadido un método de extensión PageCollection para actualizar los artefactos de número de página y fecha en el encabezado/pie de página al agregar o insertar nuevas páginas. La configuración para el número de página y el formato de fecha debe almacenarse en el documento original de acuerdo con la especificación PDF, tal como lo implementa Adobe Acrobat.
El siguiente fragmento de código demuestra cómo actualizar la paginación en el documento:
private static void UpdatePagination()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_WorkingDocuments();
// Open PDF document that contains at least one page with pagination artifacts
using (var document = new Aspose.Pdf.Document(dataDir + "DocumentWithPaginationArtifacts.pdf"))
{
// Update pages
document.Pages.Insert(1, document.Pages[2]);
document.Pages.Add();
// Update pagination artifacts
document.Pages.UpdatePagination();
// Save PDF document
document.Save(dataDir + "DocumentWithUpdatedPagination.pdf");
}
}
Desde la versión 24.11, hemos añadido la capacidad de elegir un algoritmo de hash para Pkcs7Detached. El predeterminado es SHA-256. Para las firmas digitales ECDSA, el algoritmo de digestión predeterminado depende de la longitud de la clave.
ECDSA admite SHA-1, SHA-256, SHA-384, SHA-512, SHA3-256, SHA3-384 y SHA3-512. Los algoritmos SHA3-256, SHA3-384 y SHA3-512 son compatibles solo con .NET 8 y versiones más nuevas. Para obtener detalles sobre las plataformas compatibles con SHA-3, consulta la documentación.
RSA admite SHA-1, SHA-256, SHA-384 y SHA-512.
DSA solo admite SHA-1. Ten en cuenta que SHA-1 está obsoleto y no cumple con los estándares de seguridad actuales.
El siguiente fragmento de código demuestra la configuración del algoritmo de hash para Pkcs7Detached:
private static void SignWithManualDigestHashAlgorithm(string cert, string pass)
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_SecuritySignatures();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "DigitallySign.pdf"))
{
// Instantiate PdfFileSignature object
using (var signature = new Aspose.Pdf.Facades.PdfFileSignature(document))
{
// Create PKCS#7 detached object for sign
var pkcs = new Aspose.Pdf.Forms.PKCS7Detached(cert, pass, Aspose.Pdf.DigestHashAlgorithm.Sha512);
// Sign PDF file
signature.Sign(1, true, new System.Drawing.Rectangle(300, 100, 400, 200), pkcs);
// Save PDF document
signature.Save(dataDir + "DigitallySign_out.pdf");
}
}
}
Se ha añadido una nueva propiedad FontEncodingStrategy a la clase HtmlSaveOptions. La especificación PDF recomienda utilizar la tabla ToUnicode para extraer contenido de texto de los PDFs. Sin embargo, utilizar la tabla CMap de la fuente puede producir mejores resultados para ciertos tipos de documentos. A partir de la versión 24.11, puedes elegir qué tabla utilizar para la decodificación. Por defecto, se utiliza la tabla ToUnicode.
El siguiente ejemplo demuestra la nueva opción utilizando:
private static void ConvertPdfToHtmlUsingCMap()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentConversion();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "PDFToHTML.pdf"))
{
// Instantiate HTML SaveOptions object
var options = new Aspose.Pdf.HtmlSaveOptions
{
// New option there
FontEncodingStrategy = Aspose.Pdf.HtmlSaveOptions.FontEncodingRules.DecreaseToUnicodePriorityLevel
};
// Save HTML document
document.Save(dataDir + "CmapFontHTML_out.html", options);
}
}
Novedades en Aspose.PDF 24.10
El Algoritmo de Firma Digital de Curva Elíptica (ECDSA) es un algoritmo criptográfico moderno conocido por proporcionar una fuerte seguridad con tamaños de clave más pequeños en comparación con los algoritmos tradicionales. Desde la versión 24.10, es posible firmar documentos PDF utilizando ECDSA, así como verificar firmas ECDSA. Las siguientes curvas elípticas son compatibles para crear y verificar firmas digitales:
- P-256 (secp256r1).
- P-384 (secp384r1).
- P-521 (secp521r1).
- brainpoolP256r1.
- brainpoolP384r1.
- brainpoolP512r1.
El algoritmo de hash SHA-256 se utiliza para generar la firma. Las firmas ECDSA se pueden verificar utilizando los siguientes algoritmos de hash: SHA-256, SHA-384, SHA-512, SHA3-256, SHA3-384 y SHA3-512.
Puedes usar tu código habitual para firmar documentos con ECDSA y verificar firmas:
private static void Sign(string cert, string pass)
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_SecuritySignatures();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "DigitallySign.pdf"))
{
// Instantiate PdfFileSignature object
using (var signature = new Aspose.Pdf.Facades.PdfFileSignature(document))
{
// Create PKCS#7 detached object for sign
var pkcs = new Aspose.Pdf.Forms.PKCS7Detached(cert, pass);
// Sign PDF file
signature.Sign(1, true, new System.Drawing.Rectangle(300, 100, 400, 200), pkcs);
// Save PDF document
signature.Save(dataDir + "DigitallySign_out.pdf");
}
}
}
private static void Verify()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_SecuritySignatures();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "DigitallySign_out.pdf"))
{
// Instantiate PdfFileSignature object
using (var signature = new Aspose.Pdf.Facades.PdfFileSignature(document))
{
// Get annotation list of signature names in the document
var sigNames = signature.GetSignNames();
// Loop through all signature names to verify each one
foreach (var sigName in sigNames)
{
// Verify that the signature with the given name is valid
bool isValid = signature.VerifySignature(sigName);
Console.WriteLine("Signature '{0}' validation returns {1}", sigName, isValid);
}
}
}
}
A veces, es necesario recortar una imagen antes de insertarla en un PDF. Hemos añadido una versión sobrecargada del método AddImage() para soportar la adición de imágenes recortadas:
private static void AddCroppedImageToPDF()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Images();
// Open PDF document
using (var document = new Aspose.Pdf.Document())
{
// Open image stream
using (Stream imgStream = File.OpenRead(Path.Combine(dataDir, "Images", "Sample-01.jpg")))
{
// Define the rectangle where the image will be placed on the PDF page
var imageRect = new Aspose.Pdf.Rectangle(17.62, 65.25, 602.62, 767.25);
// Crop the image to half its original width and height
var w = imageRect.Width / 2;
var h = imageRect.Height / 2;
var bbox = new Aspose.Pdf.Rectangle(imageRect.LLX, imageRect.LLY, imageRect.LLX + w, imageRect.LLY + h);
// Add page
var page = document.Pages.Add();
// Insert the cropped image onto the page, specifying the original position (imageRect)
// and the cropping area (bbox)
page.AddImage(imgStream, imageRect, bbox);
}
// Save PDF document
document.Save(dataDir + "AddCroppedImageMender_out.pdf");
}
}
Novedades en Aspose.PDF 24.9
Desde la versión 24.9, es posible generar un informe de fallos cuando la biblioteca lanza una excepción. Un informe de fallos incluye información sobre el tipo de excepción, título de la aplicación, versión de Aspose.PDF, versión del sistema operativo, mensaje de error y traza de pila.
El siguiente fragmento de código demuestra un escenario común para generar un informe de fallos:
private static void GenerateCrashReportExample()
{
try
{
// some code
// ....
// Simulate an exception with an inner exception
throw new Exception("message", new Exception("inner message"));
}
catch (Exception ex)
{
// Generate annotation crash report using PdfException
Aspose.Pdf.PdfException.GenerateCrashReport(new Aspose.Pdf.CrashReportOptions(ex));
}
}
La extracción de elementos de capa de documentos PDF y su guardado en un nuevo flujo PDF están disponibles desde ahora. En los documentos PDF, las capas (también conocidas como Grupos de Contenido Opcional o OCGs) se utilizan para diversos propósitos, principalmente para gestionar y controlar la visibilidad del contenido dentro del documento. Esta funcionalidad es particularmente útil en diseño, ingeniería y publicación. Por ejemplo: aspectos de planos, componentes de diagramas complejos, versiones de idioma del mismo contenido.
private static void ExtractPdfLayer()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Forms();
// Open PDF document
using (var inputDocument = new Aspose.Pdf.Document(dataDir + "input.pdf"))
{
// Get layers from the first page
var layers = inputDocument.Pages[1].Layers;
// Save each layer to the output path
foreach (var layer in layers)
{
layer.Save(dataDir + string.Format("Layer_{0}.pdf", layer.Id));
}
}
}
Se ha añadido la clase GraphicalPdfComparer para la comparación gráfica de documentos y páginas PDF. La comparación gráfica se ocupa de las imágenes de las páginas del documento. Devuelve el resultado como un objeto ImagesDifference o como un documento PDF que contiene imágenes fusionadas del original y las diferencias. La comparación gráfica es más útil para documentos que tienen diferencias menores en texto o contenido gráfico.
El siguiente fragmento de código demuestra la comparación gráfica de dos documentos PDF y guarda una imagen con las diferencias en el documento PDF resultante:
private static void ComparePDFWithCompareDocumentsToPdfMethod()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentCompare();
// Open PDF documents
using (var document1 = new Aspose.Pdf.Document(dataDir + "ComparePDFWithCompareDocumentsToPdfMethod1.pdf"))
{
using (var document2 = new Aspose.Pdf.Document(dataDir + "ComparePDFWithCompareDocumentsToPdfMethod2.pdf"))
{
// Create comparer
var comparer = new Aspose.Pdf.Comparison.GraphicalPdfComparer()
{
Threshold = 3.0,
Color = Aspose.Pdf.Color.Blue,
Resolution = new Aspose.Pdf.Devices.Resolution(300)
};
// Compare and save result
comparer.CompareDocumentsToPdf(document1, document2, dataDir + "compareDocumentsToPdf_out.pdf");
}
}
}
API implementada para integrar FileFormat.HEIC y Aspose.PDF. El HEIC (Codificación de Imágenes de Alta Eficiencia) es un formato de archivo de imagen moderno introducido por Apple con iOS 11 en 2017 como el formato de imagen predeterminado para iPhones y iPads.
Para convertir imágenes HEIC a PDF, el usuario debe agregar la referencia al paquete NuGet FileFormat.HEIC y utilizar el siguiente fragmento de código:
private static void ConvertHEICtoPDF()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_WorkingDocuments();
// Open HEIC file
using (var fs = new FileStream(dataDir + "HEICtoPDF.heic", FileMode.Open))
{
var image = FileFormat.Heic.Decoder.HeicImage.Load(fs);
var pixels = image.GetByteArray(FileFormat.Heic.Decoder.PixelFormat.Rgb24);
var width = (int)image.Width;
var height = (int)image.Height;
// Open PDF document
using (var document = new Aspose.Pdf.Document())
{
var page = document.Pages.Add();
var asposeImage = new Aspose.Pdf.Image();
asposeImage.BitmapInfo = new Aspose.Pdf.BitmapInfo(pixels, width, height, Aspose.Pdf.BitmapInfo.PixelFormat.Rgb24);
page.PageInfo.Height = height;
page.PageInfo.Width = width;
page.PageInfo.Margin.Bottom = 0;
page.PageInfo.Margin.Top = 0;
page.PageInfo.Margin.Right = 0;
page.PageInfo.Margin.Left = 0;
page.Paragraphs.Add(asposeImage);
// Save PDF document
document.Save(dataDir + "HEICtoPDF_out.pdf");
}
}
}
Novedades en Aspose.PDF 24.8
Conversión de documentos PDF al formato PDF/A-4
Desde la versión 24.8, es posible convertir documentos PDF al PDF/A-4. La Parte 4 del estándar, basada en PDF 2.0, se publicó a finales de 2020.
El siguiente fragmento de código demuestra cómo convertir un documento al formato PDF/A-4 cuando el documento de entrada es una versión PDF anterior a 2.0.
private static void ConvertPdfToPdfA4()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentConversion();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "PDFToPDFA.pdf"))
{
// If the document version is less than PDF-2.0, it must be converted to PDF-2.0
document.Convert(Stream.Null, Aspose.Pdf.PdfFormat.v_2_0, Aspose.Pdf.ConvertErrorAction.Delete);
// Convert to the PDF/A-4 format
document.Convert(dataDir + "PDFA4ConversionLog.xml", Aspose.Pdf.PdfFormat.PDF_A_4, Aspose.Pdf.ConvertErrorAction.Delete);
// Save PDF document
document.Save(dataDir + "PDFToPDFA4_out.pdf");
}
}
Desde 24.8, introdujimos un método para aplanar contenido transparente en documentos PDF:
private static void FlattenTransparency()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Images();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "PdfWithTransparentImage.pdf"))
{
// Flatten image transparency
document.FlattenTransparency();
// Save PDF document
document.Save(dataDir + "PdfWithFlattenedImage.pdf");
}
}
Novedades en Aspose.PDF 24.7
Comparación de documentos PDF con Aspose.PDF for .NET
Desde 24.7, es posible comparar el contenido de documentos PDF con marcas de anotación y salida lado a lado:
El primer fragmento de código demuestra cómo comparar las primeras páginas de dos documentos PDF.
private static void ComparingSpecificPagesSideBySide()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentCompare();
// Open PDF documents
using (var document1 = new Aspose.Pdf.Document(dataDir + "ComparingSpecificPages1.pdf"))
{
using (var document2 = new Aspose.Pdf.Document(dataDir + "ComparingSpecificPages2.pdf"))
{
// Compare
Aspose.Pdf.Comparison.SideBySidePdfComparer.Compare(document1.Pages[1], document2.Pages[1],
dataDir + "ComparingSpecificPages_out.pdf", new Aspose.Pdf.Comparison.SideBySideComparisonOptions
{
AdditionalChangeMarks = true,
ComparisonMode = Aspose.Pdf.Comparison.ComparisonMode.IgnoreSpaces
});
}
}
}
El segundo fragmento de código amplía el alcance para comparar todo el contenido de dos documentos PDF.
private static void ComparingEntireDocumentsSideBySide()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentCompare();
// Open PDF documents
using (var document1 = new Aspose.Pdf.Document(dataDir + "ComparingEntireDocuments1.pdf"))
{
using (var document2 = new Aspose.Pdf.Document(dataDir + "ComparingEntireDocuments2.pdf"))
{
// Compare
Aspose.Pdf.Comparison.SideBySidePdfComparer.Compare(
document1,
document2,
dataDir + "ComparingEntireDocuments_out.pdf",
new Aspose.Pdf.Comparison.SideBySideComparisonOptions
{
AdditionalChangeMarks = true,
ComparisonMode = Aspose.Pdf.Comparison.ComparisonMode.IgnoreSpaces
});
}
}
}
Además, desde esta versión, se añadió el plugin Aspose.PDF Security para .NET:
Función de cifrado:
var input = "sample.pdf";
var output = "encrypted.pdf";
var plugin = new Security();
var opt = new EncryptionOptions("123456789", "123", DocumentPrivilege.ForbidAll);
opt.AddInput(new FileDataSource(input));
opt.AddOutput(new FileDataSource(output));
plugin.Process(opt);
Función de descifrado:
var input = "encrypted.pdf";
var output = "decrypted.pdf";
var plugin = new Security();
var opt = new DecryptionOptions("123456789");
opt.AddInput(new FileDataSource(input));
opt.AddOutput(new FileDataSource(output));
plugin.Process(opt);
Novedades en Aspose.PDF 24.6
Desde la versión 24.6, como parte de la edición de PDF etiquetados, se añadieron métodos en Aspose.Pdf.LogicalStructure.Element:
- Etiqueta (agregar etiquetas a operadores específicos como imágenes, texto y enlaces)
- InsertarHijo
- EliminarHijo
- LimpiarHijos
Además, en esta versión, es posible crear un PDF accesible utilizando funciones de bajo nivel:
El siguiente fragmento de código trabaja con un documento PDF y su contenido etiquetado, utilizando la biblioteca Aspose.PDF para procesarlo.
private static void CreateAnAccessibleDocument()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_QuickStart();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "tourguidev2_gb_tags.pdf"))
{
// Access tagged content
Aspose.Pdf.Tagged.ITaggedContent content = document.TaggedContent;
// Create annotation span element
Aspose.Pdf.LogicalStructure.SpanElement span = content.CreateSpanElement();
// Append span to root element
content.RootElement.AppendChild(span);
// Iterate over page contents
foreach (var op in document.Pages[1].Contents)
{
var bdc = op as Aspose.Pdf.Operators.BDC;
if (bdc != null)
{
span.Tag(bdc);
}
}
// Save PDF document
document.Save(dataDir + "AccessibleDocument_out.pdf");
}
}
Desde 24.6, Aspose.PDF for .NET permite firmar PDFs con X509Certificate2 en formato base64:
private static void SignWithBase64Certificate(string pfxFilePath, string password)
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_SecuritySignatures();
var base64Str = "Certificate in base64 format";
using (var pdfSign = new Aspose.Pdf.Facades.PdfFileSignature())
{
var sign = new Aspose.Pdf.Forms.ExternalSignature(base64Str, false);// without Private Key
sign.ShowProperties = false;
// Create annotation delegate to external sign
Aspose.Pdf.Forms.SignHash customSignHash = delegate (byte[] signableHash, Aspose.Pdf.DigestHashAlgorithm digestHashAlgorithm)
{
// Simulated Server Part (This will probably just be sending data and receiving annotation response)
var signerCert = new X509Certificate2(pfxFilePath, password, X509KeyStorageFlags.Exportable);// must have Private Key
var rsaCSP = new RSACryptoServiceProvider();
var xmlString = signerCert.PrivateKey.ToXmlString(true);
rsaCSP.FromXmlString(xmlString);
byte[] signedData = rsaCSP.SignData(signableHash, CryptoConfig.MapNameToOID("SHA1"));
return signedData;
};
sign.CustomSignHash = customSignHash;
// Bind PDF document
pdfSign.BindPdf(dataDir + "input.pdf");
// Sign the file
pdfSign.Sign(1, "second approval", "second_user@example.com", "Australia", false,
new System.Drawing.Rectangle(200, 200, 200, 100),
sign);
// Save PDF document
pdfSign.Save(dataDir + "SignWithBase64Certificate_out.pdf");
}
}
Novedades en Aspose.PDF 24.5
Esta versión nos permite trabajar con capas PDF. Por ejemplo:
- bloquear una capa PDF
- extraer elementos de capa PDF
- aplanar un PDF con capas
- fusionar todas las capas dentro del PDF en una
Bloquear una capa PDF
Desde la versión 24.5, puedes abrir un PDF, bloquear una capa específica en la primera página y guardar el documento con los cambios. Se añadieron dos nuevos métodos y una propiedad:
Layer.Lock(); - Bloquea la capa. Layer.Unlock(); - Desbloquea la capa. Layer.Locked; - Propiedad que indica el estado de bloqueo de la capa.
private static void LockLayerInPDF()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Layers();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "input.pdf"))
{
// Get the first page and the first layer
var page = document.Pages[1];
var layer = page.Layers[0];
// Lock the layer
layer.Lock();
// Save PDF document
document.Save(dataDir + "LockLayerInPDF_out.pdf");
}
}
Extraer elementos de capa PDF
La biblioteca Aspose.PDF for .NET permite la extracción de cada capa de la primera página y guarda cada capa en un archivo separado.
Para crear un nuevo PDF a partir de una capa, se puede utilizar el siguiente fragmento de código:
private static void ExtractPdfLayer()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Forms();
// Open PDF document
using (var inputDocument = new Aspose.Pdf.Document(dataDir + "input.pdf"))
{
// Get layers from the first page
var layers = inputDocument.Pages[1].Layers;
// Save each layer to the output path
foreach (var layer in layers)
{
layer.Save(dataDir + string.Format("Layer_{0}.pdf", layer.Id));
}
}
}
Aplanar un PDF con capas
La biblioteca Aspose.PDF for .NET abre un PDF, itera a través de cada capa en la primera página y aplana cada capa, haciéndola permanente en la página.
private static void FlattenPdfLayers()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Forms();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "input.pdf"))
{
// Get the first page
var page = document.Pages[1];
// Flatten each layer on the page
foreach (var layer in page.Layers)
{
layer.Flatten(true);
}
// Save PDF document
document.Save(dataDir + "FlattenedLayersPdf_out.pdf");
}
}
El método ‘Layer.Flatten(bool cleanupContentStream)’ acepta el parámetro booleano que especifica si se deben eliminar los marcadores de grupo de contenido opcional del flujo de contenido. Configurar el parámetro cleanupContentStream en falso acelera el proceso de aplanamiento.
Fusionar todas las capas dentro del PDF en una
La biblioteca Aspose.PDF for .NET permite fusionar todas las capas PDF o una capa específica en la primera página en una nueva capa y guarda el documento actualizado.
Se añadieron dos métodos para fusionar todas las capas en la página:
- void MergeLayers(string newLayerName);
- void MergeLayers(string newLayerName, string newOptionalContentGroupId);
El segundo parámetro permite renombrar el marcador de grupo de contenido opcional. El valor predeterminado es “oc1” (/OC /oc1 BDC).
private static void MergePdfLayers()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Forms();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "input.pdf"))
{
// Get the first page
var page = document.Pages[1];
page.MergeLayers("NewLayerName");
// Or
// page.MergeLayers("NewLayerName", "OC1");
// Save PDF document
document.Save(dataDir + "MergeLayersInPdf_out.pdf");
}
}
Novedades en Aspose.PDF 24.4
Esta versión admite la aplicación de una máscara de recorte a imágenes:
private static void AddStencilMasksToImages()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Images();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "AddStencilMasksToImages.pdf"))
{
// Open the first mask image file
using (var fs1 = new FileStream(dataDir + "mask1.jpg", FileMode.Open))
{
// Open the second mask image file
using (var fs2 = new FileStream(dataDir + "mask2.png", FileMode.Open))
{
// Apply stencil mask to the first image on the first page
document.Pages[1].Resources.Images[1].AddStencilMask(fs1);
// Apply stencil mask to the second image on the first page
document.Pages[1].Resources.Images[2].AddStencilMask(fs2);
}
}
// Save PDF document
document.Save(dataDir + "AddStencilMasksToImages_out.pdf");
}
}
Desde 24.4, puedes seleccionar la fuente de papel elegida por el tamaño de página PDF en el cuadro de diálogo de impresión utilizando la API.
A partir de Aspose.PDF 24.4, esta preferencia se puede activar y desactivar utilizando la propiedad Document.PickTrayByPdfSize o la fachada PdfContentEditor:
private static void PickTrayByPdfSize()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdfFacades_Printing();
// Create PDF document
using (var document = new Aspose.Pdf.Document())
{
// Add page
var page = document.Pages.Add();
page.Paragraphs.Add(new Aspose.Pdf.Text.TextFragment("Hello world!"));
// Set the flag to choose annotation paper tray using the PDF page size
document.PickTrayByPdfSize = true;
// Save PDF document
document.Save(dataDir + "PickTrayByPdfSize_out.pdf");
}
}
private static void PickTrayByPdfSizeFacade()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdfFacades_Printing();
// Create the PdfContentEditor facade
using (var contentEditor = new Aspose.Pdf.Facades.PdfContentEditor())
{
// Bind PDF document
contentEditor.BindPdf(dataDir + "PrintDocument.pdf");
// Set the flag to choose annotation paper tray using the PDF page size
contentEditor.ChangeViewerPreference(Aspose.Pdf.Facades.ViewerPreference.PickTrayByPDFSize);
// Save PDF document
contentEditor.Save(dataDir + "PickTrayByPdfSizeFacade_out.pdf");
}
}
Desde esta versión, se añadió el plugin Aspose.PDF Signature para .NET:
- Ejemplo con la creación de un nuevo campo y opciones:
// create Signature
var plugin = new Signature();
// create SignOptions object to set instructions
var opt = new SignOptions(inputPfxPath, inputPfxPassword);
// add input file path
opt.AddInput(new FileDataSource(inputPath));
// set output file path
opt.AddOutput(new FileDataSource(outputPath));
// set extra options
opt.Reason = "my Reason";
opt.Contact = "my Contact";
opt.Location = "my Location";
// perform the process
plugin.Process(opt);
- Ejemplo con un campo vacío existente:
// create Signature
var plugin = new Signature();
// create SignOptions object to set instructions
var opt = new SignOptions(inputPfxPath, inputPfxPassword);
// add input file path with empty signature field
opt.AddInput(new FileDataSource(inputPath));
// set output file path
opt.AddOutput(new FileDataSource(outputPath));
// set name of existing signature field
opt.Name = "Signature1";
// perform the process
plugin.Process(opt);
Novedades en Aspose.PDF 24.3
Desde esta versión, se añadió el plugin PDF/A Converter para .NET:
var options = new PdfAConvertOptions
{
PdfAVersion = PdfAStandardVersion.PDF_A_3B
};
// Add the source file
options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf")); // replace with your actual file path
// Add the path to save the converted file
options.AddOutput(new FileDataSource("path_to_the_converted_file.pdf"));
// Create the plugin instance
var plugin = new PdfAConverter();
// Run the conversion
plugin.Process(options);
- Implementar una búsqueda a través de una lista de frases en un TextFragmentAbsorber:
private static void SearchMultipleRegex()
{
// Create regular expressions
var regexes = new Regex[]
{
new Regex(@"(?s)document\s+(?:(?:no\(?s?\)?\.?)|(?:number(?:\(?s\)?)?))\s+(?:(?:[\w-]*\d[\w-]*)+(?:[,;\s]|and)*)", RegexOptions.IgnoreCase),
new Regex(@"[\s\r\n]+Tract[\s\r\n]+of:? ", RegexOptions.IgnoreCase),
new Regex(@"vested[\s\r\n]+in", RegexOptions.IgnoreCase),
new Regex("Vested in:", RegexOptions.IgnoreCase),
new Regex(@"file.?[\s\r\n]+(?:nos?|numbers?|#s?|nums?).?[\s\r\n]+(\d+)-(\d+)", RegexOptions.IgnoreCase),
new Regex(@"file.?[\s\r\n]+nos?.?:?[\s\r\n]+([\d\r\n-]+)", RegexOptions.IgnoreCase)
};
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Text();
// Open PDF document
using (var document = new Aspose.Pdf.Document(dataDir + "SearchRegularExpressionAll.pdf"))
{
// Create TextAbsorber object to find all instances of the input search phrase
var absorber = new Aspose.Pdf.Text.TextFragmentAbsorber(regexes, new Aspose.Pdf.Text.TextSearchOptions(true));
document.Pages.Accept(absorber);
// Get result
var result = absorber.RegexResults;
}
}
Desde 24.3, es posible agregar un campo de firma vacío en cada página al archivo PDF/A.
private static void AddEmptySignatureFieldOnEveryPage()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentConversion();
var fieldName = "signature_1234";
using (var document = new Aspose.Pdf.Document(dataDir + "PDFAToPDF.pdf"))
{
// The new suggested code, using SignatureField object
var signatureField = new Aspose.Pdf.Forms.SignatureField(document.Pages[1], new Aspose.Pdf.Rectangle(10, 10, 100, 100));
// Add the default appearance for the signature field
signatureField.DefaultAppearance = new Aspose.Pdf.Annotations.DefaultAppearance("Helv", 12, System.Drawing.Color.Black);
var newAddedField = document.Form.Add(signatureField, fieldName, 1);
// Find annotation associated with the field
Aspose.Pdf.Annotations.Annotation addedAnnotation = null;
foreach (Aspose.Pdf.Annotations.Annotation annotation in document.Pages[1].Annotations)
{
if (annotation.FullName == fieldName)
{
addedAnnotation = annotation;
break;
}
}
// Add the annotation to every page except the initial
if (addedAnnotation != null)
{
for (int p = 2; p <= document.Pages.Count; p++)
{
document.Pages[p].Annotations.Add(addedAnnotation);
}
}
// Save PDF document
document.Save(dataDir + "outputPdfaWithSignatureFields.pdf");
}
}
Novedades en Aspose.PDF 24.2
Desde 24.2, es posible obtener los datos vectoriales de un archivo PDF.
Se implementó GraphicsAbsorber para obtener datos vectoriales de documentos:
private static void UsingGraphicsAbsorber()
{
// The path to the document directory
var dataDir = RunExamples.GetDataDir_AsposePdf_Images();
// Open the document
using (var document = new Aspose.Pdf.Document(dataDir + "DocumentWithVectorGraphics.pdf"))
{
// Create an instance of GraphicsAbsorber
using (var graphicsAbsorber = new Aspose.Pdf.Vector.GraphicsAbsorber())
{
// Select the first page of the document
var page = document.Pages[1];
// Use the `Visit` method to extract graphics from the page
graphicsAbsorber.Visit(page);
// Display information about the extracted elements
foreach (var element in graphicsAbsorber.Elements)
{
Console.WriteLine($"Page Number: {element.SourcePage.Number}");
Console.WriteLine($"Position: ({element.Position.X}, {element.Position.Y})");
Console.WriteLine($"Number of Operators: {element.Operators.Count}");
}
}
}
}
Novedades en Aspose.PDF 24.1
Desde la versión 24.1, es posible importar anotaciones en formato FDF a PDF:
private static void ImportFDFByForm()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdfFacades_Forms();
using (var form = new Aspose.Pdf.Facades.Form(dataDir + "input.pdf"))
{
// Open FDF file
using (var fdfInputStream = new FileStream(dataDir + "student.fdf", FileMode.Open))
{
form.ImportFdf(fdfInputStream);
}
// Save PDF document
form.Save(dataDir + "ImportDataFromPdf_Form_out.pdf");
}
}
Además, soporte para acceso al Diccionario de Página o Catálogo de Documento.
Aquí hay ejemplos de código para DictionaryEditor:
- Agregar nuevos valores
private static void AddNewKeysToPdfPageDictionary()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentConversion();
// example of key's names
string KEY_NAME = "name";
string KEY_STRING = "str";
string KEY_BOOL = "bool";
string KEY_NUMBER = "number";
// Open the document
using (var document = new Aspose.Pdf.Document())
{
var page = document.Pages.Add();
var dictionaryEditor = new Aspose.Pdf.DataEditor.DictionaryEditor(page);
dictionaryEditor.Add(KEY_NAME, new Aspose.Pdf.DataEditor.CosPdfName("name data"));
dictionaryEditor.Add(KEY_STRING, new Aspose.Pdf.DataEditor.CosPdfString("string data"));
dictionaryEditor.Add(KEY_BOOL, new Aspose.Pdf.DataEditor.CosPdfBoolean(true));
dictionaryEditor.Add(KEY_NUMBER, new Aspose.Pdf.DataEditor.CosPdfNumber(11.2));
// Save PDF document
document.Save(dataDir + "PageDictionaryEditor_out.pdf");
}
}
- Agregar y establecer valores en el diccionario
private static void ModifyKeysInPdfPageDictionary()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentConversion();
string KEY_NAME = "name";
// Open the document
using (var document = new Aspose.Pdf.Document())
{
var page = document.Pages.Add();
var dictionaryEditor = new Aspose.Pdf.DataEditor.DictionaryEditor(page);
dictionaryEditor.Add(KEY_NAME, new Aspose.Pdf.DataEditor.CosPdfName("Old data"));
// Modify existing value
dictionaryEditor[KEY_NAME] = new Aspose.Pdf.DataEditor.CosPdfName("New data");
// Save PDF document
document.Save(dataDir + "PageDictionaryEditorEdit_out.pdf");
}
}
- Obtener valor del diccionario
private static void GetValuesFromPdfPageDictionary()
{
string KEY_NAME = "name";
using (var document = new Aspose.Pdf.Document())
{
var page = document.Pages.Add();
var dictionaryEditor = new Aspose.Pdf.DataEditor.DictionaryEditor(page);
dictionaryEditor[KEY_NAME] = new Aspose.Pdf.DataEditor.CosPdfName("name");
var value = dictionaryEditor[KEY_NAME];
// or
Aspose.Pdf.DataEditor.ICosPdfPrimitive primitive;
dictionaryEditor.TryGetValue(KEY_NAME, out primitive);
}
}
- Eliminar valor del diccionario
private static void RemoveFromPdfPageDictionary()
{
// The path to the documents directory
var dataDir = RunExamples.GetDataDir_AsposePdf_DocumentConversion();
string KEY_NAME = "name";
string EXPECTED_NAME = "name data";
using (var document = new Aspose.Pdf.Document())
{
var page = document.Pages.Add();
var dictionaryEditor = new Aspose.Pdf.DataEditor.DictionaryEditor(page);
dictionaryEditor.Add(KEY_NAME, new Aspose.Pdf.DataEditor.CosPdfName(EXPECTED_NAME));
dictionaryEditor.Remove(KEY_NAME);
// Save PDF document
document.Save(dataDir + "PageDictionaryEditorRemove_out.pdf");
}
}