dotnetify.NET (Jak to dziala dla programistow)

Aby założyć prosty projekt i rozpocząć konfigurację DotNetify w aplikacji internetowej C#, wykonaj poniższe kroki. Ten samouczek demonstruje, jak skonfigurować podstawowy serwer i klienta DotNetify przy użyciu ASP.NET Core i Blazor.

Skonfiguruj nowy projekt Blazor Server w ASP.NET Core

1. Otwórz Visual Studio: Uruchom Visual Studio i utwórz nowy projekt.
2. Utwórz aplikację Blazor Server: Wybierz szablon aplikacji Blazor Server z listy szablonów projektów i kliknij „Dalej".
3. Skonfiguruj projekt: Podaj nazwę projektu (np. „DotNetifyWebApp") i wprowadź niezbędne zmiany w konfiguracji. Kliknij „Utwórz".

Zainstaluj DotNetify za pomocą NuGet

1. Zarządzaj pakietami NuGet: W oknie Solution Explorer kliknij prawym przyciskiem myszy projekt i wybierz opcję „Manage NuGet Packages".
2. Wyszukaj DotNetify: Zainstaluj pakiety DotNetify i DotNetify.Blazor.

Skonfiguruj DotNetify

Aby skonfigurować DotNetify, otwórz plik Startup.cs i użyj metod ConfigureServices oraz 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

Utwórz ViewModel

Utwórz nowy plik klasy w swoim projekcie (np. HelloWorldViewModel.cs) i zaprojektuj podstawowy ViewModel.

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

Zarejestruj ViewModel

Przed zarejestrowaniem ViewModelu otwórz plik 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

Utwórz komponent Blazor

W swoim projekcie dodaj nowy komponent Blazor (np. HelloWorld.razor) i połącz go z 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;
    }
}

• Konfiguruje aplikację do używania DotNetify, Blazor, Razor Pages i SignalR.
• Konfiguruje punkty końcowe i routing DotNetify oraz Blazor.
• Definiuje podstawowy ViewModel z atrybutem zwracającym komunikat powitalny.
• Rejestruje HelloWorldViewModel jako usługę.
• Komponent Blazor nawiązuje połączenie z HelloWorldViewModel, pobiera tekst powitalny i wyświetla go na ekranie.

Zainstaluj pakiet IronPDF, aby uzyskać narzędzia potrzebne do pracy z plikami PDF w projektach .NET.

Install-Package IronPdf

Integracja DotNetify z IronPDF

Konfiguracja DotNetify:

Konfiguracja startowa: Otwórz plik Startup.cs i skonfiguruj DotNetify za pomocą metod ConfigureServices i 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

Utwórz ViewModel

Dodaj nowy plik klasy do projektu (np. PdfViewModel.cs) i utwórz ViewModel, który będzie generował plik 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

Utwórz komponent Blazor, dodając nowy komponent (np. GeneratePdf.razor) i wiążąc go z 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");
    }
}

Integracja DotNetify z IronPDF w aplikacji C# ASP.NET Core Blazor umożliwia obsługę danych w czasie rzeczywistym i dynamiczne generowanie plików PDF. Konfiguracja rozpoczyna się od ustawienia projektu w pliku Startup.cs, gdzie rejestrowane są usługi dla Razor Pages, Blazor Server, SignalR i DotNetify w celu włączenia funkcji Blazor po stronie serwera i czasu rzeczywistego.

W pliku PdfViewModel.cs zdefiniowana jest logika generowania plików PDF przez IronPDF. Plik PDF można wygenerować za pomocą zaledwie kilku linii kodu. Funkcja GeneratePdf konwertuje treść HTML na plik PDF i aktualizuje właściwość PdfUrl, informując klienta o lokalizacji nowego pliku. Komunikacją z komponentem Blazor GeneratePdf.razor zarządza ten ViewModel.

Komponent łączy się z PdfViewModel przez IDotNetifyService i wiąże się z jego właściwościami, umożliwiając klientowi wywołanie funkcji GeneratePdf i reagowanie na zmiany właściwości. Gdy użytkownicy klikają przycisk „Generate PDF", wywoływana jest metoda ViewModelu, która tworzy plik PDF i dynamicznie aktualizuje adres URL pobierania. W tej konfiguracji aplikacja internetowa zapewnia responsywne i angażujące doświadczenie użytkownika, łącząc potężne możliwości generowania dokumentów IronPDF z synchronizacją danych w czasie rzeczywistym DotNetify.