DotNetify é um framework de código aberto desenvolvido com .NET e Blazor , projetado para criar aplicações web em tempo real em uma plataforma .NET . Ao utilizar o poder do SignalR para interações em tempo real entre o cliente e o servidor, simplifica-se a construção de aplicações web dinâmicas e interativas. O DotNetify oferece um modelo de programação que sincroniza as visualizações do lado do cliente com os dados de script do lado do servidor , permitindo que os desenvolvedores criem interfaces online ricas, responsivas e de alto desempenho de forma rápida e fácil.

Por outro lado, a biblioteca IronPDF PDF Generation Library é um pacote .NET poderoso que facilita a criação, edição e manipulação programática de documentos PDF. É uma excelente opção para criar documentos dinâmicos e baseados em dados, como relatórios, faturas e formulários, oferecendo uma API intuitiva para transformar texto HTML em PDFs.

Ao integrar o DotNetify com o IronPDF, a interatividade web em tempo real e os recursos robustos de produção de PDFs são combinados em um aplicativo C#. Essa integração é particularmente benéfica para aplicações que exigem a exibição de dados em tempo real e a capacidade de criar e distribuir documentos PDF dinamicamente com base nos dados mais recentes. Os desenvolvedores podem criar aplicativos online interativos e abrangentes que atendem a requisitos de negócios complexos e aprimoram as experiências do usuário por meio da geração e distribuição perfeitas de documentos, aproveitando a versátil geração de PDFs do IronPDF e a sincronização de dados em tempo real do DotNetify.

O que é DotNetify?

DotNetify é um framework de código aberto projetado para simplificar a criação de aplicativos web interativos e em tempo real com .NET e Blazor. Os desenvolvedores podem criar interfaces de usuário dinâmicas e responsivas que se sincronizam facilmente com os dados do servidor utilizando o SignalR, facilitando a comunicação em tempo real entre o cliente e o servidor. O DotNetify utiliza uma abordagem de programação reativa, abstraindo as complexidades da vinculação de dados em tempo real e do tratamento de eventos, simplificando assim a criação de aplicações online complexas com o mínimo de código.

O DotNetify permite que os desenvolvedores criem modelos de visualização (view models) no servidor que propagam imediatamente as alterações para o cliente, garantindo que a interface do usuário sempre reflita o estado do aplicativo. Essa estrutura oferece flexibilidade na escolha da tecnologia do lado do cliente, suportando tanto front-ends JavaScript clássicos quanto front-ends Blazor . É ideal para aplicações que exigem atualizações em tempo real, como painéis de controle, ferramentas colaborativas e fluxos de dados ao vivo, devido à sua facilidade de uso e eficácia.

O processamento em tempo real de interações complexas e fluxos de dados pelo DotNetify aprimora significativamente a experiência do usuário, permitindo uma sincronização de dados fluida e feedback imediato. Em resumo, o DotNetify é uma ferramenta valiosa para desenvolvedores .NET que desejam criar aplicativos online reativos, de ponta e em tempo real de forma rápida e eficiente.

Funcionalidades do DotNetify

O DotNetify em C# oferece uma infinidade de recursos que simplificam a criação de aplicativos online interativos e em tempo real, incluindo:

• Comunicação em tempo real: Utiliza SignalR para comunicação bidirecional em tempo real entre cliente e servidor, permitindo interfaces de usuário interativas e atualizações instantâneas.
• Modelo de Programação Reativa: Oferece um modelo de programação reativa, sincronizando automaticamente as visualizações do lado do cliente e os modelos de visualização do lado do servidor para manter a interface do usuário atualizada com as informações mais recentes.
• Modelos de visualização do lado do servidor: Facilita a criação de modelos de visualização do lado do servidor aos quais os componentes do lado do cliente podem se vincular, simplificando o gerenciamento de estado e o fluxo de dados dentro do aplicativo.
• Suporte para Blazor e JavaScript : Suporta tanto front-ends JavaScript clássicos quanto front-ends Blazor , permitindo que os desenvolvedores escolham a tecnologia do lado do cliente que melhor se adapte às suas necessidades.
• Facilidade de integração: Integra perfeitamente funcionalidades em tempo real em projetos novos ou existentes e funciona bem com frameworks de componentes de interface de usuário front-end, como WebSockets, combinando com projetos que utilizam React Native, Vue e Blazor.
• Escalabilidade: Herda os recursos de escalabilidade do SignalR, permitindo que os aplicativos gerenciem muitas conexões simultâneas com eficiência.
• Arquitetura MVVM: Adota a arquitetura Model-View-ViewModel (MVVM), auxiliando na separação de responsabilidades e na manutenção de um código organizado e limpo.
• Tratamento de eventos: Reduz o código repetitivo necessário para lidar com interações da interface do usuário e mudanças de estado, simplificando o tratamento de eventos e a vinculação de dados.
• Extensível e personalizável: Oferece pontos de extensibilidade e mecanismos para personalização de comportamento e integração necessária com outras bibliotecas ou frameworks.
• Infraestrutura robusta: Oferece um mecanismo de roteamento dinâmico que pode ser totalmente definido no back-end, capaz de roteamento aninhado, autenticação baseada em token e muito mais.
• Código aberto e orientado pela comunidade: Como um projeto de código aberto, o DotNetify se beneficia da participação e das contribuições da comunidade, garantindo atualizações e melhorias contínuas.

Creating and Configuring DotNetify in C#

Para criar um projeto simples e começar a configurar o DotNetify em uma aplicação online em C#, siga estes passos. Este tutorial demonstra como usar ASP.NET Core e Blazor para configurar um servidor e um cliente DotNetify básicos.

Configurar um novo projeto de servidor ASP.NET Core Blazor

1. Abra o Visual Studio: Inicie o Visual Studio e crie um novo projeto.
2. Criar um aplicativo Blazor Server: Escolha o modelo de aplicativo Blazor Server nos modelos de projeto e clique em "Avançar".
3. Configure seu projeto: Forneça um nome para o seu projeto (por exemplo, "DotNetifyWebApp") e faça as alterações de configuração necessárias. Clique em "Criar".

Instale o DotNetify via NuGet.

1. Gerenciar pacotes NuGet : No Solution Explorer, clique com o botão direito do mouse no seu projeto e escolha "Gerenciar pacotes NuGet ".
2. Procure por DotNetify: Instale os pacotes DotNetify e Blazor .

Configure o DotNetify

Para configurar o DotNetify, abra Startup.cs e utilize os métodos ConfigureServices e 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

Criar um ViewModel

Crie um novo arquivo de classe em seu projeto (por exemplo, HelloWorldViewModel.cs) e projete um 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 o 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>();
            });
}

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

Criar componente Blazor

No seu projeto, adicione um novo componente Blazor (como Razor) e conecte-o ao 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 a aplicação para utilizar DotNetify, Blazor, Razor Pages e SignalR.
• Configura os endpoints e o roteamento do DotNetify e do Blazor .
• Descreve um ViewModel básico com um atributo que retorna uma mensagem de saudação.
• Registra o HelloWorldViewModel como um serviço. O componente Blazor estabelece uma conexão com o HelloWorldViewModel, recupera o texto de boas-vindas e o exibe na tela.

Começando

Para usar o DotNetify e o IronPDF, você precisa criar um projeto .NET e incorporar ambas as bibliotecas em sua aplicação. Aqui está um tutorial passo a passo para você começar:

O que é o IronPDF?

A biblioteca IronPDF PDF Library for .NET , rica em recursos, permite que programas em C# criem, leiam e editem documentos PDF. Com esta biblioteca, os desenvolvedores podem converter rapidamente informações de HTML, CSS e JavaScript em PDFs de alta qualidade e prontos para impressão. As principais tarefas incluem adicionar cabeçalhos e rodapés, dividir e mesclar PDFs, inserir marcas d'água em documentos e converter HTML para PDF.

O IronPDF é relevante para uma variedade de aplicações porque oferece suporte tanto ao .NET Framework quanto ao .NET Core. Graças à sua simplicidade de uso e à abundância de informações, os PDFs podem ser facilmente integrados aos produtos dos desenvolvedores. O IronPDF lida com layouts e formatação de dados complexos, garantindo que os PDFs gerados sejam muito semelhantes ao texto HTML original do cliente. Além disso, o IronPDF oferece suporte a aplicativos multiplataforma, como ambientes Windows, web e móveis.

Funcionalidades do IronPDF

• Geração de PDF a partir de HTML: Converta JavaScript, HTML e CSS em PDF. O IronPDF oferece suporte a media queries e design responsivo, dois padrões web contemporâneos. O suporte aos padrões modernos da web é útil para decorar dinamicamente faturas, relatórios e documentos em PDF com HTML e CSS.

• Edição de PDF: É possível adicionar texto, imagens e outros conteúdos a PDFs já existentes. Os desenvolvedores podem usar o IronPDF para extrair texto e imagens de arquivos PDF, combinar vários PDFs em um único arquivo, dividir arquivos PDF em vários documentos separados e incluir marcas d'água, anotações, cabeçalhos e rodapés.

• Conversão para PDF: Converta diversos formatos de arquivo, incluindo arquivos Word, Excel e imagens, para o formato PDF. O IronPDF também suporta a conversão de PDF para imagem (PNG, JPEG, etc.).

Desempenho e confiabilidade: Alto desempenho e confiabilidade são qualidades desejáveis ​​em projetos de ambientes industriais. Com o IronPDF, os desenvolvedores podem gerenciar grandes conjuntos de documentos com facilidade.

Instale o IronPDF

Para obter as ferramentas necessárias para trabalhar com PDFs em projetos .NET , instale o pacote IronPDF .

Install-Package IronPdf

Integre o DotNetify com o IronPDF

Configurar o DotNetify:

Configuração de Inicialização: Abra Startup.cs e configure o DotNetify usando os métodos ConfigureServices e 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

Criar um ViewModel

Adicione um novo arquivo de classe ao seu projeto (por exemplo, PdfViewModel.cs) e crie um ViewModel que irá gerar um 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

Crie um componente Blazor adicionando um novo componente (por exemplo, Razor) e vinculando-o ao 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");
    }
}

Ao integrar o DotNetify e o IronPDF em uma aplicação C# ASP.NET Core Blazor , torna-se possível o processamento de dados em tempo real e a produção dinâmica de PDFs. A configuração começa com a configuração do projeto no arquivo Startup.cs, onde os serviços para Razor Pages, Blazor Server, SignalR e DotNetify são registrados para habilitar recursos do Blazor no lado do servidor e recursos em tempo real.

No arquivo PdfViewModel.cs, está definida a lógica de geração de PDF do IronPDF. O arquivo PDF pode ser gerado com apenas algumas linhas de código. A função GeneratePdf converte o conteúdo HTML em um PDF e atualiza a propriedade PdfUrl, informando o cliente sobre a localização do novo arquivo. A comunicação com o componente Razor Blazor é gerenciada por este ViewModel.

O componente se conecta ao PdfViewModel via o IDotNetifyService e vincula-se às suas propriedades, permitindo que o cliente chame a função GeneratePdf e responda a alterações de propriedades. Quando os usuários clicam no botão "Gerar PDF", o método do ViewModel é invocado, criando o PDF e atualizando dinamicamente o URL de download. Com essa configuração, o aplicativo web oferece uma experiência de usuário responsiva e envolvente, combinando os poderosos recursos de geração de documentos do IronPDF com a sincronização de dados em tempo real do DotNetify.

Conclusão

A integração do DotNetify com o IronPDF combina a sincronização de dados em tempo real e a produção dinâmica de PDFs em uma aplicação C# ASP.NET Core Blazor . O DotNetify permite a comunicação perfeita entre componentes Blazor do lado do cliente e ViewModels do lado do servidor, resultando em aplicações interativas e responsivas. Isso é complementado pelo IronPDF, que fornece ferramentas robustas para criar e modificar PDFs diretamente da lógica do lado do servidor. Essa poderosa combinação permite o desenvolvimento de aplicativos capazes de criar e distribuir documentos personalizados, bem como atualizações em tempo real.

Essa integração aproveita as tecnologias de processamento de dados em tempo real e geração de documentos para aprimorar a experiência do usuário, seja para relatórios, faturamento ou qualquer outra tarefa relacionada a documentos. Seguindo os passos descritos, os desenvolvedores podem configurar e utilizar essas ferramentas de forma eficiente, abrindo novas possibilidades no desenvolvimento de aplicações web modernas.

Com o IronPDF e as Ferramentas de Desenvolvimento de Iron Software , os desenvolvedores interessados ​​em explorar seus amplos recursos podem utilizar funcionalidades como OCR, leitura de código de barras, produção de PDFs e muito mais. As alternativas de licenciamento relacionadas ao projeto são especificadas em detalhes, permitindo que os desenvolvedores escolham o modelo mais adequado às suas necessidades. As vantagens listadas contribuem para que os desenvolvedores ofereçam soluções oportunas, coordenadas e eficazes para uma infinidade de desafios.