DotNetify es un marco de código abierto hecho con .NET y Blazor diseñado para crear aplicaciones web en tiempo real en una plataforma .NET. Al utilizar el poder de SignalR para las interacciones en tiempo real entre el cliente y el servidor, simplifica la construcción de aplicaciones web dinámicas e interactivas. DotNetify proporciona un modelo de programación que sincroniza las vistas del lado del cliente con los datos del guion del lado del servidor, permitiendo a los desarrolladores diseñar interfaces en línea ricas, receptivas y de alto rendimiento de manera rápida y sencilla.

Por el contrario, la Biblioteca de Generación de PDF IronPDF es un paquete .NET potente que facilita la creación, edición y manipulación de documentos PDF programáticamente. Es una excelente opción para crear documentos dinámicos basados en datos como informes, facturas y formularios, ofreciendo una API intuitiva para transformar texto HTML en PDF.

Al integrar DotNetify con IronPDF, se combinan la interactividad web en tiempo real y las capacidades robustas de producción de PDF en una aplicación C#. Esta integración es particularmente beneficiosa para aplicaciones que requieren visualización de datos en tiempo real y la capacidad de crear y distribuir dinámicamente documentos PDF basados en los datos más recientes. Los desarrolladores pueden crear aplicaciones en línea extensas e interactivas que aborden requisitos comerciales complejos y mejoren las experiencias de los usuarios a través de la generación y distribución fluida de documentos al aprovechar la versátil generación de PDF de IronPDF y la sincronización de datos en tiempo real de DotNetify.

¿Qué es DotNetify?

DotNetify es un marco de código abierto diseñado para simplificar la creación de aplicaciones web interactivas en tiempo real con .NET y Blazor. Los desarrolladores pueden crear interfaces de usuario dinámicas y receptivas que se sincronizan sin esfuerzo con los datos del lado del servidor al utilizar SignalR, facilitando la comunicación en tiempo real entre el cliente y el servidor. DotNetify utiliza un enfoque de programación reactiva, abstrayendo las complejidades de la vinculación de datos en tiempo real y el manejo de eventos, simplificando así la creación de aplicaciones en línea complejas con código mínimo.

DotNetify permite a los desarrolladores construir modelos de vista del lado del servidor que propagan inmediatamente los cambios al cliente, asegurando que la interfaz de usuario siempre refleje el estado de la aplicación. Este marco ofrece flexibilidad al elegir la tecnología del lado del cliente, apoyando tanto front-ends JavaScript clásicos como front-ends Blazor. Es ideal para aplicaciones que requieren actualizaciones en tiempo real, como paneles, herramientas colaborativas y flujos de datos en vivo, debido a su facilidad de uso y eficacia.

El manejo en tiempo real de DotNetify de interacciones intrincadas y flujos de datos mejora significativamente la experiencia del usuario al permitir una sincronización de datos fluida y una respuesta inmediata. En general, DotNetify es una herramienta valiosa para desarrolladores .NET que buscan construir aplicaciones en línea reactivas, de vanguardia y en tiempo real de manera rápida y eficiente.

Características de DotNetify

DotNetify en C# ofrece una gran cantidad de características que simplifican la creación de aplicaciones en línea interactivas y en tiempo real, incluyendo:

• Comunicación en Tiempo Real: Utiliza SignalR para la comunicación cliente-servidor bidireccional y en tiempo real, habilitando interfaces de usuario interactivas y actualizaciones instantáneas.
• Modelo de Programación Reactivo: Proporciona un modelo de programación reactivo, sincronizando automáticamente las vistas del lado del cliente y los modelos de vista del lado del servidor para mantener la interfaz de usuario actualizada con la información más reciente.
• Modelos de Vista del Lado del Servidor: Facilita la creación de modelos de vista del lado del servidor a los que los componentes del lado del cliente pueden vincularse, simplificando la gestión de estado y el flujo de datos dentro de la aplicación.
• Soporte para Blazor y JavaScript: Soporta tanto front-ends JavaScript clásicos como front-ends Blazor, permitiendo a los desarrolladores elegir la tecnología del lado del cliente que mejor se adapta a sus necesidades.
• Facilidad de Integración: Integra sin problemas la funcionalidad en tiempo real en proyectos nuevos o existentes, y funciona bien con marcos de componentes UI del lado del cliente como WebSockets, integrándose con proyectos que usan React Native, Vue y Blazor.
• Escalabilidad: Hereda las características de escalabilidad de SignalR, permitiendo a las aplicaciones gestionar eficazmente muchas conexiones concurrentes.
• Arquitectura MVVM: Adopta la arquitectura Modelo-Vista-Modelo de Vista (MVVM), ayudando a separar responsabilidades y mantener un código organizado y limpio.
• Manejo de Eventos: Reduce el código repetitivo necesario para manejar interacciones de UI y cambios de estado al simplificar el manejo de eventos y la vinculación de datos.
• Extensible y Personalizable: Proporciona puntos de extensibilidad y ganchos para la personalización del comportamiento y la integración necesaria con otras bibliotecas o marcos.
• Infraestructura Robusta: Ofrece un mecanismo de enrutamiento dinámico que puede definirse completamente en el back-end, capaz de enrutamiento anidado, autenticación basada en tokens y más.
• Código Abierto y Conducido por la Comunidad: Como proyecto de código abierto, DotNetify se beneficia de la participación y contribución de la comunidad, asegurando actualizaciones y mejoras continuas.

Creating and Configuring DotNetify in C#

Para establecer un proyecto simple y comenzar a configurar DotNetify en una aplicación en línea C#, siga estos pasos. Este tutorial demuestra cómo usar ASP.NET Core y Blazor para configurar un servidor y cliente DotNetify básico.

Crear un nuevo proyecto de servidor ASP.NET Core Blazor

1. Abra Visual Studio: inicie Visual Studio y cree un nuevo proyecto.
2. Cree una aplicación Blazor Server: elija la plantilla de aplicación Blazor Server de las plantillas de proyecto y haga clic en "Siguiente".
3. Configure su proyecto: proporcione un nombre para su proyecto (por ejemplo, "DotNetifyWebApp") y realice los cambios de configuración necesarios. Haga clic en "Crear".

Instalar DotNetify a través de NuGet

1. Administrar paquetes NuGet : en el Explorador de soluciones, haga clic con el botón derecho en su proyecto y seleccione "Administrar paquetes NuGet ".
2. Busque DotNetify: instale los paquetes DotNetify y Blazor .

Configurar DotNetify

Para configurar DotNetify, abre Startup.cs y utiliza los métodos ConfigureServices y Configure.

using DotNetify;
using DotNetify.Blazor;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
        services.AddServerSideBlazor();
        services.AddSignalR();
        services.AddDotNetify();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapBlazorHub();
            endpoints.MapFallbackToPage("/_Host");
            endpoints.MapHub<DotNetifyHub>("/dotnetify");
        });
    }
}

using DotNetify;
using DotNetify.Blazor;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
        services.AddServerSideBlazor();
        services.AddSignalR();
        services.AddDotNetify();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapBlazorHub();
            endpoints.MapFallbackToPage("/_Host");
            endpoints.MapHub<DotNetifyHub>("/dotnetify");
        });
    }
}

Imports DotNetify
Imports DotNetify.Blazor

Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		services.AddRazorPages()
		services.AddServerSideBlazor()
		services.AddSignalR()
		services.AddDotNetify()
	End Sub

	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		If env.IsDevelopment() Then
			app.UseDeveloperExceptionPage()
		Else
			app.UseExceptionHandler("/Error")
			app.UseHsts()
		End If

		app.UseHttpsRedirection()
		app.UseStaticFiles()
		app.UseRouting()
		app.UseEndpoints(Sub(endpoints)
			endpoints.MapBlazorHub()
			endpoints.MapFallbackToPage("/_Host")
			endpoints.MapHub(Of DotNetifyHub)("/dotnetify")
		End Sub)
	End Sub
End Class

Imports DotNetify
Imports DotNetify.Blazor

Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		services.AddRazorPages()
		services.AddServerSideBlazor()
		services.AddSignalR()
		services.AddDotNetify()
	End Sub

	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		If env.IsDevelopment() Then
			app.UseDeveloperExceptionPage()
		Else
			app.UseExceptionHandler("/Error")
			app.UseHsts()
		End If

		app.UseHttpsRedirection()
		app.UseStaticFiles()
		app.UseRouting()
		app.UseEndpoints(Sub(endpoints)
			endpoints.MapBlazorHub()
			endpoints.MapFallbackToPage("/_Host")
			endpoints.MapHub(Of DotNetifyHub)("/dotnetify")
		End Sub)
	End Sub
End Class

Crear un ViewModel

Cree un nuevo archivo de clase en su proyecto (por ejemplo, HelloWorldViewModel.cs) y diseñe un ViewModel básico.

using DotNetify;

public class HelloWorldViewModel : BaseVM
{
    public string Greetings => "Hello, World!";
}

using DotNetify;

public class HelloWorldViewModel : BaseVM
{
    public string Greetings => "Hello, World!";
}

Imports DotNetify

Public Class HelloWorldViewModel
	Inherits BaseVM

	Public ReadOnly Property Greetings() As String
		Get
			Return "Hello, World!"
		End Get
	End Property
End Class

Imports DotNetify

Public Class HelloWorldViewModel
	Inherits BaseVM

	Public ReadOnly Property Greetings() As String
		Get
			Return "Hello, World!"
		End Get
	End Property
End Class

Registrar ViewModel

Antes de registrar el ViewModel, abre Program.cs.

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            })
            .ConfigureServices(services =>
            {
                services.AddTransient<HelloWorldViewModel>();
            });
}

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            })
            .ConfigureServices(services =>
            {
                services.AddTransient<HelloWorldViewModel>();
            });
}

Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		CreateHostBuilder(args).Build().Run()
	End Sub

	Public Shared Function CreateHostBuilder(ByVal args() As String) As IHostBuilder
		Return Host.CreateDefaultBuilder(args).ConfigureWebHostDefaults(Sub(webBuilder)
				webBuilder.UseStartup(Of Startup)()
		End Sub).ConfigureServices(Sub(services)
				services.AddTransient(Of HelloWorldViewModel)()
		End Sub})
	End Function

Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		CreateHostBuilder(args).Build().Run()
	End Sub

	Public Shared Function CreateHostBuilder(ByVal args() As String) As IHostBuilder
		Return Host.CreateDefaultBuilder(args).ConfigureWebHostDefaults(Sub(webBuilder)
				webBuilder.UseStartup(Of Startup)()
		End Sub).ConfigureServices(Sub(services)
				services.AddTransient(Of HelloWorldViewModel)()
		End Sub})
	End Function

Crear componente Blazor

En su proyecto, agregue un nuevo componente Blazor (como HelloWorld.razor) y conéctelo al ViewModel.

@page "/"

@using DotNetify
@using DotNetify.Blazor
@inject IDotNetifyService DotNetify

<h3>@greetings</h3>

@code {
    private string greetings;

    protected override async Task OnInitializedAsync()
    {
        var vm = await DotNetify.ConnectAsync<HelloWorldViewModel>(this);
        greetings = vm.Greetings;
    }
}

@page "/"

@using DotNetify
@using DotNetify.Blazor
@inject IDotNetifyService DotNetify

<h3>@greetings</h3>

@code {
    private string greetings;

    protected override async Task OnInitializedAsync()
    {
        var vm = await DotNetify.ConnectAsync<HelloWorldViewModel>(this);
        greetings = vm.Greetings;
    }
}

• Configura la aplicación para utilizar DotNetify, Blazor, Razor Pages y SignalR.
• Configura los puntos finales y el enrutamiento de DotNetify y Blazor.
• Describe un ViewModel básico con un atributo de mensaje de saludo que devuelve.
• Registra HelloWorldViewModel como un servicio.
• El componente Blazor establece una conexión con el HelloWorldViewModel, recupera el texto de bienvenida y lo muestra en la pantalla.

Empezando

Para usar DotNetify e IronPDF, necesita crear un proyecto .NET e incorporar ambas bibliotecas en su aplicación. Aquí hay un tutorial paso a paso para comenzar:

¿Qué es IronPDF?

La biblioteca .NET rica en funciones IronPDF PDF Library permite a los programas C# producir, leer y editar documentos PDF. Con esta biblioteca, los desarrolladores pueden convertir rápidamente información HTML, CSS y JavaScript en PDF de alta calidad listos para imprimir. Las tareas clave incluyen agregar encabezados y pies de página, dividir y unir PDFs, marcar con marcas de agua documentos, y convertir HTML a PDF.

IronPDF es relevante para una variedad de aplicaciones porque soporta tanto .NET Framework como .NET Core. Con su simplicidad de uso y abundante información, los PDFs se pueden integrar fácilmente en los productos de los desarrolladores. IronPDF maneja disposiciones y formatos de datos complejos, asegurando que los PDF que genera se asemejen estrechamente al texto HTML original del cliente. Además, IronPDF apoya aplicaciones multiplataforma como entornos Windows, web y móviles.

Características de IronPDF

• Generación de PDF desde HTML: Convierte JavaScript, HTML, y CSS a PDF. IronPDF soporta consultas de medios y diseño responsivo, dos estándares web contemporáneos. Su soporte para estándares web modernos es útil para decorar dinámicamente facturas PDF, informes y documentos con HTML y CSS.

• Edición de PDF: Se puede añadir texto, imágenes y otros contenidos a PDFs preexistentes. Los desarrolladores pueden usar IronPDF para extraer texto e imágenes de archivos PDF, combinar múltiples PDFs en un archivo, dividir archivos PDF en varios documentos separados, e incluir marcas de agua, anotaciones, encabezados y pies de página.

• Conversión de PDF: Convierte varios formatos de archivos, incluidos Word, Excel y archivos de imagen, al formato PDF. IronPDF también es compatible con la conversión de PDF a imagen (PNG, JPEG, etc.).

• Rendimiento y Fiabilidad: En los entornos industriales se desean cualidades de diseño como alto rendimiento y fiabilidad. Con IronPDF, los desarrolladores pueden gestionar fácilmente grandes conjuntos de documentos.

Instalar IronPDF

Para obtener las herramientas necesarias para trabajar con PDFs en proyectos .NET, instale el paquete IronPDF.

Install-Package IronPdf

Integra DotNetify con IronPDF

Configurar DotNetify:

Configuración de inicio: Abre Startup.cs y configura DotNetify usando los métodos ConfigureServices y Configure.

using DotNetify;
using DotNetify.Blazor;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
        services.AddServerSideBlazor();
        services.AddSignalR();
        services.AddDotNetify();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapBlazorHub();
            endpoints.MapFallbackToPage("/_Host");
            endpoints.MapHub<DotNetifyHub>("/dotnetify");
        });
    }
}

using DotNetify;
using DotNetify.Blazor;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
        services.AddServerSideBlazor();
        services.AddSignalR();
        services.AddDotNetify();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapBlazorHub();
            endpoints.MapFallbackToPage("/_Host");
            endpoints.MapHub<DotNetifyHub>("/dotnetify");
        });
    }
}

Imports DotNetify
Imports DotNetify.Blazor

Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		services.AddRazorPages()
		services.AddServerSideBlazor()
		services.AddSignalR()
		services.AddDotNetify()
	End Sub

	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		If env.IsDevelopment() Then
			app.UseDeveloperExceptionPage()
		Else
			app.UseExceptionHandler("/Error")
			app.UseHsts()
		End If

		app.UseHttpsRedirection()
		app.UseStaticFiles()
		app.UseRouting()
		app.UseEndpoints(Sub(endpoints)
			endpoints.MapBlazorHub()
			endpoints.MapFallbackToPage("/_Host")
			endpoints.MapHub(Of DotNetifyHub)("/dotnetify")
		End Sub)
	End Sub
End Class

Imports DotNetify
Imports DotNetify.Blazor

Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		services.AddRazorPages()
		services.AddServerSideBlazor()
		services.AddSignalR()
		services.AddDotNetify()
	End Sub

	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		If env.IsDevelopment() Then
			app.UseDeveloperExceptionPage()
		Else
			app.UseExceptionHandler("/Error")
			app.UseHsts()
		End If

		app.UseHttpsRedirection()
		app.UseStaticFiles()
		app.UseRouting()
		app.UseEndpoints(Sub(endpoints)
			endpoints.MapBlazorHub()
			endpoints.MapFallbackToPage("/_Host")
			endpoints.MapHub(Of DotNetifyHub)("/dotnetify")
		End Sub)
	End Sub
End Class

Crear un ViewModel

Agregue un nuevo archivo de clase en su proyecto (por ejemplo, PdfViewModel.cs) y cree un ViewModel que producirá un PDF.

using DotNetify;
using IronPdf;

public class PdfViewModel : BaseVM
{
    public string PdfUrl { get; set; }

    public void GeneratePdf()
    {
        // Create a new PDF renderer instance
        var Renderer = new ChromePdfRenderer();

        // Render HTML as a PDF document
        var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");

        // Define the output path for saving the PDF
        var OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf";
        
        // Save the generated PDF document
        PdfDocument.SaveAs(OutputPath);

        // Update the property for the PDF URL
        PdfUrl = "/PdfFiles/HelloWorld.pdf";
        Changed(nameof(PdfUrl));
    }
}

using DotNetify;
using IronPdf;

public class PdfViewModel : BaseVM
{
    public string PdfUrl { get; set; }

    public void GeneratePdf()
    {
        // Create a new PDF renderer instance
        var Renderer = new ChromePdfRenderer();

        // Render HTML as a PDF document
        var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");

        // Define the output path for saving the PDF
        var OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf";
        
        // Save the generated PDF document
        PdfDocument.SaveAs(OutputPath);

        // Update the property for the PDF URL
        PdfUrl = "/PdfFiles/HelloWorld.pdf";
        Changed(nameof(PdfUrl));
    }
}

Imports DotNetify
Imports IronPdf

Public Class PdfViewModel
    Inherits BaseVM

    Public Property PdfUrl As String

    Public Sub GeneratePdf()
        ' Create a new PDF renderer instance
        Dim Renderer = New ChromePdfRenderer()

        ' Render HTML as a PDF document
        Dim PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>")

        ' Define the output path for saving the PDF
        Dim OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf"

        ' Save the generated PDF document
        PdfDocument.SaveAs(OutputPath)

        ' Update the property for the PDF URL
        PdfUrl = "/PdfFiles/HelloWorld.pdf"
        Changed(NameOf(PdfUrl))
    End Sub
End Class

Imports DotNetify
Imports IronPdf

Public Class PdfViewModel
    Inherits BaseVM

    Public Property PdfUrl As String

    Public Sub GeneratePdf()
        ' Create a new PDF renderer instance
        Dim Renderer = New ChromePdfRenderer()

        ' Render HTML as a PDF document
        Dim PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>")

        ' Define the output path for saving the PDF
        Dim OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf"

        ' Save the generated PDF document
        PdfDocument.SaveAs(OutputPath)

        ' Update the property for the PDF URL
        PdfUrl = "/PdfFiles/HelloWorld.pdf"
        Changed(NameOf(PdfUrl))
    End Sub
End Class

Cree un componente Blazor agregando un nuevo componente (por ejemplo, GeneratePdf.razor) y vinculándolo al ViewModel.

@page "/"

@using DotNetify
@using DotNetify.Blazor
@inject IDotNetifyService DotNetify

<PageTitle>Generate PDF</PageTitle>
<h3>Generate PDF</h3>

<button @onclick="GeneratePdf">Generate PDF</button>

@if (!string.IsNullOrEmpty(pdfUrl))
{
    <a href="@pdfUrl" target="_blank">Download PDF</a>
}

@code {
    private string pdfUrl;

    protected override async Task OnInitializedAsync()
    {
        var vm = await DotNetify.ConnectAsync<PdfViewModel>(this);
        pdfUrl = vm.PdfUrl;

        vm.PropertyChanged += (sender, args) =>
        {
            if (args.PropertyName == nameof(vm.PdfUrl))
            {
                pdfUrl = vm.PdfUrl;
                StateHasChanged();
            }
        };
    }

    private void GeneratePdf()
    {
        DotNetify.CallMethod("GeneratePdf");
    }
}

@page "/"

@using DotNetify
@using DotNetify.Blazor
@inject IDotNetifyService DotNetify

<PageTitle>Generate PDF</PageTitle>
<h3>Generate PDF</h3>

<button @onclick="GeneratePdf">Generate PDF</button>

@if (!string.IsNullOrEmpty(pdfUrl))
{
    <a href="@pdfUrl" target="_blank">Download PDF</a>
}

@code {
    private string pdfUrl;

    protected override async Task OnInitializedAsync()
    {
        var vm = await DotNetify.ConnectAsync<PdfViewModel>(this);
        pdfUrl = vm.PdfUrl;

        vm.PropertyChanged += (sender, args) =>
        {
            if (args.PropertyName == nameof(vm.PdfUrl))
            {
                pdfUrl = vm.PdfUrl;
                StateHasChanged();
            }
        };
    }

    private void GeneratePdf()
    {
        DotNetify.CallMethod("GeneratePdf");
    }
}

Al integrar DotNetify e IronPDF en una aplicación Blazor ASP.NET Core de C#, se hace posible el manejo de datos en tiempo real y la producción dinámica de PDF. La configuración comienza con la configuración del proyecto en Startup.cs, donde se registran servicios para Razor Pages, Servidor Blazor, SignalR y DotNetify para habilitar el Blazor del lado del servidor y características en tiempo real.

En PdfViewModel.cs, se define la lógica de generación de PDF de IronPDF. El archivo PDF se puede generar con solo unas pocas líneas de código. La función GeneratePdf convierte contenido HTML en un PDF y actualiza la propiedad PdfUrl, informando al cliente de la nueva ubicación del archivo. La comunicación con el componente GeneratePdf.razor Blazor es manejada por este ViewModel.

El componente se conecta al PdfViewModel a través del IDotNetifyService y se vincula a sus propiedades, permitiendo al cliente llamar a la función GeneratePdf y responder a cambios de propiedad. Cuando los usuarios hacen clic en el botón "Generar PDF", se invoca el método del ViewModel, creando el PDF y actualizando dinámicamente la URL de descarga. Con esta configuración, la aplicación web ofrece una experiencia de usuario receptiva y atractiva al combinar las poderosas capacidades de generación de documentos de IronPDF con la sincronización de datos en tiempo real de DotNetify.

Conclusión

La integración de DotNetify con IronPDF combina la sincronización de datos en tiempo real y la producción dinámica de PDF en una aplicación Blazor ASP.NET Core de C#. DotNetify permite una comunicación sin interrupciones entre los componentes del lado del cliente de Blazor y los ViewModels del lado del servidor, llevando a aplicaciones interactivas y responsivas. Esto es complementado por IronPDF, que proporciona herramientas robustas para crear y modificar PDFs directamente desde la lógica del lado del servidor. Esta combinación poderosa permite el desarrollo de aplicaciones capaces de crear y distribuir documentos personalizados, así como actualizaciones en tiempo real.

Esta integración aprovecha el manejo de datos en tiempo real y las tecnologías de generación de documentos para mejorar la experiencia del usuario, ya sea para informes, facturación u otra tarea relacionada con documentos. Siguiendo los pasos descritos, los desarrolladores pueden configurar y utilizar eficientemente estas herramientas, desbloqueando nuevas posibilidades en el desarrollo moderno de aplicaciones web.

Con IronPDF y las Herramientas de Desarrollo Iron Software, los desarrolladores ansiosos de explorar sus amplias características pueden utilizar funcionalidades como OCR, escaneo de códigos de barras, producción de PDF y más. Las alternativas de licencia proporcionadas relacionadas con el proyecto se especifican en detalle, permitiendo a los desarrolladores elegir el mejor modelo que se adapte a sus necesidades. Las ventajas enumeradas contribuyen a que los desarrolladores entreguen soluciones coordinadas, oportunas y efectivas para una multitud de desafíos.