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

Um ein einfaches Projekt zu erstellen und mit der Konfiguration von DotNetify in einer C#-Online-Anwendung zu beginnen, befolgen Sie diese Schritte. Dieses Tutorial zeigt, wie man mit ASP.NET Core und Blazor einen grundlegenden DotNetify-Server und -Client einrichtet.

Einrichten eines neuen ASP.NET Core Blazor Server-Projekts

1. Visual Studio öffnen: Starten Sie Visual Studio und erstellen Sie ein neues Projekt.
2. Erstellen einer Blazor Server App: Wählen Sie die Vorlage "Blazor Server App" aus den Projektvorlagen aus und klicken Sie auf "Weiter".
3. Konfigurieren Sie Ihr Projekt: Geben Sie Ihrem Projekt einen Namen (z. B. "DotNetifyWebApp") und nehmen Sie die erforderlichen Konfigurationsänderungen vor. Klicken Sie auf "Erstellen".

DotNetify über NuGet installieren

1. NuGet-Pakete verwalten: Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt und wählen Sie "NuGet-Pakete verwalten".
2. Suchen Sie nach DotNetify: Installieren Sie die Pakete DotNetify und DotNetify.Blazor.

Konfigurieren Sie DotNetify

Um DotNetify zu konfigurieren, öffnen Sie Startup.cs und verwenden Sie die ConfigureServices und Configure-Methoden.

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

Erstellen eines ViewModels

Erstellen Sie eine neue Klassendatei in Ihrem Projekt (z.B. HelloWorldViewModel.cs) und entwerfen Sie ein einfaches ViewModel.

using DotNetify;

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

using DotNetify;

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

ViewModel registrieren

Öffnen Sie vor der Registrierung des ViewModels 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>();
            });
}

Blazor-Komponente erstellen

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

• Richtet die Anwendung so ein, dass DotNetify, Blazor, Razor Pages und SignalR genutzt werden können.
• Konfiguriert DotNetify- und Blazor-Endpunkte und das Routing.
• Beschreibt ein einfaches ViewModel mit einem Attribut, das eine Begrüßungsnachricht zurückgibt.
• Registriert das HelloWorldViewModel als Dienst.
• Die Blazor-Komponente stellt eine Verbindung mit dem HelloWorldViewModel her, ruft den Begrüßungstext ab und zeigt ihn auf dem Bildschirm an.

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

Install-Package IronPdf

Integration von DotNetify mit IronPDF

DotNetify konfigurieren:

Startup-Konfiguration: Öffnen Sie Startup.cs und konfigurieren Sie DotNetify mit den 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");
        });
    }
}

Erstellen eines ViewModels

Fügen Sie Ihrem Projekt eine neue Klassendatei hinzu (z.B. PdfViewModel.cs) und erstellen Sie ein ViewModel, das PDF generieren wird.

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

Erstellen Sie eine Blazor-Komponente, indem Sie eine neue Komponente hinzufügen (z.B. GeneratePdf.razor) und sie mit dem ViewModel verbinden.

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

Durch die Integration von DotNetify und IronPDF in einer C# ASP.NET Core Blazor-Anwendung werden Echtzeitdatenverarbeitung und dynamische PDF-Erstellung ermöglicht. Die Einrichtung beginnt mit der Konfiguration des Projekts in Startup.cs, wo Dienste für Razor Pages, Blazor Server, SignalR und DotNetify registriert werden, um serverseitige Blazor- und Echtzeitfunktionen zu aktivieren.

In PdfViewModel.cs wird die PDF-Erstellungslogik von IronPDF definiert. Die PDF-Datei kann mit nur wenigen Zeilen Code erstellt werden. Die GeneratePdf-Funktion wandelt HTML-Inhalte in ein PDF um und aktualisiert die PdfUrl-Eigenschaft, um den Client über den neuen Speicherort der Datei zu informieren. Die Kommunikation mit der GeneratePdf.razor Blazor-Komponente wird von diesem ViewModel gehandhabt.

Die Komponente verbindet sich über den IDotNetifyService mit dem PdfViewModel und bindet sich an seine Eigenschaften, wodurch der Client die Funktion GeneratePdf aufrufen und auf Eigenschaftsänderungen reagieren kann. Wenn Benutzer auf den "Generate PDF"-Button klicken, wird die Methode des ViewModels aufgerufen, um das PDF zu erstellen und die Download-URL dynamisch zu aktualisieren. Mit dieser Konfiguration liefert die Webanwendung eine responsive und ansprechende Benutzererfahrung, indem IronPDF's leistungsfähige Dokumenterstellungsfähigkeiten mit DotNetify's Echtzeit-Datensynchronisierung kombiniert werden.