ATUALIZAÇÕES DO DESENVOLVEDOR

dotnetify.NET (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Updated: 23 de abril de 2026

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.

dotnetify .NET (Como Funciona para Desenvolvedores): Figura 1

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

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

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

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

dotnetify .NET (Como Funciona para Desenvolvedores): Figura 2

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.

dotnetify .NET (Como Funciona para Desenvolvedores): Figura 3

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 .

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

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

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

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.

dotnetify .NET (Como Funciona para Desenvolvedores): Figura 4

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.

dotnetify .NET (Como Funciona para Desenvolvedores): Figura 5

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.

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

Leia mais

Artigos relacionados