L'intégration de WebGrease avec IronPDF et .NET Core offre une méthode puissante pour produire des documents PDF de haute qualité et rationaliser la performance des applications web. Avec l'utilisation de la compression JavaScript, de l'optimisation des images et de la minification CSS, WebGrease est un package riche en fonctionnalités qui permet aux sites web de fonctionner plus rapidement et plus facilement pour les développeurs. Les développeurs peuvent facilement créer des PDF dynamiques à partir de plusieurs sources, y compris HTML et les vues MVC, avec IronPDF, un outil .NET puissant pour produire et manipuler des documents PDF.

Les applications web restent fluides et adaptables grâce à cette intégration, permettant une gestion efficace des ressources et la génération dynamique de PDF. WebGrease et IronPDF sont entièrement compatibles avec .NET Core, permettant aux développeurs de créer des applications multi-plateformes qui fonctionnent parfaitement sur Linux, macOS et Windows. Cela aboutit à une expérience utilisateur améliorée grâce à une performance optimisée et une gestion supérieure des documents.

Qu'est-ce que WebGrease ?

Initialement créé comme un composant de la pile ASP.NET, WebGrease est un outil pour automatiser des processus tels que l'optimisation JavaScript, la compression, l'optimisation des images et la minification CSS de fichiers statiques afin d'améliorer la performance des sites web. Ces optimisations contribuent à la réduction de la taille des ressources web, ce qui améliore la performance des applications web et accélère les temps de chargement.

Dans le contexte de .NET Core, lorsque nous parlons de WebGrease, nous entendons l'application de ces méthodes d'optimisation aux applications .NET Core. Microsoft a créé le framework .NET Core, multi-plateforme et open-source, pour permettre aux développeurs de créer des applications innovantes, évolutives et performantes. Les développeurs peuvent appliquer des techniques d'optimisation de la performance des applications ASP.NET traditionnelles à leurs projets .NET Core en intégrant WebGrease. De cette façon, les développeurs peuvent s'assurer que leurs applications web sont efficaces et performantes sur diverses plateformes, telles que Windows, Linux et macOS.

Caractéristiques de WebGrease

Dans le cadre de .NET Core, WebGrease offre un certain nombre de fonctionnalités visant à améliorer l'efficacité et la rapidité des applications web. Les caractéristiques saillantes sont les suivantes :

Minimisation de CSS :

• Élimine le formatage inutile, les commentaires et les espaces blancs des fichiers CSS.
• Réduit les requêtes HTTP en combinant de nombreux fichiers CSS en un seul fichier.
• Améliore la performance et accélère les temps de chargement pour le CSS.

Compression JavaScript :

• Réduit la taille des fichiers JavaScript en supprimant les caractères inutiles.
• Combine plusieurs fichiers JavaScript en un.
• Réduit la taille des fichiers JavaScript pour accélérer les temps de téléchargement et d'exécution.

Optimisation d'image :

• Compresse les images sans réduire de manière significative la qualité.
• Convertit les images dans des formats plus efficaces si nécessaire.
• Optimise les ressources d'image pour augmenter les vitesses de chargement.

Minimisation HTML :

• Supprime les espaces blancs et les commentaires des fichiers HTML.
• Simplifie les fichiers HTML pour un parsing et un rendu plus rapide par le navigateur.

Regroupement de ressources :

• Combine plusieurs fichiers JavaScript et CSS en un seul fichier.
• Réduit le nombre de requêtes HTTP nécessaires pour charger une page, améliorant les temps de chargement.

Flexibilité de configuration :

• Offre des options pour configurer le processus d'optimisation.
• Permet aux développeurs de choisir les répertoires et fichiers à optimiser ou à exclure.

Compatibilité multiplateforme :

• Entièrement compatible avec .NET Core, permettant une utilisation sur Windows, Linux et macOS.
• Assure que les améliorations de performance fonctionnent bien dans divers environnements.

Intégration avec les processus de construction :

• Peut être intégré aux procédures de construction pour optimiser automatiquement les ressources pendant le déploiement et le développement.
• Prend en charge les processus automatisés pour assurer une optimisation cohérente à travers les phases de développement.

Amélioration des performances :

• Minimise les ressources qui doivent être chargées, améliorant ainsi la performance globale de l'application web.
• Améliore l'expérience utilisateur et accélère le chargement des pages.

Créer et configurer WebGrease

Pour utiliser WebGrease dans une application .NET Core, installez les packages nécessaires, configurez le processus de construction et configurez les tâches d'optimisation. Les étapes suivantes vous aideront à établir et à configurer WebGrease dans une application .NET Core :

Créer un projet .NET Core

Tout d'abord, créez une nouvelle application web .NET Core. Vous pouvez utiliser le CLI .NET à cet effet.

dotnet new web -n WebGreaseApp
cd WebGreaseApp

dotnet new web -n WebGreaseApp
cd WebGreaseApp

Ajouter les packages requis

Bien qu'il n'existe pas de package .NET Core direct pour WebGrease, vous pouvez obtenir des fonctionnalités similaires avec d'autres programmes comme BundlerMinifier. Ajoutez ce package à votre projet.

dotnet add package BundlerMinifier.Core

dotnet add package BundlerMinifier.Core

Configurer le groupement et la minification

Créez un fichier bundleconfig.json à la racine de votre projet pour fournir les paramètres de regroupement et de minification pour vos fichiers CSS et JavaScript. Voici un exemple de configuration.

[
  {
    "outputFileName": "wwwroot/css/site.min.css",
    "inputFiles": [
      "wwwroot/css/site.css"
    ],
    "minify": {
      "enabled": true,
      "renameLocals": true
    }
  },
  {
    "outputFileName": "wwwroot/js/site.min.js",
    "inputFiles": [
      "wwwroot/js/site.js"
    ],
    "minify": {
      "enabled": true
    }
  }
]

[
  {
    "outputFileName": "wwwroot/css/site.min.css",
    "inputFiles": [
      "wwwroot/css/site.css"
    ],
    "minify": {
      "enabled": true,
      "renameLocals": true
    }
  },
  {
    "outputFileName": "wwwroot/js/site.min.js",
    "inputFiles": [
      "wwwroot/js/site.js"
    ],
    "minify": {
      "enabled": true
    }
  }
]

Intégrer au processus de construction

Ajoutez des instructions pour exécuter les opérations de groupement et de minification pendant le processus de construction dans votre fichier projet (.csproj).

Ajoutez l'élément suivant à l'intérieur de l'élément <Project> dans votre fichier .csproj :

<Target Name="PrepublishScript" BeforeTargets="PrepareForPublish">
  <Exec Command="dotnet bundle" />
</Target>

<Target Name="PrepublishScript" BeforeTargets="PrepareForPublish">
  <Exec Command="dotnet bundle" />
</Target>

Installer et exécuter BundlerMinifier

Pour utiliser l'outil BundlerMinifier, vous devez installer l'utilitaire .NET. Exécutez la commande suivante :

dotnet tool install -g BundlerMinifier.Core

dotnet tool install -g BundlerMinifier.Core

Pour regrouper et minimiser vos fichiers, exécutez :

dotnet bundle

dotnet bundle

Optimiser les images

Vous pouvez utiliser ImageSharp ou d'autres outils d'optimisation d'images compatibles .NET Core pour l'optimisation des images.

Installer ImageSharp

Installez le package SixLabors.ImageSharp :

dotnet add package SixLabors.ImageSharp

dotnet add package SixLabors.ImageSharp

Voici un exemple d'extrait de code pour l'optimisation des images :

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using System.IO;

public void OptimizeImage(string inputPath, string outputPath)
{
    // Load the image
    using (var image = Image.Load(inputPath))
    {
        // Resize and optimize the image
        image.Mutate(x => x.Resize(new ResizeOptions
        {
            Mode = ResizeMode.Max,
            Size = new Size(800, 600)
        }));
        // Save the image in an optimized format
        image.Save(outputPath); // Automatic encoder selected based on file extension.
    }
}

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using System.IO;

public void OptimizeImage(string inputPath, string outputPath)
{
    // Load the image
    using (var image = Image.Load(inputPath))
    {
        // Resize and optimize the image
        image.Mutate(x => x.Resize(new ResizeOptions
        {
            Mode = ResizeMode.Max,
            Size = new Size(800, 600)
        }));
        // Save the image in an optimized format
        image.Save(outputPath); // Automatic encoder selected based on file extension.
    }
}

Imports SixLabors.ImageSharp
Imports SixLabors.ImageSharp.Processing
Imports System.IO

Public Sub OptimizeImage(ByVal inputPath As String, ByVal outputPath As String)
	' Load the image
	Using image = System.Drawing.Image.Load(inputPath)
		' Resize and optimize the image
		image.Mutate(Function(x) x.Resize(New ResizeOptions With {
			.Mode = ResizeMode.Max,
			.Size = New Size(800, 600)
		}))
		' Save the image in an optimized format
		image.Save(outputPath) ' Automatic encoder selected based on file extension.
	End Using
End Sub

Imports SixLabors.ImageSharp
Imports SixLabors.ImageSharp.Processing
Imports System.IO

Public Sub OptimizeImage(ByVal inputPath As String, ByVal outputPath As String)
	' Load the image
	Using image = System.Drawing.Image.Load(inputPath)
		' Resize and optimize the image
		image.Mutate(Function(x) x.Resize(New ResizeOptions With {
			.Mode = ResizeMode.Max,
			.Size = New Size(800, 600)
		}))
		' Save the image in an optimized format
		image.Save(outputPath) ' Automatic encoder selected based on file extension.
	End Using
End Sub

Exécutez votre application pour vous assurer que le regroupement et la minification fonctionnent comme prévu. Ouvrez votre application dans le navigateur, puis vérifiez que les fichiers JavaScript et CSS sont minimisés.

En suivant ces étapes, vous pouvez configurer l'optimisation de type WebGrease pour une application .NET Core avec des outils compatibles.

Commencer avec IronPDF

La mise en place de l'optimisation des performances pour vos ressources web et l'utilisation d'IronPDF pour la génération et la manipulation de PDF sont toutes deux nécessaires à l'intégration de l'optimisation de type WebGrease avec IronPDF dans une application .NET Core. Voici comment commencer, étape par étape :

Qu'est-ce qu'IronPDF ?

La bibliothèque .NET riche en fonctionnalités IronPDF permet aux programmes C# de produire, lire et éditer des documents PDF. Avec ce programme, les développeurs peuvent facilement convertir des informations HTML, CSS et JavaScript en PDF de haute qualité, prêts à être imprimés. Parmi les tâches les plus cruciales, la création d'en-têtes et de pieds de page, la division et la combinaison de PDFs, 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 le .NET Framework et .NET Core. Étant donné que les PDF sont conviviaux et contiennent un contenu vaste, les développeurs peuvent facilement les intégrer dans leurs produits. Comme IronPDF peut gérer des mises en page et des formats de données complexes, les PDF qu'il génère en sortie reflètent fidèlement le texte HTML initialement fourni par le client.

Caractéristiques de IronPDF

Génération de PDF à partir de HTML

• Convertit JavaScript, HTML et CSS en PDF.
• Prend en charge les requêtes média et le design réactif, s'alignant sur les normes web modernes.
• Utile pour décorer dynamiquement les documents PDF, les rapports et les factures en utilisant HTML et CSS.

Édition de PDF

• Permet l'ajout de texte, d'images et d'autres contenus à des PDF existants.
• Extrait le texte et les images des fichiers PDF.
• Fusionne plusieurs PDF en un seul.
• Divise les fichiers PDF en documents séparés.
• Inclut des filigranes, des annotations, des en-têtes et des pieds de page.

Conversion PDF

• Convertit une grande variété de formats de fichiers en PDF, y compris les fichiers Word, Excel et image.
• Permet la conversion de PDF en images (PNG, JPEG, etc.).

Performance et Fiabilité

• Haute performance et fiabilité, adapté aux applications industrielles.
• Traite facilement de grands ensembles de documents.

Installer IronPDF

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

dotnet add package IronPdf

Configurer le groupement et la minification

Assurez-vous que le fichier de configuration bundleconfig.json est en place pour fournir à nouveau les paramètres de regroupement et de minification si nécessaire :

[
  {
    "outputFileName": "wwwroot/css/site.min.css",
    "inputFiles": [
      "wwwroot/css/site.css"
    ],
    "minify": {
      "enabled": true,
      "renameLocals": true
    }
  },
  {
    "outputFileName": "wwwroot/js/site.min.js",
    "inputFiles": [
      "wwwroot/js/site.js"
    ],
    "minify": {
      "enabled": true
    }
  }
]

[
  {
    "outputFileName": "wwwroot/css/site.min.css",
    "inputFiles": [
      "wwwroot/css/site.css"
    ],
    "minify": {
      "enabled": true,
      "renameLocals": true
    }
  },
  {
    "outputFileName": "wwwroot/js/site.min.js",
    "inputFiles": [
      "wwwroot/js/site.js"
    ],
    "minify": {
      "enabled": true
    }
  }
]

Connecter au processus de construction

Assurez-vous que votre fichier .csproj contient des instructions pour exécuter les opérations de minification et de groupement pendant le processus de construction. Ajoutez la cible suivante à l'intérieur de l'élément <Project> :

<Target Name="PrepublishScript" BeforeTargets="PrepareForPublish">
  <Exec Command="dotnet bundle" />
</Target>

<Target Name="PrepublishScript" BeforeTargets="PrepareForPublish">
  <Exec Command="dotnet bundle" />
</Target>

Intégrer IronPDF

Construisez un contrôleur avec IronPDF pour produire des PDF. Créez un nouveau contrôleur PdfController.

using Microsoft.AspNetCore.Mvc;
using IronPdf;

namespace WebGreaseIronPdfApp.Controllers
{
    public class PdfController : Controller
    {
        public IActionResult GeneratePdf()
        {
            // Create a PDF from a simple HTML string
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF!</h1><p>This is a generated PDF document.</p>");
            
            // Save the PDF to a byte array
            var pdfBytes = pdf.BinaryData;
            
            // Return the PDF file as a download
            return File(pdfBytes, "application/pdf", "example.pdf");
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using IronPdf;

namespace WebGreaseIronPdfApp.Controllers
{
    public class PdfController : Controller
    {
        public IActionResult GeneratePdf()
        {
            // Create a PDF from a simple HTML string
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF!</h1><p>This is a generated PDF document.</p>");
            
            // Save the PDF to a byte array
            var pdfBytes = pdf.BinaryData;
            
            // Return the PDF file as a download
            return File(pdfBytes, "application/pdf", "example.pdf");
        }
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports IronPdf

Namespace WebGreaseIronPdfApp.Controllers
    Public Class PdfController
        Inherits Controller

        Public Function GeneratePdf() As IActionResult
            ' Create a PDF from a simple HTML string
            Dim renderer = New ChromePdfRenderer()
            Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF!</h1><p>This is a generated PDF document.</p>")

            ' Save the PDF to a byte array
            Dim pdfBytes = pdf.BinaryData

            ' Return the PDF file as a download
            Return File(pdfBytes, "application/pdf", "example.pdf")
        End Function
    End Class
End Namespace

Imports Microsoft.AspNetCore.Mvc
Imports IronPdf

Namespace WebGreaseIronPdfApp.Controllers
    Public Class PdfController
        Inherits Controller

        Public Function GeneratePdf() As IActionResult
            ' Create a PDF from a simple HTML string
            Dim renderer = New ChromePdfRenderer()
            Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF!</h1><p>This is a generated PDF document.</p>")

            ' Save the PDF to a byte array
            Dim pdfBytes = pdf.BinaryData

            ' Return the PDF file as a download
            Return File(pdfBytes, "application/pdf", "example.pdf")
        End Function
    End Class
End Namespace

La première chose que nous faisons dans le code de PdfController est d'importer les espaces de noms nécessaires, qui sont Microsoft.AspNetCore.Mvc pour la fonctionnalité MVC ASP.NET Core et IronPDF pour la génération de PDF. Parce qu'elle dérive de Controller, la classe PdfController est un contrôleur MVC. La méthode GeneratePdf de cette classe est définie pour gérer la création de PDFs.

Pour convertir le matériel HTML en PDF, cette fonction crée une instance de ChromePdfRenderer de IronPDF. Une chaîne HTML basique peut être transformée en document PDF en utilisant la fonction RenderHtmlAsPdf. L'attribut BinaryData est ensuite utilisé pour enregistrer ce PDF dans un tableau de bytes. Enfin, le fichier PDF est renvoyé en tant que réponse téléchargeable à l'aide de la méthode File, avec le nom de fichier demandé (example.pdf) et le type MIME correct (application/pdf). Le programme peut désormais créer dynamiquement et servir des documents PDF basés sur du contenu HTML grâce à cette intégration.

Route pour générer un PDF

Assurez-vous que le routage de génération de PDF est inclus dans votre fichier Startup.cs.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
        endpoints.MapControllerRoute(
            name: "pdf",
            pattern: "pdf",
            defaults: new { controller = "Pdf", action = "GeneratePdf" });
    });
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
        endpoints.MapControllerRoute(
            name: "pdf",
            pattern: "pdf",
            defaults: new { controller = "Pdf", action = "GeneratePdf" });
    });
}

Public Sub Configure(app As IApplicationBuilder, env As IWebHostEnvironment)
    If env.IsDevelopment() Then
        app.UseDeveloperExceptionPage()
    Else
        app.UseExceptionHandler("/Home/Error")
        app.UseHsts()
    End If
    app.UseHttpsRedirection()
    app.UseStaticFiles()
    app.UseRouting()
    app.UseAuthorization()
    app.UseEndpoints(Sub(endpoints)
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}")
        endpoints.MapControllerRoute(
            name: "pdf",
            pattern: "pdf",
            defaults:=New With {.controller = "Pdf", .action = "GeneratePdf"})
    End Sub)
End Sub

Public Sub Configure(app As IApplicationBuilder, env As IWebHostEnvironment)
    If env.IsDevelopment() Then
        app.UseDeveloperExceptionPage()
    Else
        app.UseExceptionHandler("/Home/Error")
        app.UseHsts()
    End If
    app.UseHttpsRedirection()
    app.UseStaticFiles()
    app.UseRouting()
    app.UseAuthorization()
    app.UseEndpoints(Sub(endpoints)
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}")
        endpoints.MapControllerRoute(
            name: "pdf",
            pattern: "pdf",
            defaults:=New With {.controller = "Pdf", .action = "GeneratePdf"})
    End Sub)
End Sub

Exécuter et vérifier

Exécutez votre application pour vous assurer que vous pouvez créer des PDF et que le groupement et la minification fonctionnent correctement.

dotnet run

dotnet run

Ouvrez le navigateur et accédez à votre application. Il devrait vous être possible de naviguer vers /pdf et de télécharger un document PDF.

Conclusion

La combinaison d'optimisation de type WebGrease et d'IronPDF constitue une puissante association pour améliorer la performance en ligne et produire des documents PDF de haute qualité dans les applications .NET Core. Les développeurs peuvent s'assurer que leurs applications sont efficaces et flexibles en utilisant des outils tels qu'IronPDF pour créer des PDF et BundlerMinifier pour optimiser les ressources. En plus de la compression d'image, des stratégies d'optimisation des ressources, telles que la minification CSS et JavaScript, aident également à accélérer les chargements de page et à améliorer l'expérience utilisateur. Parallèlement, IronPDF offre de solides fonctionnalités pour créer dynamiquement des PDF à partir de texte HTML, simplifiant le processus de création de documents bien préparés comme les factures, les rapports, etc.

Cette intégration fournit une solution complète pour les besoins modernes de développement web sous le cadre .NET Core, améliorant non seulement la performance de l'application en ligne mais ajoutant également des fonctionnalités utiles pour le traitement des PDF.

Avec IronPDF et Iron Software, vous pouvez améliorer votre trousse à outils pour le développement .NET en profitant de l'OCR, de la numérisation de codes-barres, de la création de PDF, de la connectivité Excel, et bien plus encore. À partir d'un prix compétitif, IronPDF offre aux développeurs un accès à plus d'applications web et de fonctionnalités, ainsi qu'un développement plus efficace, en combinant ses concepts de base avec la boîte à outils très flexible de Iron Software.

Les options de licence bien définies pour le projet facilitent pour les développeurs la sélection du modèle optimal, aidant à l'exécution rapide, bien organisée et efficace de solutions pour un large éventail de problèmes.