Aradığınızı bulamadınız mı?
Mesaj simgesi
Altbilgi içeriğine atla
  1. IronPDF
  2. IronPDF Blogu
  3. .NET Yardım
  4. dotnetify .NET
.NET YARDıM

dotnetify.NET (Geliştiriciler İçin Nasıl Çalışır)

Jacob Mellor, Teknoloji Direktörü @ Team Iron
Jacob Mellor
Güncellendi:

DotNetify, gerçek zamanlı web uygulamaları oluşturmak için .NET ve Blazor ile yapılan açık kaynak bir çerçevedir. SignalR'ın gücünden yararlanarak istemci ve sunucu arasındaki gerçek zamanlı etkileşimleri basitleştirir, bu da dinamik ve etkileşimli web uygulamalarının oluşturulmasını kolaylaştırır. DotNetify, istemci tarafı görünümlerin sunucu tarafı betik verileri ile senkronize edilmesini sağlayan bir programlama modeli sunarak, geliştiricilerin hızlı ve kolayca zengin, duyarlı ve performanslı çevrimiçi arayüzler tasarlamalarını sağlar.

Buna karşılık, IronPDF PDF Generation Library, programatik olarak PDF belgeleri oluşturmayı, düzenlemeyi ve yönetmeyi kolaylaştıran güçlü bir .NET paketidir. Raporlar, faturalar ve formlar gibi dinamik, veri odaklı belgeler oluşturmak için mükemmel bir seçim olup, HTML metnini PDF'lere dönüştürmek için sezgisel bir API sunar.

DotNetify ve IronPDF'i entegre ederek, gerçek zamanlı web etkileşimi ve güçlü PDF üretim yetenekleri C# uygulamasında birleşir. Bu entegrasyon, gerçek zamanlı veri görüntüleme ve en son verilere dayalı olarak dinamik PDF belgeleri oluşturma ve dağıtma yeteneği gerektiren uygulamalar için özellikle faydalıdır. Geliştiriciler, IronPDF'in esnek PDF oluşturma yeteneklerinden ve DotNetify'ın gerçek zamanlı veri senkronizasyonundan yararlanarak karmaşık iş gereksinimlerini karşılayan ve kullanıcılara iyi bir deneyim sunan kapsamlı, etkileşimli çevrimiçi uygulamalar oluşturabilirler.

DotNetify Nedir?

DotNetify, .NET ve Blazor ile etkileşimli, gerçek zamanlı web uygulamaları oluşturmayı basitleştirmek için tasarlanmış açık kaynaklı bir çerçevedir. SignalR kullanarak geliştiriciler, istemci ve sunucu arasında gerçek zamanlı iletişimi kolaylaştırarak istemci tarafı verileriyle otomatik olarak senkronize olan dinamik ve duyarlı kullanıcı arayüzleri oluşturabilirler. DotNetify, gerçek zamanlı veri bağlama ve olay işleme karmaşıklıklarını soyutlayan bir tepkisel programlama yaklaşımı kullanarak, minimal kod ile karmaşık çevrimiçi uygulamalar oluşturmayı kolaylaştırır.

dotnetify .NET (Geliştiriciler İçin Nasıl Çalışır): Şekil 1

DotNetify, geliştiricilerin sunucu tarafı görünüm modelleri oluşturmasına olanak tanır, böylece değişiklikler hemen istemciye iletilir ve kullanıcı arayüzü her zaman uygulamanın durumunu yansıtır. Bu çerçeve, hem klasik JavaScript ön uçları hem de Blazor ön uçlarını destekleyerek, istemci tarafındaki teknoloji seçiminde esneklik sunar. Gerçek zamanlı güncellemeler gerektiren uygulamalar, örneğin kontrol panelleri, işbirlikçi araçlar ve canlı veri akışları, kullanım kolaylığı ve etkinliği nedeniyle idealdir.

DotNetify'nin karmaşık etkileşimleri ve veri akışlarını gerçek zamanlı olarak ele alması, kullanıcı deneyimini pürüzsüz veri senkronizasyonu ve anında geri bildirimle önemli ölçüde artırır. Genel olarak, DotNetify, hızlı ve verimli bir şekilde reaktif, modern ve gerçek zamanlı çevrimiçi uygulamalar inşa etmek için hedefleyen .NET geliştiricileri için değerli bir araçtır.

DotNetify'nin Özellikleri

C# içinde DotNetify, etkileşimli, gerçek zamanlı çevrimiçi uygulamalar oluşturmayı basitleştiren bir dizi özelliğe sahiptir, bunlar arasında:

  • Gerçek Zamanlı İletişim: Etkileşimli kullanıcı arayüzleri ve anında güncellemeler sağlayan çift yönlü, gerçek zamanlı istemci-sunucu iletişimi için SignalR kullanır.
  • Tepkisel Programlama Modeli: İstemci tarafı görünümleri ve sunucu tarafı görünüm modellerini otomatik olarak senkronize eden, kullanıcı arayüzünü en güncel bilgiyle tutan bir tepkisel programlama modeli sağlar.
  • Sunucu Tarafı Görünüm Modelleri: İstemci tarafı bileşenlerin bağlanabileceği sunucu tarafı görünüm modelleri oluşturmayı kolaylaştırarak, uygulama içinde durum yönetimini ve veri akışını basitleştirir.
  • Blazor ve JavaScript Desteği: Hem klasik JavaScript ön uçları hem de Blazor ön uçlarını destekleyerek, geliştiricilerin gereksinimlerine en uygun olan istemci tarafı teknolojisini seçmelerine olanak tanır.
  • Entegrasyon Kolaylığı: Yeni veya mevcut projelere gerçek zamanlı işlevselliği sorunsuz bir şekilde entegre eder ve React Native, Vue ve Blazor gibi projelerle karışan WebSockets gibi ön uç UI bileşen çerçeveleriyle iyi çalışır.
  • Ölçeklenebilirlik: Uygulamaların birçok eş zamanlı bağlantıyı etkin bir şekilde yönetmesini sağlayan SignalR'ın ölçeklenebilirlik özelliklerini miras alır.
  • MVVM Mimarisi: Sorumlulukları ayırmaya ve organize ve temiz kodu korumaya yardımcı olan Model-Görünüm-Görünüm Modeli (MVVM) mimarisini kabul eder.
  • Olay İşleme: Arayüz etkileşimlerinin ve durum değişikliklerinin işlenmesi için gerekli olan şablon kodunu azaltarak olay işleme ve veri bağlamayı düzene koyar.
  • Genişletilebilir ve Özelleştirilebilir: Diğer kütüphaneler veya çerçeveler ile gerekli entegrasyon ve davranış özelleştirilmesi için genişletilebilirlik noktaları ve kancalar sağlar.
  • Sağlam Altyapı: Arkada tamamen tanımlanabilecek dinamik bir yönlendirme mekanizması sunar, iç içe geçmiş yönlendirme, belirteç tabanlı kimlik doğrulama ve daha fazlasını yapabilme kapasitesine sahiptir.
  • Açık Kaynak ve Topluluk Tabánlı: Açık kaynaklı bir proje olarak, DotNetify, devam eden yükseltmeler ve iyileştirmeler sağlayan topluluk katılımı ve katkılarından yararlanır.

Creating and Configuring DotNetify in C

Basit bir proje oluşturmak ve C# çevrimiçi uygulamanızda DotNetify'yi yapılandırmaya başlamak için bu adımları takip edin. Bu öğretici, temel bir DotNetify sunucusu ve istemcisinin nasıl kurulacağını göstermek için ASP.NET Core ve Blazor kullanımını gösterir.

Yeni Bir ASP.NET Core Blazor Sunucu Projesi Kurma

  1. Visual Studio'yu Açın: Visual Studio'yu başlatın ve yeni bir proje oluşturun.
  2. Bir Blazor Sunucu Uygulaması Oluşturun: Proje şablonlarından Blazor Sunucu Uygulaması şablonunu seçin ve "İleri"ye tıklayın.
  3. Projenizi Yapılandırın: Projenize bir ad verin (örneğin, "DotNetifyWebApp") ve gerekli yapılandırma değişikliklerini yapın. "Oluştur"a tıklayın.

NuGet Üzerinden DotNetify Kurun

  1. NuGet Paketlerini Yönet: Çözüm Gezgini'nde projenize sağ tıklayın ve "NuGet Paketlerini Yönet" seçeneğini seçin.
  2. DotNetify'i Arayın: DotNetify ve DotNetify.Blazor paketlerini kurun.

DotNetify'yi Yapılandır

DotNetify'yi yapılandırmak için Startup.cs dosyasını açın ve ConfigureServices ve Configure metodlarını kullanın.

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
$vbLabelText   $csharpLabel

Bir Görünüm Modeli Oluşturun

Projenizde yeni bir sınıf dosyası (örneğin, HelloWorldViewModel.cs) oluşturun ve temel bir Görünüm Modeli tasarlayın.

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
$vbLabelText   $csharpLabel

Görünüm Modeli Kaydedin

ViewModel'i kaydetmeden önce Program.cs dosyasını açın.

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
$vbLabelText   $csharpLabel

Blazor Bileşeni Oluştur

Projenize yeni bir Blazor bileşeni (örneğin, HelloWorld.razor) ekleyin ve Görünüm Modeline bağlayın.

@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;
    }
}
  • Uygulamanın DotNetify, Blazor, Razor Pages ve SignalR'nin kullanılacak şekilde ayarlanmasını sağlar.
  • DotNetify ve Blazor uç noktalarını ve yönlendirmeyi yapılandırır.
  • Selam mesajı döndüren bir özniteliğe sahip basit bir Görünüm Modelini tanımlar.
  • HelloWorldViewModel'i bir hizmet olarak kaydeder.
  • Blazor bileşeni, HelloWorldViewModel ile bağlantı kurar, hoş geldiniz metnini alır ve ekranda görüntüler.

dotnetify .NET (Geliştiriciler İçin Nasıl Çalışır): Şekil 2

Başlarken

DotNetify ve IronPDF'i kullanabilmek için bir .NET projesi oluşturmalı ve her iki kütüphaneyi de uygulamanıza dahil etmelisiniz. İşte başlangıç yapmanız için adım adım bir öğretici:

IronPDF Nedir?

Özellik bakımından zengin olan IronPDF PDF Library, C# programlarının PDF belgeleri oluşturmasını, okumasını ve düzenlemesini sağlar. Bu kütüphane ile geliştiriciler, HTML, CSS ve JavaScript bilgilerini yüksek kalitede, baskıya hazır PDF'lere hızla dönüştürebilirler. Başlıca görevler arasında üstbilgi ve altbilgiler eklemek, PDF'leri bölmek ve birleştirmek, belgelere filigran eklemek ve HTML'yi PDF'ye dönüştürmek yer alır.

IronPDF, hem .NET Framework hem de .NET Core'ü destekleyen çok çeşitli uygulamalar için gerçekçidir. Kullanım kolaylıkları ve bilgilerin bolluğu ile, PDF'ler geliştiricilerin ürünlerine kolayca entegre edilebilir. IronPDF, karmaşık veri düzenleri ve formatlarını yönetir, ürettiği PDF'lerin müşterinin orijinal HTML metnine yakın olmasını sağlar. Ayrıca, IronPDF Windows, web ve mobil ortamlar gibi çok platformlu uygulamaları destekler.

dotnetify .NET (Geliştiriciler İçin Nasıl Çalışır): Şekil 3

IronPDF Özellikleri

  • HTML'den PDF Oluşturma: JavaScript, HTML ve CSS'yi PDF'ye dönüştürün. IronPDF, medya sorguları ve duyarlı tasarım gibi modern web standartlarını destekler. Modern web standartlarına desteği ile, PDF faturalarını, raporlarını ve belgelerini HTML ve CSS ile dinamik bir şekilde süslemek için kullanışlıdır.

  • PDF Düzenleme: Mevcut PDF'lere metin, resim ve diğer içerikleri ekleyebilirsiniz. Geliştiriciler, PDF dosyalarından metin ve resim çıkarmak için IronPDF'i kullanabilir, birden çok PDF'yi tek bir dosyada birleştirebilir, PDF dosyalarını birkaç ayrı kağıda bölebilir ve filigran, açıklamalar, üstbilgiler ve altbilgiler ekleyebilir.

  • PDF Dönüştürme: Word, Excel ve resim dosyaları da dahil olmak üzere birkaç dosya formatını PDF formatına dönüştürün. IronPDF ayrıca PDF'den resme dönüştürmeyi (PNG, JPEG, vb.) de destekler.

  • Performans ve Güvenilirlik: Yüksek performans ve güvenilirlik, endüstriyel ayarlarda arzu edilen tasarım nitelikleridir. IronPDF ile geliştiriciler, büyük belge setlerini kolayca yönetebilirler.

IronPDF Kurulumu

.NET projelerinde PDF'lerle çalışmak için gerekli araçları kazanmak amacıyla IronPDF paketini kurun.

Install-Package IronPdf

DotNetify'yi IronPDF ile Entegre Etme

DotNetify'i Yapılandırın:

Başlangıç Yapılandırması: Startup.cs dosyasını açın ve ConfigureServices ve Configure metodlarını kullanarak DotNetify'yi yapılandırın.

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
$vbLabelText   $csharpLabel

Bir Görünüm Modeli Oluşturun

Projenize yeni bir sınıf dosyası ekleyin (örneğin, PdfViewModel.cs) ve bir ViewModel oluşturun, bu PDF üretecek.

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
$vbLabelText   $csharpLabel

Bir Blazor bileşeni oluşturmak için yeni bir bileşen ekleyin (örneğin, GeneratePdf.razor) ve bunu ViewModel'e bağlayın.

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

DotNetify ve IronPDF'i C# ASP.NET Core Blazor uygulamasına entegre ederek, gerçek zamanlı veri işleme ve dinamik PDF üretimi mümkün hale gelir. Kurulum, Razor Pages, Blazor Server, SignalR ve DotNetify için hizmetlerin kaydedildiği Startup.cs'de projeyi yapılandırarak başlar, böylece sunucu tarafı Blazor ve gerçek zamanlı özellikler etkinleştirilir.

PdfViewModel.cs'de, IronPDF'in PDF üretim mantığı tanımlanır. PDF dosyası sadece birkaç satır kodla üretilebilir. GeneratePdf fonksiyonu, HTML içeriğini PDF'e dönüştürür ve PdfUrl özelliğini güncelleyerek yeni dosyanın konumunu müşteriye bildirir. GeneratePdf.razor Blazor bileşeniyle iletişim bu ViewModel tarafından yönetilir.

dotnetify .NET (Geliştiriciler İçin Nasıl Çalışır): Şekil 4

Bileşen, IDotNetifyService üzerinden PdfViewModel'e bağlanır ve özelliklerine bağlanarak müşterinin GeneratePdf fonksiyonunu çağırmasına ve özellik değişikliklerine yanıt vermesine olanak tanır. Kullanıcılar 'PDF Oluştur' düğmesine tıkladığında, ViewModel'in metodu tetiklenir, PDF oluşturulur ve indirme URL'si dinamik olarak güncellenir. Bu yapılandırma ile web uygulaması, IronPDF'in güçlü belge oluşturma yeteneklerini DotNetify'in gerçek zamanlı veri senkronizasyonuyla birleştirerek duyarlı ve ilgi çekici bir kullanıcı deneyimi sunar.

dotnetify .NET (Geliştiriciler İçin Nasıl Çalışır): Şekil 5

Sonuç

DotNetify'i IronPDF ile birleştirmek, C# ASP.NET Core Blazor uygulamasında gerçek zamanlı veri senkronizasyonu ve dinamik PDF üretimini bir araya getirir. DotNetify, istemci tarafı Blazor bileşenleri ile sunucu tarafı ViewModel'ler arasında kesintisiz iletişim sağlar, etkileşimli ve duyarlı uygulamalar oluşturur. Bu, sunucu tarafı mantık ile doğrudan PDF'ler oluşturmayı ve değiştirmeyi sağlayan güçlü araçlar sunan IronPDF ile tamamlanır. Bu güçlü kombinasyon, özelleştirilmiş belgeler oluşturabilen ve dağıtabilen, ayrıca gerçek zamanlı güncellemeler yapabilen uygulamaların geliştirilmesine olanak tanır.

Bu entegrasyon, kullanıcı deneyimini geliştirmek için raporlama, faturalandırma veya başka herhangi bir belgeyle ilgili görevlerde gerçek zamanlı veri işleme ve belge oluşturma teknolojilerini kullanır. Belirtilen adımları takip ederek, geliştiriciler bu araçları verimli bir şekilde kurabilir ve kullanarak modern web uygulama geliştirmede yeni olasılıkları açığa çıkarabilir.

IronPDF ve Iron Software Developer Tools ile, özelliklerini keşfetmeye istekli geliştiriciler, OCR, barkod tarama, PDF üretimi gibi işlevleri kullanabilir. Projeye ilişkin sağlanan lisans alternatifleri ayrıntılı bir şekilde belirtilmiştir ve geliştiricilere ihtiyaçlarına en iyi uyan modeli seçme imkanı tanır. Listelenen avantajlar, geliştiricilerin çok sayıda zorluk için zamanında, koordinasyonlu ve etkili çözümler sunmasına katkıda bulunur.

Sıkça Sorulan Sorular

DotNetify nedir ve nasıl çalışır?

DotNetify, gerçek zamanlı web uygulamaları geliştirme amacıyla .NET ve Blazor ile oluşturulmuş açık kaynaklı bir çerçevedir. DotNetify, SignalR'ı kullanarak istemci ve sunucu arasında gerçek zamanlı iletişimi sağlayarak dinamik ve etkileşimli web uygulamaları oluşturmayı kolaylaştırır.

Gerçek zamanlı web uygulamalarını PDF oluşturma ile C#'de nasıl entegre edebilirim?

Gerçek zamanlı web uygulamaları için DotNetify ve PDF oluşturma işlemi için IronPDF'i birleştirerek geliştiriciler, gerçek zamanlı veri girdileriyle dinamik olarak PDF belgeleri oluşturan ve dağıtan etkileşimli uygulamalar oluşturabilirler.

IronPDF, PDF belge manipulasyonu için ne tür yetenekler sunar?

IronPDF, PDF belgelerini programatik olarak oluşturma, düzenleme ve dönüştürme yetenekleri sağlar. HTML, CSS ve JavaScript'ten PDF'lere dönüşüm sağlar ve çeşitli PDF manipulasyonlarını destekler, bu da rapor ve dinamik belgeler oluşturmak için idealdir.

DotNetify, gerçek zamanlı uygulama geliştirmeyi nasıl geliştirir?

DotNetify, istemci tarafı görünümleriyle sunucu tarafı verilerini senkronize eden bir programlama modeli sunarak gerçek zamanlı uygulama geliştirmeyi geliştirir, böylece duyarlı ve etkileşimli web arayüzleri oluşturmayı mümkün kılar. Hem JavaScript hem de Blazor için esnek bir geliştirme ortamı sunar.

DotNetify'de SignalR kullanmanın faydaları nelerdir?

DotNetify'de SignalR, gerçek zamanlı istemci-sunucu iletişimlerine olanak tanır, bu da etkileşimli ve duyarlı web uygulamaları oluşturmak için gereklidir. Bu, uygulama içinde anlık güncellemeleri ve dinamik etkileşimleri kolaylaştırır.

IronPDF, .NET uygulamalarında dinamik raporlar oluşturmada nasıl yardımcı olur?

IronPDF, CSS ve JavaScript dahil HTML içeriklerini yüksek kaliteli PDF belgelerine dönüştürerek dinamik raporlar oluşturabilir. Bu, veri odaklı raporlar ve faturalar üretmesi gereken uygulamalar için özellikle kullanışlıdır.

DotNetify'de ViewModel'lerin rolü nedir?

DotNetify'de ViewModel'ler, istemci ve sunucu arasında veri senkronizasyonunu idare etmek için kullanılır. Tutarlı bir veri akışı ile uygulamaların duyarlı kullanıcı arayüzleri geliştirmelerini sağlar.

DotNetify ve IronPDF'i birleştirmek kullanıcı deneyimini nasıl geliştirir?

DotNetify ve IronPDF'i birleştirmek, aynı uygulama içinde gerçek zamanlı veri güncellemeleri ve dinamik PDF oluşturma işlemlerine olanak tanır. Bu entegrasyon, belgelerin kesintisiz bir şekilde oluşturulmasını ve dağıtılmasını sağlayarak uygulamanın işlevselliğini geliştirir.

Jacob Mellor, Teknoloji Direktörü @ Team Iron
Jacob Mellor
  Mühendislik ekibiyle şimdi sohbet edin
Teknoloji Direktörü

Jacob Mellor, Iron Software'de Baş Teknoloji Yöneticisidir ve C# PDF teknolojisinde öncü bir mühendisdir. Iron Software'ın ana kod tabanının ilk geliştiricisi olarak, CEO Cameron Rimington ile birlikte şirketin ürün mimarisini 50'den fazla kişilik bir şirkete dönüştürmüştür ...

Daha Fazla Oku

İlgili Makaleler

30 günlük deneme → Tam ürün. Sınırsız. Kart gerektirmez. Ücretsiz Denemeye Başlayın

Iron Destek Ekibi

Haftada 5 gün, 24 saat çevrimiçiyiz.
Sohbet
E-posta
Beni Ara