Crear un archivo PDF en .NET MAUI Usando IronPDF

Introducción

.NET Multi-platform App UI (.NET MAUI) es un marco multiplataforma para crear aplicaciones nativas móviles y de escritorio con C# y XAML. Puede utilizar .NET MAUI para operar en Android, iOS, MacOS y Windows utilizando una única base de código. .NET MAUI es de código abierto y es una mejora de Xamarin Forms. Los controles de la interfaz de usuario se han reescrito desde cero para mejorar el rendimiento y la extensibilidad. Además, ha pasado de la plataforma móvil a incluir casos de uso en ordenadores de sobremesa. Si alguna vez ha utilizado Xamarin Forms para crear interfaces de usuario multiplataforma, descubrirá que el marco MAUI de .NET tiene mucho en común con él.

Sin embargo, existen algunas diferencias. Puedes construir aplicaciones multiplataforma con .NET MAUI Framework utilizando un único proyecto, pero puedes añadir código y recursos específicos de la plataforma si es necesario. Uno de los principales objetivos de .NET MAUI es permitirle escribir la mayor parte de la lógica de su aplicación y el diseño de interfaz de usuario en una sola base de código como sea posible. .NET MAUI estará disponible para todas las plataformas y será compatible con los patrones MVVM y XAML existentes.

.NET MAUI permite a los desarrolladores trabajar en varias plataformas, como el desarrollo móvil y las plataformas Windows.

Características de IronPDF

IronPDF es un potente conversor de PDF que puede manejar casi cualquier tarea que pueda realizar un navegador. La biblioteca .NET para desarrolladores simplifica la creación, lectura y manipulación de archivos PDF. IronPDF utiliza el motor de Google Chrome para convertir archivos HTML a PDF. Entre otras tecnologías web, IronPDF admite HTML, ASPX, Convertir páginas Razor a PDF con IronPDF y MVC View. IronPDF es compatible con aplicaciones de Microsoft .NET (tanto aplicaciones web ASP.NET como aplicaciones tradicionales de Windows). IronPDF también puede utilizarse para crear atractivos documentos PDF.

IronPDF puede crear archivos PDF a partir de archivos HTML con JavaScript y CSS que contienen archivos de JavaScript, CSS e imágenes.

No solo se puede convertir archivos HTML a PDF con IronPDF, sino que también se puede convertir archivos de imagen a PDF.

IronPDF puede ayudar a crear documentos PDF interactivos, completar y enviar formularios interactivos con IronPDF, unir y dividir documentos PDF, extraer texto e imágenes de PDFs de documentos PDF, buscar texto en documentos PDF, rasterizar páginas PDF a imágenes, convertir PDF a HTML, y imprimir documentos PDF utilizando IronPrint.

IronPDF puede generar un documento a partir de una URL. Para iniciar sesión detrás de HTML usando IronPDF para formularios de inicio de sesión, también permite el uso de credenciales de inicio de sesión de red personalizadas, agentes de usuario, proxies, cookies, encabezados HTTP y variables de formulario.

IronPDF es una biblioteca que puede leer y rellenar documentos PDF y es capaz de extraer imágenes de los documentos. Nos permite agregar encabezados y pies de página a archivos PDF, texto, fotos, marcadores para una navegación más fácil, marcas de agua y más a los documentos. También nos permite unir y dividir páginas en un documento nuevo o existente. IronPDF es capaz de convertir documentos en objetos PDF sin necesidad de utilizar un visor Acrobat. También es posible convertir un archivo CSS en un documento PDF y los archivos CSS de tipo multimedia pueden convertirse en documentos.

Creación de un nuevo proyecto en Visual Studio

En primer lugar, cree un proyecto utilizando tanto Visual Studio Code como Visual Studio. Cuando se utiliza Visual Studio Code, es necesario utilizar la herramienta de línea de comandos para instalar la plantilla de tipo de proyecto.

Abra el software Microsoft Visual Studio y vaya al menú Archivo. Selecciona "nuevo proyecto" y en la ventana de nuevo proyecto selecciona ".NET MAUI App" Este artículo utilizará una .NET MAUI App para generar documentos PDF y guardarlos en una ubicación adecuada.

Crear un nuevo proyecto en Visual Studio

Introduzca el nombre del proyecto y seleccione la ruta del archivo en el cuadro de texto correspondiente. A continuación, haz clic en el botón Crear, como en la captura de pantalla a continuación.

Configurar el proyecto

El proyecto de Visual Studio generará ahora la estructura para la aplicación seleccionada siguiendo la plataforma .NET MAUI App. A continuación, abrirá el archivo MainPage.cs para agregar código y construir/ejecutar la aplicación.

Crear un archivo PDF en .NET MAUI usando IronPDF, Figura 3: Agregar código en el archivo MainPage.cs

Agregar código en el archivo MainPage.cs

A continuación, instala la biblioteca para probar el código.

Instalar la biblioteca IronPDF

La biblioteca IronPDF puede descargarse e instalarse de cuatro maneras.

Estos son:

• Utilización de Visual Studio.
• Uso de la línea de comandos de Visual Studio.
• Descarga directa desde el sitio web de NuGet.
• Descarga directa desde el sitio web de IronPDF.

Uso de Visual Studio

El software Visual Studio proporciona la opción NuGet Package Manager para instalar el paquete directamente en la solución. La siguiente captura de pantalla muestra cómo abrir el Gestor de paquetes NuGet.

Navegar a la interfaz de administrador de paquetes de NuGet

Esto proporciona el cuadro de búsqueda para mostrar la lista de paquetes del sitio web de NuGet. En el gestor de paquetes NuGet, busque la palabra clave "IronPDF", como en la captura de pantalla siguiente.

Paquete IronPDF desde NuGet Package Manager UI

En la imagen anterior, se enumeran los elementos de búsqueda relacionados, seleccione la primera opción para instalar el paquete en la solución. Se instalará en todas las plataformas de aplicaciones .NET MAUI, como las plataformas Android, iOS y Windows.

Uso de la línea de comandos de Visual Studio

En Visual Studio, ve a Herramientas > Administrador de paquetes NuGet > Consola del administrador de paquetes

Introduzca la siguiente línea en la pestaña Consola del gestor de paquetes:

Install-Package IronPdf

Ahora, el paquete se descargará/instalará en todas las plataformas .NET MAUI del proyecto actual y estará listo para usar.

Instala el paquete en la consola del administrador de paquetes

Descarga directa desde el sitio web de NuGet

La tercera forma es descargar el paquete NuGet directamente desde su sitio web accediendo a esta página del repositorio de NuGet de IronPDF.

• Seleccione la opción de descarga de paquetes en el menú de la derecha.
• Haga doble clic en el paquete descargado. Se instalará automáticamente.
• Vuelva a cargar la solución y el paquete debería ser utilizable en su proyecto.

Descarga directa desde el sitio web de IronPDF

Descarga el paquete ZIP más reciente de IronPDF directamente desde su sitio web. Una vez descargado, sigue los pasos a continuación para agregar el paquete a tu proyecto.

• Haz clic con el botón derecho en la opción Dependencias del proyecto desde la ventana de la solución.
• Seleccione la plataforma específica y, a continuación, las opciones de referencia y busque la ubicación de la referencia descargada.

• Haga clic en Aceptar para añadir la referencia.

  También tendrás que añadir referencias a todas las plataformas .NET compatibles con MAUI.

Crear PDFs en una aplicación .NET MAUI usando IronPDF

Cuando se crea un proyecto, se generará automáticamente un archivo llamado MainPage.xaml. Aquí es donde poner la UI de la aplicación .NET MAUI.

Sigue el código que aparece a continuación.

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MAUI_PDF.MainPage"
            >

    <ScrollView>
        <VerticalStackLayout
            Spacing="25"
            Padding="30,0"
            VerticalOptions="Center">

            <Image
                Source="dotnet_bot.png"
                SemanticProperties.Description="Cute .NET bot waving hi to you!"
                HeightRequest="200"
                HorizontalOptions="Center" />

            <Label
                Text="Welcome to IronPDF!"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="32"
                HorizontalOptions="Center" />

            <Button
                x:Name="PdfBtn"
                Text="Click me to generate PDF"
                SemanticProperties.Hint="Click button to generate PDF"
                Clicked="GeneratePDF"
                HorizontalOptions="Center" />
        </VerticalStackLayout>
    </ScrollView>

</ContentPage>

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MAUI_PDF.MainPage"
            >

    <ScrollView>
        <VerticalStackLayout
            Spacing="25"
            Padding="30,0"
            VerticalOptions="Center">

            <Image
                Source="dotnet_bot.png"
                SemanticProperties.Description="Cute .NET bot waving hi to you!"
                HeightRequest="200"
                HorizontalOptions="Center" />

            <Label
                Text="Welcome to IronPDF!"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="32"
                HorizontalOptions="Center" />

            <Button
                x:Name="PdfBtn"
                Text="Click me to generate PDF"
                SemanticProperties.Hint="Click button to generate PDF"
                Clicked="GeneratePDF"
                HorizontalOptions="Center" />
        </VerticalStackLayout>
    </ScrollView>

</ContentPage>

Una vez que el código anterior se haya agregado al archivo MainPage.xaml, abre el archivo MainPage.xaml.cs e incluye el siguiente método dentro de la clase MainPage:

private void GeneratePDF(object sender, EventArgs e)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var doc = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF!</h1> <p>I'm using IronPDF MAUI!</p>");

    //Saves the memory stream as file.
    SaveService saveService = new SaveService();
    saveService.SaveAndView("IronPDF HTML string.pdf", "application/pdf", doc.Stream);
}

private void GeneratePDF(object sender, EventArgs e)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var doc = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF!</h1> <p>I'm using IronPDF MAUI!</p>");

    //Saves the memory stream as file.
    SaveService saveService = new SaveService();
    saveService.SaveAndView("IronPDF HTML string.pdf", "application/pdf", doc.Stream);
}

Private Sub GeneratePDF(ByVal sender As Object, ByVal e As EventArgs)
	Dim renderer As New ChromePdfRenderer()
	Dim doc = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF!</h1> <p>I'm using IronPDF MAUI!</p>")

	'Saves the memory stream as file.
	Dim saveService As New SaveService()
	saveService.SaveAndView("IronPDF HTML string.pdf", "application/pdf", doc.Stream)
End Sub

El método GeneratePDF genera un nuevo documento PDF que contiene el texto "Hello, IronPDF!..." y lo guarda en el ordenador del usuario en una ubicación especificada.

En el método anterior, se crea un nuevo objeto ChromePdfRenderer y se invoca el método RenderHtmlAsPdf para producir un nuevo documento PDF que contiene las palabras "Hello IronPDF!" ..." a partir de una cadena de marcado HTML. A continuación, se delegará el guardado del archivo en el dispositivo del usuario a una clase independiente, llamada SaveService. Esta clase se creará en el siguiente paso.

El archivo completo MainPage.xaml.cs se proporciona a continuación. Asegúrese de que el contenido del archivo coincide con lo que se muestra a continuación antes de continuar con el siguiente paso:

// Change the namespace as desired, but make sure that all source files use this same namespace,
// or there will be errors!
namespace MAUI_IronPDF;    

// This namespace is required to make use of IronPDF functionality
using IronPdf;

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();
    }

    private void GeneratePDF(object sender, EventArgs e)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var doc = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF!</h1> <p>I'm using IronPDF MAUI!</p>");
        //Saves the memory stream as file.
        SaveService saveService = new SaveService();
        saveService.SaveAndView("IronPDF HTML string.pdf", "application/pdf", doc.Stream);
    }
}

// Change the namespace as desired, but make sure that all source files use this same namespace,
// or there will be errors!
namespace MAUI_IronPDF;    

// This namespace is required to make use of IronPDF functionality
using IronPdf;

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();
    }

    private void GeneratePDF(object sender, EventArgs e)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var doc = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF!</h1> <p>I'm using IronPDF MAUI!</p>");
        //Saves the memory stream as file.
        SaveService saveService = new SaveService();
        saveService.SaveAndView("IronPDF HTML string.pdf", "application/pdf", doc.Stream);
    }
}

Imports IronPdf

' Change the namespace as desired, but make sure that all source files use this same namespace,
' or there will be errors!
Namespace MAUI_IronPDF

	' This namespace is required to make use of IronPDF functionality

	Partial Public Class MainPage
		Inherits ContentPage

		Public Sub New()
			InitializeComponent()
		End Sub

		Private Sub GeneratePDF(ByVal sender As Object, ByVal e As EventArgs)
			Dim renderer As New ChromePdfRenderer()
			Dim doc = renderer.RenderHtmlAsPdf("<h1>Hello IronPDF!</h1> <p>I'm using IronPDF MAUI!</p>")
			'Saves the memory stream as file.
			Dim saveService As New SaveService()
			saveService.SaveAndView("IronPDF HTML string.pdf", "application/pdf", doc.Stream)
		End Sub
	End Class
End Namespace

Ahora, crea un nuevo archivo de clase llamado SaveService.cs en la raíz del proyecto y añade el siguiente código fuente:

// Change the namespace as desired, but make sure that all source files use this same namespace,
// or there will be errors!
namespace MAUI_IronPDF
{
    // SaveService partial class declaration ... this allows a layer of abstraction
    // as we implement the save file details specially for each platform on which this app will
    // operate! 
    public partial class SaveService
    {
        public void SaveAndView(string filename, string contentType, MemoryStream stream)
        {
            SaveFile(filename, contentType, stream);
        }

        // Additional partial files will provide implementations for this method specifically.
        partial void SaveFile(string filename, string contentType, MemoryStream stream);
    }
}

// Change the namespace as desired, but make sure that all source files use this same namespace,
// or there will be errors!
namespace MAUI_IronPDF
{
    // SaveService partial class declaration ... this allows a layer of abstraction
    // as we implement the save file details specially for each platform on which this app will
    // operate! 
    public partial class SaveService
    {
        public void SaveAndView(string filename, string contentType, MemoryStream stream)
        {
            SaveFile(filename, contentType, stream);
        }

        // Additional partial files will provide implementations for this method specifically.
        partial void SaveFile(string filename, string contentType, MemoryStream stream);
    }
}

' Change the namespace as desired, but make sure that all source files use this same namespace,
' or there will be errors!
Namespace MAUI_IronPDF
	' SaveService partial class declaration ... this allows a layer of abstraction
	' as we implement the save file details specially for each platform on which this app will
	' operate! 
	Partial Public Class SaveService
		Public Sub SaveAndView(ByVal filename As String, ByVal contentType As String, ByVal stream As MemoryStream)
			SaveFile(filename, contentType, stream)
		End Sub

		' Additional partial files will provide implementations for this method specifically.
		Partial Private Sub SaveFile(ByVal filename As String, ByVal contentType As String, ByVal stream As MemoryStream)
		End Sub
	End Class
End Namespace

Dado que los detalles de implementación para guardar contenido en dispositivos de usuario varían con cada plataforma (Windows, Android, MacOS, etc.), es necesario escribir código específico de la plataforma para cada tipo de dispositivo que la aplicación vaya a soportar. Para hacer esto posible, definimos SaveService como una clase parcial (con fines de abstracción) que contiene un método parcial, llamado SaveAndView. A continuación, la implementación de este método se definirá en una clase parcial SaveService.cs separada para una o más de las carpetas anidadas en la carpeta Platforms dentro del Explorador de Soluciones (ver imagen abajo):

La estructura de carpetas para implementar multiplataforma

Para simplificar, este tutorial definirá el archivo parcial mencionado sólo para la plataforma Windows. Cree un nuevo archivo SaveService.cs en la carpeta de la plataforma de Windows que contenga el código que se muestra a continuación:

using Windows.Storage;
using Windows.Storage.Pickers;
using Windows.Storage.Streams;
using Windows.UI.Popups;

namespace MAUI_IronPDF;

public partial class SaveService
{
    async partial void SaveFile(string filename, string contentType, MemoryStream stream)
    {
        StorageFile stFile;
        string extension = Path.GetExtension(filename);
        //Gets process windows handle to open the dialog in application process.
        IntPtr windowHandle = System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle;
        if (!Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons"))
        {
            //Creates file save picker to save a file.
            FileSavePicker savePicker = new();
            savePicker.DefaultFileExtension = ".pdf";
            savePicker.SuggestedFileName = filename;
            //Saves the file as PDF file.
            savePicker.FileTypeChoices.Add("PDF", new List<string>() { ".pdf" });

            WinRT.Interop.InitializeWithWindow.Initialize(savePicker, windowHandle);
            stFile = await savePicker.PickSaveFileAsync();
        }
        else
        {
            StorageFolder local = ApplicationData.Current.LocalFolder;
            stFile = await local.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
        }
        if (stFile != null)
        {
            using (IRandomAccessStream zipStream = await stFile.OpenAsync(FileAccessMode.ReadWrite))
            {
                //Writes compressed data from memory to file.
                using Stream outstream = zipStream.AsStreamForWrite();
                outstream.SetLength(0);
                //Saves the stream as file.
                byte [] buffer = stream.ToArray();
                outstream.Write(buffer, 0, buffer.Length);
                outstream.Flush();
            }
            //Create message dialog box.
            MessageDialog msgDialog = new("Do you want to view the document?", "File has been created successfully");
            UICommand yesCmd = new("Yes");
            msgDialog.Commands.Add(yesCmd);
            UICommand noCmd = new("No");
            msgDialog.Commands.Add(noCmd);

            WinRT.Interop.InitializeWithWindow.Initialize(msgDialog, windowHandle);

            //Showing a dialog box.
            IUICommand cmd = await msgDialog.ShowAsync();
            if (cmd.Label == yesCmd.Label)
            {
                //Launch the saved file.
                await Windows.System.Launcher.LaunchFileAsync(stFile);
            }
        }
    }
}

using Windows.Storage;
using Windows.Storage.Pickers;
using Windows.Storage.Streams;
using Windows.UI.Popups;

namespace MAUI_IronPDF;

public partial class SaveService
{
    async partial void SaveFile(string filename, string contentType, MemoryStream stream)
    {
        StorageFile stFile;
        string extension = Path.GetExtension(filename);
        //Gets process windows handle to open the dialog in application process.
        IntPtr windowHandle = System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle;
        if (!Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons"))
        {
            //Creates file save picker to save a file.
            FileSavePicker savePicker = new();
            savePicker.DefaultFileExtension = ".pdf";
            savePicker.SuggestedFileName = filename;
            //Saves the file as PDF file.
            savePicker.FileTypeChoices.Add("PDF", new List<string>() { ".pdf" });

            WinRT.Interop.InitializeWithWindow.Initialize(savePicker, windowHandle);
            stFile = await savePicker.PickSaveFileAsync();
        }
        else
        {
            StorageFolder local = ApplicationData.Current.LocalFolder;
            stFile = await local.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
        }
        if (stFile != null)
        {
            using (IRandomAccessStream zipStream = await stFile.OpenAsync(FileAccessMode.ReadWrite))
            {
                //Writes compressed data from memory to file.
                using Stream outstream = zipStream.AsStreamForWrite();
                outstream.SetLength(0);
                //Saves the stream as file.
                byte [] buffer = stream.ToArray();
                outstream.Write(buffer, 0, buffer.Length);
                outstream.Flush();
            }
            //Create message dialog box.
            MessageDialog msgDialog = new("Do you want to view the document?", "File has been created successfully");
            UICommand yesCmd = new("Yes");
            msgDialog.Commands.Add(yesCmd);
            UICommand noCmd = new("No");
            msgDialog.Commands.Add(noCmd);

            WinRT.Interop.InitializeWithWindow.Initialize(msgDialog, windowHandle);

            //Showing a dialog box.
            IUICommand cmd = await msgDialog.ShowAsync();
            if (cmd.Label == yesCmd.Label)
            {
                //Launch the saved file.
                await Windows.System.Launcher.LaunchFileAsync(stFile);
            }
        }
    }
}

Imports Windows.Storage
Imports Windows.Storage.Pickers
Imports Windows.Storage.Streams
Imports Windows.UI.Popups

Namespace MAUI_IronPDF

	Partial Public Class SaveService
		Private Async Sub SaveFile(ByVal filename As String, ByVal contentType As String, ByVal stream As MemoryStream)
			Dim stFile As StorageFile
			Dim extension As String = Path.GetExtension(filename)
			'Gets process windows handle to open the dialog in application process.
			Dim windowHandle As IntPtr = System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle
			If Not Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons") Then
				'Creates file save picker to save a file.
				Dim savePicker As New FileSavePicker()
				savePicker.DefaultFileExtension = ".pdf"
				savePicker.SuggestedFileName = filename
				'Saves the file as PDF file.
				savePicker.FileTypeChoices.Add("PDF", New List(Of String)() From {".pdf"})

				WinRT.Interop.InitializeWithWindow.Initialize(savePicker, windowHandle)
				stFile = Await savePicker.PickSaveFileAsync()
			Else
				Dim local As StorageFolder = ApplicationData.Current.LocalFolder
				stFile = Await local.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting)
			End If
			If stFile IsNot Nothing Then
				Using zipStream As IRandomAccessStream = Await stFile.OpenAsync(FileAccessMode.ReadWrite)
					'Writes compressed data from memory to file.
					Using outstream As Stream = zipStream.AsStreamForWrite()
						outstream.SetLength(0)
						'Saves the stream as file.
						Dim buffer() As Byte = stream.ToArray()
						outstream.Write(buffer, 0, buffer.Length)
						outstream.Flush()
					End Using
				End Using
				'Create message dialog box.
				Dim msgDialog As New MessageDialog("Do you want to view the document?", "File has been created successfully")
				Dim yesCmd As New UICommand("Yes")
				msgDialog.Commands.Add(yesCmd)
				Dim noCmd As New UICommand("No")
				msgDialog.Commands.Add(noCmd)

				WinRT.Interop.InitializeWithWindow.Initialize(msgDialog, windowHandle)

				'Showing a dialog box.
				Dim cmd As IUICommand = Await msgDialog.ShowAsync()
				If cmd.Label = yesCmd.Label Then
					'Launch the saved file.
					Await Windows.System.Launcher.LaunchFileAsync(stFile)
				End If
			End If
		End Sub
	End Class
End Namespace

Construye y ejecuta la aplicación MAUI. Aparecerá una ventana con la interfaz que se muestra a continuación:

La interfaz de usuario de la aplicación MAUI

Haga clic en el botón "Generar PDF". Al cabo de unos instantes, aparecerá una ventana emergente para elegir la ubicación del archivo PDF generado.

Seleccione una ubicación para guardar el archivo PDF

Conclusión

IronPDF es una de las bibliotecas conversoras de PDF más utilizadas que permite generar, leer, editar y dar formato a archivos PDF. La biblioteca IronPDF ofrece muchas ventajas y funcionalidades, como un motor de navegación que le ayudará a convertir una URL determinada en un archivo PDF, permite añadir CSS a cadenas HTML y convertirlas en archivos PDF, y también permite rellenar formularios PDF. Todas las funciones de IronPDF están incluidas en una sola biblioteca.

IronPDF ofrece varias estructuras de precios. El precio básico para IronPDF comienza en $749. La asistencia técnica y las actualizaciones del producto también están disponibles por una cuota de un año. La cobertura de redistribución libre de derechos también puede adquirirse como complemento.

En resumen, IronPDF es recomendable, ya que ofrece un gran rendimiento y un gran número de funciones para los desarrolladores que trabajan con PDF. Es compatible con plataformas universales como .NET MAUI. También viene con una excelente asistencia y documentación, lo que le permite utilizar plenamente la amplia gama de la biblioteca IronPDF y sus muchas características.