Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. .NET Ayuda
  4. dotnetify .NET
.NET AYUDA

dotnetify.NET (Cómo Funciona para Desarrolladores)

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
Actualizado:

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 .NET (Cómo Funciona Para Desarrolladores): Figura 1

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.

Creación y configuración de DotNetify en 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 DotNetify.Blazor.

Configurar DotNetify

Para configurar DotNetify, abra Startup.cs y utilice 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");
        });
    }
}
$vbLabelText   $csharpLabel

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!";
}
$vbLabelText   $csharpLabel

Registrar ViewModel

Antes de registrar el ViewModel, abra 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>();
            });
}
$vbLabelText   $csharpLabel

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;
    }
}
  • 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.

dotnetify .NET (Cómo Funciona Para Desarrolladores): Figura 2

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.

dotnetify .NET (Cómo Funciona Para Desarrolladores): Figura 3

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: Abra Startup.cs y configure 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");
        });
    }
}
$vbLabelText   $csharpLabel

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));
    }
}
$vbLabelText   $csharpLabel

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");
    }
}

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 ubicación del nuevo archivo. La comunicación con el componente GeneratePdf.razor Blazor es manejada por este ViewModel.

dotnetify .NET (Cómo Funciona Para Desarrolladores): Figura 4

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.

dotnetify .NET (Cómo Funciona Para Desarrolladores): Figura 5

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.

Preguntas Frecuentes

¿Qué es DotNetify y cómo funciona?

DotNetify es un framework de código abierto construido con .NET y Blazor, diseñado para desarrollar aplicaciones web en tiempo real. Utiliza SignalR para permitir la comunicación en tiempo real entre el cliente y el servidor, facilitando la creación de aplicaciones web dinámicas e interactivas.

¿Cómo puedo integrar aplicaciones web en tiempo real con la generación de PDF en C#?

Al combinar DotNetify para aplicaciones web en tiempo real e IronPDF para la generación de PDFs, los desarrolladores pueden crear aplicaciones interactivas que generan y distribuyen dinámicamente documentos PDF basados en entradas de datos en tiempo real.

¿Qué capacidades ofrece IronPDF para la manipulación de documentos PDF?

IronPDF ofrece capacidades para crear, editar y convertir documentos PDF de manera programática. Permite la conversión de HTML, CSS y JavaScript a PDFs y soporta varias manipulaciones de PDF, lo que lo hace ideal para generar informes y documentos dinámicos.

¿Cómo mejora DotNetify el desarrollo de aplicaciones en tiempo real?

DotNetify mejora el desarrollo de aplicaciones en tiempo real al ofrecer un modelo de programación que sincroniza las vistas del lado del cliente con los datos del lado del servidor, permitiendo la creación de interfaces web interactivas y responsivas. Soporta tanto JavaScript como Blazor para un entorno de desarrollo flexible.

¿Cuáles son los beneficios de usar SignalR en DotNetify?

SignalR en DotNetify permite la comunicación en tiempo real cliente-servidor, lo cual es esencial para crear aplicaciones web interactivas y responsivas. Esto facilita actualizaciones instantáneas e interacciones dinámicas dentro de la aplicación.

¿Cómo puede IronPDF ayudar en la generación de informes dinámicos en una aplicación .NET?

IronPDF puede generar informes dinámicos convirtiendo contenido HTML, incluyendo CSS y JavaScript, en documentos PDF de alta calidad. Esto puede ser particularmente útil para aplicaciones que requieren la generación de informes e invoices basados en datos.

¿Cuál es el papel de los ViewModels en DotNetify?

En DotNetify, los ViewModels se utilizan para manejar la sincronización de datos entre el cliente y el servidor. Facilitan el desarrollo de aplicaciones con interfaces de usuario responsivas al mantener un flujo de datos consistente.

¿Cómo mejora la experiencia del usuario al combinar DotNetify e IronPDF?

Combinar DotNetify con IronPDF mejora la experiencia del usuario al permitir actualizaciones de datos en tiempo real y generación dinámica de PDF dentro de una sola aplicación. Esta integración permite una generación y distribución sin problemas de documentos, mejorando la funcionalidad de la aplicación.

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
  Chatea con el equipo de ingeniería ahora
Director de Tecnología

Jacob Mellor es Director de Tecnología en Iron Software y un ingeniero visionario que lidera la tecnología PDF en C#. Como el desarrollador original detrás de la base de código central de Iron Software, ha moldeado la arquitectura de productos de la compañía desde ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis