dotnetify.NET (Wie es für Entwickler funktioniert)

Einführung

DotNetify ist ein mit .NET und Blazor erstelltes Open-Source-Framework, das für die Erstellung von Echtzeit-Webanwendungen auf einer .NET-Plattform gedacht ist. Die Nutzung der SignalR-Leistung für Echtzeit-Interaktionen zwischen Client und Server erleichtert die Entwicklung dynamischer und interaktiver Webanwendungen. DotNetify ist ein Programmiermodell, das clientseitige Ansichten mit server-seitig daten, die es Entwicklern ermöglichen, schnell und einfach umfangreiche, reaktionsschnelle und leistungsfähige Online-Schnittstellen zu entwerfen.

Umgekehrt, IronPDF ist ein leistungsfähiges .NET-Paket, mit dem sich PDF-Dokumente programmatisch erstellen, bearbeiten und manipulieren lassen. Es ist eine hervorragende Option für die Erstellung dynamischer, datengesteuerter Dokumente wie Berichte, Rechnungen und Formulare, da es eine intuitive API für die Umwandlung von HTML-Text in PDF-Dateien bietet.

Web-Interaktivität in Echtzeit und leistungsstarke PDF-Produktionsfunktionen werden durch die Integration von DotNetify mit IronPDF in einer C#-Anwendung kombiniert. Anwendungen, die eine Echtzeit-Datenanzeige und die Möglichkeit zur dynamischen Erstellung und Verteilung von PDF-Dokumenten auf der Grundlage der neuesten Daten erfordern, werden diese Integration besonders hilfreich finden. Entwickler können umfangreiche, interaktive Online-Anwendungen entwerfen, die komplizierte Geschäftsanforderungen erfüllen und die Benutzererfahrung durch nahtlose Dokumentenerstellung und -verteilung verbessern, indem sie die vielseitige PDF-Erzeugung von IronPDF und die Echtzeit-Datensynchronisation von DotNetify nutzen.

Was ist DotNetify?

DotNetify ist ein Open-Source-Framework, das die Erstellung interaktiver Echtzeit-Webanwendungen mit .NET und Blazor erleichtert. Entwickler können dynamische und reaktionsschnelle Benutzeroberflächen erstellen, die sich mühelos mit serverseitigen Daten synchronisieren, indem sie SignalR verwenden, das die Echtzeitkommunikation zwischen Client und Server erleichtert. DotNetify ist ein reaktiver Programmieransatz, der die Erstellung komplizierter Online-Anwendungen mit wenig Code vereinfacht, indem er die Schwierigkeiten der Echtzeit-Datenbindung und Ereignisbehandlung abstrahiert.

Um sicherzustellen, dass die Benutzeroberfläche immer den aktuellen Stand der Anwendung repräsentiert, ermöglicht DotNetify Entwicklern die Konstruktion von View-Modellen auf dem Server, die Änderungen sofort an den Client weitergeben. Dieses Framework ermöglicht Flexibilität bei der Auswahl der clientseitigen Technologie und unterstützt sowohl klassische JavaScript-Frontends als auch Blazor-Frontends. Aufgrund seiner Benutzerfreundlichkeit und Effektivität eignet es sich perfekt für Anwendungen, die in Echtzeit aktualisiert werden müssen, wie z. B. Dashboards, Tools für die Zusammenarbeit und Live-Datenströme.

Die Echtzeitverarbeitung komplizierter Interaktionen und Datenflüsse durch DotNetify verbessert die Benutzererfahrung erheblich, indem sie eine reibungslose Datensynchronisation und sofortiges Feedback ermöglicht. Alles in allem ist DotNetify eine nützliche Lösung für .NET-Entwickler, die schnell und effektiv reaktive, hochmoderne Echtzeit-Online-Anwendungen erstellen wollen.

Merkmale von DotNetify

Eine Reihe von Funktionen, die DotNetify in C# zur Verfügung stellt, erleichtern die Erstellung interaktiver Online-Anwendungen in Echtzeit. Wichtige Merkmale sind unter anderem:

Echtzeit-Kommunikation: DotNetify nutzt SignalR, um die bidirektionale Echtzeit-Kommunikation zwischen Client und Server zu erleichtern und so interaktive Benutzeroberflächen und schnelle Updates zu ermöglichen.

Reaktives Programmiermodell: Es bietet eine reaktive Programmiermethode, bei der clientseitige Ansichten und serverseitige Ansichtsmodelle automatisch synchronisiert werden, um die Benutzeroberfläche mit den neuesten Informationen auf dem neuesten Stand zu halten.

Serverseitige Ansichtsmodelle: Dies ermöglicht es Entwicklern, serverseitige Ansichtsmodelle zu erstellen, an die sich clientseitige Komponenten binden können, wodurch die Zustandsverwaltung und der Datenfluss innerhalb der Anwendung vereinfacht werden.

Blazor- und JavaScript-Unterstützung: Unterstützt sowohl klassische JavaScript-Frontends als auch Blazor-Frontends, so dass Entwickler die Client-seitige Technologie wählen können, die ihren Anforderungen am besten entspricht.

Einfache Integration: Dank der nahtlosen Integration in bestehende .NET-Anwendungen kann die Echtzeitfunktionalität problemlos zu neuen oder bestehenden Projekten hinzugefügt werden. Es lässt sich auch gut mit Front-End-UI-Komponenten-Frameworks wie WebSockets zur Erstellung einer Webkomponente integrieren und funktioniert mit Projekten, die Software wie React Native, Vue und Blazor verwenden.

Skalierbarkeit: DotNetify, das auf SignalR basiert, erbt dessen Skalierbarkeitsfunktionen, so dass Anwendungen eine große Anzahl gleichzeitiger Verbindungen effektiv verwalten können.

MVVM-Architektur: Unterstützt das Model-View-ViewModel (MVVM) architektur, die die Aufteilung der Verantwortlichkeiten und die saubere, wartbare Organisation des Codes unterstützt.

Ereignisbehandlung: Reduziert die Menge an Boilerplate-Code, der für die Behandlung von UI-Interaktionen und Zustandsänderungen erforderlich ist, indem die Ereignisbehandlung und Datenbindung rationalisiert wird.

Erweiterbar und anpassbar: Bietet Erweiterungspunkte und Hooks, um die Anpassung des Verhaltens und die notwendige Integration mit anderen Bibliotheken oder Frameworks zu ermöglichen.

Starke Infrastruktur: Die DotNetify-Infrastruktur bietet einen dynamischen Routing-Mechanismus, der vollständig im Backend definiert werden kann und unter anderem verschachteltes Routing und Token-basierte Authentifizierung ermöglicht.

Open Source und Community-getrieben: DotNetify ist ein Open-Source-Projekt, das von der Beteiligung und den Beiträgen der Community profitiert, was kontinuierliche Upgrades und Erweiterungen garantiert.

Erstellen und Konfigurieren von DotNetify C#

Um ein einfaches Projekt zu erstellen und mit der Konfiguration von DotNetify in einer C# Online-Anwendung zu beginnen, gehen Sie wie folgt vor. Dieses Tutorial zeigt Ihnen, wie Sie mit ASP.NET Core und Blazor einen einfachen DotNetify-Server und -Client einrichten können.

Einrichten eines neuen ASP.NET Core Blazor Server-Projekts

• Öffnen Sie Visual Studio: Starten Sie Visual Studio und beginnen Sie dann ein neues Projekt.
• Erstellen Sie eine Blazor Server App: Klicken Sie auf "Weiter", nachdem Sie die Blazor Server App-Vorlage aus den Projektvorlagen ausgewählt haben.
• Konfigurieren Sie Ihr Projekt: Geben Sie Ihrem Projekt einen Namen (wie "DotNetifyWebApp") und nehmen Sie die erforderlichen Konfigurationsänderungen vor. Drücken Sie auf "Erstellen"

DotNetify über NuGet installieren

• NuGet-Pakete verwalten: Gehen Sie im Projektmappen-Explorer zu "NuGet-Pakete verwalten", indem Sie mit der rechten Maustaste auf Ihr Projekt klicken.
• Suchen Sie nach DotNetify: Installieren Sie die Pakete DotNetify und DotNetify.Blazor.

DotNetify konfigurieren

Um DotNetify zu konfigurieren, öffnen Sie Startup.cs und verwenden Sie die Methoden ConfigureServices und 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");
        });
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ein ViewModel erstellen

Erstellen Sie eine neue Klassendatei in Ihrem Projekt (HelloWorldViewModel.cs, zum Beispiel) und ein grundlegendes ViewModel entwerfen.

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Register ViewModel

Bevor Sie das ViewModel registrieren, öffnen Sie 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

Blazor-Komponente erstellen

Fügen Sie in Ihrem Projekt eine neue Blazor-Komponente hinzu (wie z. B. HelloWorld.razor) und verbinden es mit dem 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;
    }
}

'INSTANT VB TODO TASK: The following line could not be converted:
page "/" [using] DotNetify [using] DotNetify.Blazor inject IDotNetifyService DotNetify (Of h3) greetings</h3> code
If True Then
	private String greetings
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	protected override async Task OnInitializedAsync()
'	{
'		var vm = await DotNetify.ConnectAsync<HelloWorldViewModel>(Me);
'		greetings = vm.Greetings;
'	}
End If

Richtet die Anwendung für die Verwendung von DotNetify, Blazor, Razor Pages und SignalR ein. Außerdem konfiguriert es DotNetify- und Blazor-Endpunkte und Routing. Beschreibt ein einfaches ViewModel mit einem Attribut für die Rückgabe einer Grußbotschaft. Das HelloWorldViewModel wird als temporärer Dienst registriert. Blazor-Komponente, die eine Verbindung mit dem HelloWorldViewModel herstellt, den Begrüßungstext abruft und ihn auf dem Bildschirm anzeigt.

Erste Schritte

Um DotNetify und IronPDF verwenden zu können, müssen Sie ein .NET-Projekt erstellen und beide Bibliotheken in Ihre Anwendung einbinden. Hier finden Sie eine Schritt-für-Schritt-Anleitung, damit Sie loslegen können:

Was ist IronPDF?

Die funktionsreiche .NET-Bibliothek IronPDF ermöglicht es C#-Programmen, PDF-Dokumente zu erstellen, zu lesen und zu bearbeiten. Mit diesem Programm können Entwickler HTML-, CSS- und JavaScript-Informationen schnell in hochwertige, druckfertige PDF-Dateien umwandeln. Zu den wichtigsten Aufgaben gehören das Hinzufügen von Kopf- und Fußzeilen, das Aufteilen und Kombinieren von PDFs, das Hinzufügen von Wasserzeichen zu Dokumenten und die Konvertierung von HTML in PDF.

IronPDF ist für eine Vielzahl von Anwendungen hilfreich, da es sowohl .NET-Framework als auch .NET Core unterstützt. Dank ihrer einfachen Handhabung und der Fülle an Informationen können Entwickler PDFs problemlos in ihre Produkte integrieren. Da IronPDF mit komplexen Datenlayouts und -formatierungen umgehen kann, sind die von ihm erzeugten PDF-Dateien dem ursprünglichen HTML-Text des Kunden sehr ähnlich. IronPDF unterstützt auch plattformübergreifende Anwendungen wie Windows-, Web- und mobile Umgebungen.

Merkmale von IronPDF

PDF-Erzeugung aus HTML

Konvertieren Sie JavaScript, HTML und CSS in PDF. IronPDF unterstützt Media-Queries und Responsive Design, zwei moderne Webstandards. Die Unterstützung moderner Webstandards ist nützlich, um PDF-Rechnungen, Berichte und Dokumente dynamisch mit HTML und CSS zu gestalten.

PDF-Bearbeitung

Vorhandene PDF-Dateien können mit Text, Bildern und anderen Inhalten versehen werden. Entwickler können mit IronPDF Text und Bilder aus PDF-Dateien herausnehmen, mehrere PDFs in einer Datei zusammenfassen, PDF-Dateien in mehrere separate Dokumente aufteilen und Wasserzeichen, Anmerkungen, Kopf- und Fußzeilen einfügen.

PDF-Konvertierung

Konvertieren Sie verschiedene Dateiformate, darunter Word-, Excel- und Bilddateien, in das PDF-Format. IronPDF unterstützt auch die Konvertierung von PDF in Bilder (PNG, JPEG, usw.).

Leistung und Verlässlichkeit

Hohe Leistung und Zuverlässigkeit sind erwünschte Konstruktionsmerkmale in industriellen Umgebungen. Mit IronPDF können Entwickler große Dokumentensätze mühelos verwalten.

IronPDF installieren

Um die Werkzeuge zu erhalten, die Sie für die Arbeit mit PDFs in .NET-Projekten benötigen, installieren Sie das IronPDF-Paket.

dotnet add package IronPdf

dotnet add package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf

Integration von DotNetify mit IronPDF

DotNetify konfigurieren

Startup-Konfiguration: Öffnen Sie die Datei Startup.cs, und verwenden Sie die Methoden ConfigureServices und Configure, um DotNetify einzurichten.

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Erstellen eines Ansichtsmodells

Fügen Sie in Ihrem Projekt eine neue Klassendatei hinzu (wie z. B. PdfViewModel.cs) und erstellen Sie ein ViewModel, das eine PDF-Datei erzeugt.

using DotNetify;
using IronPdf;
public class PdfViewModel : BaseVM
{
    public string PdfUrl { get; set; }
    public void GeneratePdf()
    {
        var Renderer = new ChromePdfRenderer();
        var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
        var OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf";
        PdfDocument.SaveAs(OutputPath);
        PdfUrl = "/PdfFiles/HelloWorld.pdf";
        Changed(nameof(PdfUrl));
    }
}

using DotNetify;
using IronPdf;
public class PdfViewModel : BaseVM
{
    public string PdfUrl { get; set; }
    public void GeneratePdf()
    {
        var Renderer = new ChromePdfRenderer();
        var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
        var OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf";
        PdfDocument.SaveAs(OutputPath);
        PdfUrl = "/PdfFiles/HelloWorld.pdf";
        Changed(nameof(PdfUrl));
    }
}

Imports DotNetify
Imports IronPdf
Public Class PdfViewModel
	Inherits BaseVM

	Public Property PdfUrl() As String
	Public Sub GeneratePdf()
		Dim Renderer = New ChromePdfRenderer()
		Dim PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>")
		Dim OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf"
		PdfDocument.SaveAs(OutputPath)
		PdfUrl = "/PdfFiles/HelloWorld.pdf"
		Changed(NameOf(PdfUrl))
	End Sub
End Class

Fügen Sie eine neue Blazor-Komponente zu Ihrem Projekt hinzu (wie z. B. GeneratePdf.razor) und binden es an das ViewModel, um eine Blazor-Komponente zu erstellen.

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

'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@page "/" @using DotNetify @using DotNetify.Blazor @inject IDotNetifyService DotNetify (Of PageTitle) Generate PDF</PageTitle> (Of h3) Generate PDF</h3> <button @onclick="GeneratePdf"> Generate PDF</button> @if(!string.IsNullOrEmpty(pdfUrl))
'{
'	<a href="@pdfUrl" target="_blank"> Download PDF</a>
'}
code
If True Then
	private String pdfUrl
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	protected override async Task OnInitializedAsync()
'	{
'		var vm = await DotNetify.ConnectAsync<PdfViewModel>(Me);
'		pdfUrl = vm.PdfUrl;
'		vm.PropertyChanged += (sender, args) =>
'		{
'			if (args.PropertyName == nameof(vm.PdfUrl))
'			{
'				pdfUrl = vm.PdfUrl;
'				StateHasChanged();
'			}
'		};
'	}
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	private void GeneratePdf()
'	{
'		DotNetify.CallMethod("GeneratePdf");
'	}
End If

Die Integration von DotNetify und IronPDF in eine C# ASP.NET Core Blazor-Anwendung ermöglicht eine Datenverarbeitung in Echtzeit und eine dynamische PDF-Produktion. Um serverseitige Blazor- und Echtzeit-Funktionen zu aktivieren, muss das Projekt zunächst in der Datei Startup.cs konfiguriert werden, in der die Dienste für Razor Pages, Blazor Server, SignalR und DotNetify registriert werden.

Die Logik der PDF-Erzeugung von IronPDF ist im ViewModel PdfViewModel.cs definiert. Nur wenige Codezeilen reichen aus, um die PDF-Datei zu erzeugen. Eine der Funktionen ist die GeneratePdf-Funktion, die HTML-Informationen in eine PDF-Datei umwandelt. Sie speichert die Datei auf dem Server und aktualisiert die Eigenschaft PdfUrl, damit der Client weiß, wo sich die neue Datei befindet. Dieses ViewModel kommuniziert mit der Blazor-Komponente GeneratePdf.razor.

Damit der Client die Funktion GeneratePdf aufrufen und auf Eigenschaftsänderungen reagieren kann, verbindet er sich über den IDotNetifyService mit dem PdfViewModel und bindet sich an dessen Eigenschaften. Die Komponente ruft die Methode des ViewModel auf, wenn der Benutzer die Schaltfläche "PDF generieren" betätigt, erstellung der PDF-Datei und die Download-URL dynamisch zu aktualisieren. Mit dieser Konfiguration bietet die Webanwendung eine reaktionsschnelle und ansprechende Benutzererfahrung durch die Integration der leistungsstarken Dokumentenerstellungsfunktionen von IronPDF mit der Echtzeit-Datensynchronisation von DotNetify.

Schlussfolgerung

Echtzeit-Datensynchronisation und dynamische PDF-Produktion werden durch die Integration von DotNetify mit IronPDF in einer C# ASP.NET Core Blazor Anwendung kombiniert. Interaktive und reaktionsfähige Anwendungen werden durch DotNetify ermöglicht, das eine reibungslose Kommunikation zwischen clientseitigen Blazor-Komponenten und serverseitigen ViewModels ermöglicht. IronPDF bietet leistungsstarke Werkzeuge für die Erstellung und Änderung von PDF-Dateien direkt von der Server-Logik aus. Mit Hilfe dieses potenten Mixes können Entwickler Anwendungen erstellen, die einzigartige Dokumente sowie Updates in Echtzeit erstellen und versenden können.

Diese Integration nutzt die Vorteile der Echtzeit-Datenverarbeitung und der dokumentenerzeugenden Technologien, um die Benutzerfreundlichkeit zu verbessern, sei es bei der Berichterstellung, der Rechnungsstellung oder bei anderen dokumentenbezogenen Vorgängen. Entwickler können diese Tools schnell und einfach einrichten und verwenden, indem sie die aufgeführten Verfahren befolgen, was eine Welt der Möglichkeiten für die Entwicklung moderner Webanwendungen eröffnet.

Mit IronPDF können Sie OCR, Barcode-Scannen, PDF-Produktion, Excel-Anbindung und vieles mehr nutzen und IronSoftware für Entwickler, die die umfangreichen Funktionen ausprobieren möchten.

Wenn die Lizenzalternativen für das Projekt detailliert beschrieben werden, fällt es den Entwicklern leichter, das beste Modell zu wählen. Die genannten Vorteile erleichtern den Entwicklern die rechtzeitige, koordinierte und effektive Umsetzung von Lösungen für eine Vielzahl von Problemen.