dotnetify.NET (Comment ça fonctionne pour les développeurs)

Introduction

DotNetify est un framework open-source réalisé avec .NET et Blazor qui est destiné à la création d'applications web en temps réel sur une plateforme .NET. L'utilisation de la puissance de SignalR pour les interactions en temps réel entre le client et le serveur facilite la construction d'applications web dynamiques et interactives. DotNetify est un modèle de programmation qui synchronise les vues côté client avec les vues côté client côté serveur permettant aux développeurs de concevoir rapidement et facilement des interfaces en ligne riches, réactives et performantes.

Inversement, IronPDF est un puissant logiciel .NET qui facilite la création, l'édition et la manipulation programmatique de documents PDF. Il s'agit d'une excellente option pour créer des documents dynamiques et axés sur les données, tels que des rapports, des factures et des formulaires, car il fournit une API intuitive pour transformer le texte HTML en PDF.

L'interactivité web en temps réel et les puissantes capacités de production de PDF sont combinées dans une application C# en intégrant DotNetify à IronPDF. Les applications qui exigent un affichage des données en temps réel et la possibilité de créer et de distribuer dynamiquement des documents PDF basés sur les données les plus récentes trouveront cette intégration particulièrement utile. Les développeurs peuvent concevoir des applications en ligne étendues et interactives qui répondent à des exigences commerciales complexes et améliorent l'expérience des utilisateurs grâce à la génération et à la distribution transparentes de documents en tirant parti de la génération polyvalente de PDF d'IronPDF et de la synchronisation des données en temps réel de DotNetify.

Qu'est-ce que DotNetify ?

DotNetify est un framework open-source conçu pour faciliter la création d'applications web interactives en temps réel avec .NET et Blazor. Les développeurs peuvent créer des interfaces utilisateur dynamiques et réactives qui se synchronisent avec les données côté serveur sans effort en utilisant SignalR, qui facilite la communication en temps réel entre le client et le serveur. DotNetify est une approche de programmation réactive qui simplifie la création d'applications en ligne complexes avec peu de code en faisant abstraction des difficultés liées à la liaison des données en temps réel et à la gestion des événements.

Pour garantir que l'interface utilisateur représente toujours l'état de l'application, DotNetify permet aux développeurs de construire des modèles de vue sur le serveur qui propagent immédiatement les changements au client. Ce cadre permet une certaine souplesse dans le choix de la technologie côté client, en prenant en charge les interfaces JavaScript classiques et les interfaces Blazor. En raison de sa facilité d'utilisation et de son efficacité, il est parfait pour les applications qui nécessitent des mises à jour en temps réel, telles que les tableaux de bord, les outils de collaboration et les flux de données en direct.

La gestion en temps réel par DotNetify des interactions complexes et des flux de données améliore considérablement l'expérience de l'utilisateur en permettant une synchronisation fluide des données et un retour d'information immédiat. Tout bien considéré, DotNetify est une solution utile pour les développeurs .NET qui souhaitent créer rapidement et efficacement des applications en ligne réactives, à la pointe de la technologie et en temps réel.

Caractéristiques de DotNetify

Un certain nombre de fonctionnalités fournies par DotNetify en C# facilitent la création d'applications en ligne interactives et en temps réel. Les principales caractéristiques sont les suivantes

Communication en temps réel: DotNetify utilise SignalR pour faciliter la communication bidirectionnelle en temps réel entre le client et le serveur, ce qui permet des interfaces utilisateur interactives et des mises à jour rapides.

Modèle de programmation réactive: Il offre une méthode de programmation réactive dans laquelle les vues côté client et les modèles de vue côté serveur se synchronisent automatiquement pour maintenir l'interface utilisateur à jour avec les informations les plus récentes.

Modèles de vue côté serveur: Cela permet aux développeurs de créer des modèles de vue côté serveur auxquels les composants côté client peuvent se lier, ce qui simplifie la gestion de l'état et le flux de données au sein de l'application.

Prise en charge de Blazor et de JavaScript: Prise en charge des frontaux JavaScript classiques et des frontaux Blazor, permettant aux développeurs de sélectionner la technologie côté client qui répond le mieux à leurs besoins.

Facilité d'intégration: La fonctionnalité temps réel peut être facilement ajoutée à des projets nouveaux ou existants grâce à son intégration transparente avec les applications .NET existantes. Il s'intègre également bien avec les frameworks de composants d'interface utilisateur frontaux tels que WebSockets pour créer un composant web et fonctionne avec des projets utilisant des logiciels tels que React Native, Vue et Blazor.

**DotNetify, qui est basé sur SignalR, hérite de ses caractéristiques d'évolutivité, permettant aux applications de gérer efficacement un grand nombre de connexions simultanées.

Architecture MVVM: Prend en charge le modèle de vue (Model-View-ViewModel) (MVVM) qui facilite la répartition des responsabilités et l'organisation d'un code propre et facile à maintenir.

Gestion des événements: Réduit la quantité de code de base nécessaire pour gérer les interactions de l'interface utilisateur et les changements d'état en rationalisant la gestion des événements et la liaison des données.

Extensible et personnalisable: Offre des points d'extensibilité et des crochets pour permettre la personnalisation du comportement et l'intégration nécessaire avec d'autres bibliothèques ou frameworks.

**L'infrastructure DotNetify offre un mécanisme de routage dynamique qui est capable d'être défini entièrement sur le back-end, qui est capable de routage imbriqué, d'authentification à base de jetons, et plus encore.

**DotNetify est un projet open-source qui bénéficie de la participation et des contributions de la communauté, ce qui garantit des mises à jour et des améliorations continues.

Créer et configurer DotNetify C&num ;

Pour établir un projet simple et commencer à configurer DotNetify dans une application en ligne C#, procédez comme suit. Ce tutoriel vous montrera comment utiliser ASP.NET Core et Blazor pour mettre en place un serveur et un client DotNetify de base.

Configurer un nouveau projet de serveur ASP.NET Core Blazor

• Ouvrez Visual Studio : Lancez Visual Studio, puis démarrez un nouveau projet.
• Créer une application serveur Blazor : Cliquez sur "Next" après avoir sélectionné le modèle Blazor Server App dans les modèles de projet.
• Configurez votre projet : Donnez un nom à votre projet (comme "DotNetifyWebApp") et apportez les modifications nécessaires à la configuration. Appuyez sur "Créer"

Installer DotNetify via NuGet

• Gestion des paquets NuGet : Allez à "Manage NuGet Packages" à partir de l'explorateur de solutions en faisant un clic droit sur votre projet.
• Recherchez DotNetify : Installer les paquets DotNetify et DotNetify.Blazor.

Configurer DotNetify

Pour configurer DotNetify, ouvrez Startup.cs et utilisez les méthodes ConfigureServices et 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

Créer un modèle de vue

Créez un nouveau fichier de classe dans votre projet (HelloWorldViewModel.cs, par exemple) et de concevoir un modèle de visualisation de base.

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

Enregistrer le modèle de vue

Avant d'enregistrer le ViewModel, ouvrez 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

Créer un composant Blazor

Dans votre projet, ajoutez un nouveau composant Blazor (comme HelloWorld.razor) et de le connecter au 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

Configure l'application pour qu'elle utilise DotNetify, Blazor, Razor Pages et SignalR. En outre, il configure les points d'extrémité et le routage de DotNetify et de Blazor. Décrit un modèle de visualisation de base avec un attribut de retour de message d'accueil. Le HelloWorldViewModel est enregistré en tant que service temporaire. Composant Blazor qui établit une connexion avec le HelloWorldViewModel, récupère le texte de bienvenue et l'affiche à l'écran.

Pour commencer

Vous devez créer un projet .NET et incorporer les deux bibliothèques dans votre application afin d'utiliser DotNetify et IronPDF. Voici un tutoriel étape par étape pour vous aider à démarrer :

Qu'est-ce qu'IronPDF ?

La bibliothèque .NET riche en fonctionnalités IronPDF permet aux programmes C# de produire, lire et modifier des documents PDF. Grâce à ce programme, les développeurs peuvent rapidement transformer les informations HTML, CSS et JavaScript en PDF de haute qualité, prêts à être imprimés. Parmi les tâches les plus importantes, citons l'ajout d'en-têtes et de pieds de page, la division et la combinaison de PDF, l'ajout de filigranes aux documents et la conversion de HTML en PDF.

IronPDF est utile pour une variété d'applications car il prend en charge à la fois .NET Framework et .NET Core. Grâce à leur simplicité d'utilisation et à la richesse des informations qu'ils contiennent, les PDF permettent aux développeurs de les intégrer facilement dans leurs produits. Parce qu'IronPDF peut gérer des mises en page et des formatages de données complexes, les PDF qu'il génère en sortie sont assez semblables au texte HTML original du client. IronPDF prend également en charge les applications multiplateformes telles que les environnements Windows, Web et mobiles.

Caractéristiques d'IronPDF

**Génération de PDF à partir de HTML

Convertissez JavaScript, HTML et CSS en PDF. IronPDF prend en charge les media queries et le responsive design, deux normes web contemporaines. Sa prise en charge des normes web modernes est utile pour décorer dynamiquement les factures, rapports et documents PDF avec du HTML et du CSS.

Édition PDF

Il est possible d'ajouter du texte, des images et d'autres contenus à des PDF préexistants. Les développeurs peuvent utiliser IronPDF pour extraire du texte et des images de fichiers PDF, combiner plusieurs PDF en un seul fichier, diviser des fichiers PDF en plusieurs documents distincts et inclure des filigranes, des annotations, des en-têtes et des pieds de page.

Conversion PDF

Convertissez plusieurs formats de fichiers, notamment Word, Excel et des fichiers d'images, au format PDF. IronPDF prend également en charge la conversion de PDF en images (PNG, JPEG, etc.).

Performance et fiabilité

Les performances élevées et la fiabilité sont des qualités recherchées dans les environnements industriels. Avec IronPDF, les développeurs peuvent gérer facilement de grands ensembles de documents.

Installer IronPDF

Pour obtenir les outils dont vous avez besoin pour travailler avec des PDF dans des projets .NET, installez le paquet IronPDF.

dotnet add package IronPdf

dotnet add package IronPdf

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

Intégrer DotNetify à IronPDF

Configurer DotNetify

Configuration du démarrage : Ouvrez Startup.cs, puis utilisez les méthodes ConfigureServices et Configure pour configurer 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");
        });
    }
}

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

Créer un modèle de vue

Dans votre projet, ajoutez un nouveau fichier de classe (comme PdfViewModel.cs) et créer un ViewModel qui produira un PDF.

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

Ajouter un nouveau composant Blazor à votre projet (comme GeneratePdf.razor) et le lier au ViewModel pour créer un composant Blazor.

@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

Le traitement des données en temps réel et la production dynamique de PDF sont rendus possibles par l'intégration de DotNetify et IronPDF dans une application C# ASP.NET Core Blazor. Pour activer les fonctionnalités Blazor et temps réel côté serveur, la première étape de l'installation consiste à configurer le projet dans Startup.cs, où les services pour Razor Pages, Blazor Server, SignalR et DotNetify sont enregistrés.

La logique de génération de PDF d'IronPDF est définie dans le modèle de visualisation PdfViewModel.cs. Quelques lignes de code suffisent pour générer le fichier PDF. L'une de ses caractéristiques est la fonction GeneratePdf, qui prend des informations HTML et les transforme en PDF. Il stocke le fichier sur le serveur et met à jour la propriété PdfUrl pour indiquer au client où se trouve le nouveau fichier. Ce ViewModel communique avec le composant Blazor GeneratePdf.razor.

Afin de permettre au client d'appeler la fonction GeneratePdf et de réagir aux changements de propriétés, il se connecte à PdfViewModel via IDotNetifyService et se lie à ses propriétés. Le composant invoque la méthode du ViewModel lorsque l'utilisateur clique sur le bouton "Générer le PDF", création du PDF et la mise à jour dynamique de l'URL de téléchargement. Avec cette configuration, l'application web offre une expérience utilisateur réactive et attrayante en intégrant les puissantes capacités de génération de documents d'IronPDF avec la synchronisation des données en temps réel de DotNetify.

Conclusion

La synchronisation des données en temps réel et la production dynamique de PDF sont combinées dans une application C# ASP.NET Core Blazor grâce à l'intégration de DotNetify avec IronPDF. Les applications interactives et réactives sont rendues possibles par DotNetify, qui permet une communication fluide entre les composants Blazor côté client et les ViewModels côté serveur. Elle est renforcée par IronPDF, qui offre des outils puissants pour créer et modifier des PDF directement à partir de la logique côté serveur. Grâce à ce mélange puissant, les développeurs peuvent créer des applications capables de créer et d'envoyer des documents uniques ainsi que des mises à jour en temps réel.

Cette intégration tire le meilleur parti du traitement des données en temps réel et des technologies de génération de documents pour améliorer l'expérience de l'utilisateur, qu'il s'agisse de rapports, de facturation ou de toute autre opération liée aux documents. Les développeurs peuvent mettre en place et utiliser ces outils rapidement et facilement en suivant les procédures indiquées, ce qui ouvre un monde de possibilités pour le développement d'applications web contemporaines.

Vous pouvez utiliser l'OCR, la lecture de codes-barres, la production de PDF, la connexion à Excel et bien d'autres choses encore avec IronPDF et IronSoftware pour les développeurs qui souhaitent tester ses nombreuses fonctionnalités.

Si les alternatives de licence liées au projet sont spécifiées en détail, les développeurs auront plus de facilité à choisir le meilleur modèle. Les avantages susmentionnés facilitent la mise en œuvre rapide, coordonnée et efficace de solutions par les développeurs pour une variété de problèmes.