Integracja WebGrease z IronPDF i .NET Core oferuje skuteczną metodę tworzenia wysokiej jakości dokumentów PDF i usprawniania działania aplikacji internetowych. Dzięki kompresji JavaScript, optymalizacji obrazów i minifikacji CSS, WebGrease jest bogatym w funkcje pakietem, który sprawia, że strony internetowe działają szybciej i płynniej dla programistów. Programiści mogą z łatwością tworzyć dynamiczne pliki PDF z różnych źródeł, w tym widoków HTML i MVC, korzystając z IronPDF, potężnego zestawu narzędzi .NET do tworzenia i edycji dokumentów PDF.

Dzięki tej integracji aplikacje internetowe są płynne i elastyczne, co umożliwia efektywne zarządzanie zasobami i dynamiczne generowanie plików PDF. WebGrease i IronPDF są w pełni kompatybilne z .NET Core, co pozwala programistom tworzyć aplikacje wielopłatformowe, które działają bez zarzutu na systemach Linux, macOS i Windows. Skutkuje to lepszym doświadczeniem użytkownika dzięki zoptymalizowanej wydajności i doskonałej obsłudze dokumentów.

Czym jest WebGrease?

WebGrease, pierwotnie stworzony jako komponent stosu ASP.NET, jest narzędziem do automatyzacji procesów, takich jak optymalizacja JavaScript, kompresja, optymalizacja obrazów i minifikacja CSS plików statycznych w celu poprawy wydajności stron internetowych. Optymalizacje te przyczyniają się do zmniejszenia rozmiarów zasobów internetowych, co poprawia wydajność aplikacji internetowych i przyspiesza czas ich ładowania.

W kontekście .NET Core, kiedy mówimy o WebGrease, mamy na myśli zastosowanie tych metod optymalizacji w aplikacjach .NET Core. Firma Microsoft stworzyła wielopłatformowy framework .NET Core typu open source, aby umożliwić programistom tworzenie nowatorskich, skalowalnych i wydajnych aplikacji. Programiści mogą zastosować techniki optymalizacji wydajności z tradycyjnych aplikacji ASP.NET w swoich projektach .NET Core poprzez integrację WebGrease. W ten sposób programiści mogą mieć pewność, że ich aplikacje internetowe są wydajne i działają sprawnie na różnych platformach, takich jak Windows, Linux i macOS.

Funkcje WebGrease

W ramach platformy .NET Core WebGrease oferuje szereg funkcji mających na celu zwiększenie wydajności i szybkości działania aplikacji internetowych. Najważniejsze cechy są następujące:

Minifikacja CSS:

• Usuwa zbędne formatowanie, komentarze i spacje z plików CSS.
• Redukuje liczbę żądań HTTP poprzez łączenie wielu plików CSS w jeden plik.
• Zwiększa wydajność i przyspiesza ładowanie CSS.

Kompresja JavaScript:

• Minimalizuje pliki JavaScript poprzez usuwanie zbędnych znaków.
• Łączy wiele plików JavaScript w jeden.
• Zmniejsza rozmiar pliku JavaScript, aby przyspieszyć czas pobierania i wykonywania.

Optymalizacja Obrazów:

• Kompresuje obrazy bez znaczącego obniżania jakości.
• W razie potrzeby konwertuje obrazy do bardziej wydajnych formatów.
• Optymalizuje zasoby graficzne w celu zwiększenia szybkości ładowania.

Minifikacja HTML:

• Usuwa spacje i komentarze z plików HTML.
• Upraszcza pliki HTML w celu szybszego parsowania i renderowania przez przeglądarkę.

Pakietowanie zasobów:

• Łączy kilka plików JavaScript i CSS w jeden plik.
• Zmniejsza liczbę żądań HTTP potrzebnych do załadowania strony, skracając czas ładowania.

Elastyczność Konfiguracji:

• Zapewnia opcje konfiguracji procesu optymalizacji.
• Pozwala programistom wybrać katalogi i pliki, które mają zostać zoptymalizowane lub wykluczone.

Zgodność międzyplatformowa:

• W pełni kompatybilny z .NET Core, co pozwala na użycie w systemach Windows, Linux i macOS.
• Zapewnia, że ulepszenia wydajności działają dobrze w różnych środowiskach.

Integracja z Procesami Budowania:

• Możliwość integracji z procedurami kompilacji w celu automatycznej optymalizacji zasobów podczas wdrażania i rozwoju.
• Obsługuje zautomatyzowane procesy, aby zapewnić spójną optymalizację na wszystkich etapach rozwoju.

Ulepszona Wydajność:

• Minimalizuje ilość zasobów, które muszą zostać załadowane, poprawiając w ten sposób ogólną wydajność aplikacji internetowej.
• Poprawia komfort użytkowania i przyspiesza ładowanie stron.

Utwórz i skonfiguruj WebGrease

Aby używać WebGrease w aplikacji .NET Core, zainstaluj niezbędne pakiety, skonfiguruj proces kompilacji i ustaw zadania optymalizacyjne. Poniższe kroki pomogą Ci zainstalować i skonfigurować WebGrease w aplikacji .NET Core:

Utwórz projekt .NET Core

Najpierw utwórz nową aplikację internetową .NET Core. W tym celu można użyć interfejsu CLI platformy .NET.

dotnet new web -n WebGreaseApp
cd WebGreaseApp

dotnet new web -n WebGreaseApp
cd WebGreaseApp

Dodaj wymagane pakiety

Chociaż nie ma bezpośredniego pakietu .NET Core dla WebGrease, podobną funkcjonalność można uzyskać za pomocą innych programów, takich jak BundlerMinifier. Dodaj ten pakiet do swojego projektu.

dotnet add package BundlerMinifier.Core

dotnet add package BundlerMinifier.Core

Konfiguracja pakietowania i minifikacji

Utwórz plik bundleconfig.json w korzeniu projektu, aby ustawic parametry pakowania i minimalizacji dla plików CSS i JavaScript. Oto przykładowa konfiguracja.

[
  {
    "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
    }
  }
]

Integracja z procesem kompilacji

Dodaj instrukcje dotyczące wykonywania operacji pakowania i minifikacji podczas procesu kompilacji w pliku projektu (.csproj).

Dodaj nastepujacy element w elemencie <Project> w pliku .csproj:

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

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

Zainstaluj i uruchom BundlerMinifier

Aby korzystać z narzędzia BundlerMinifier, należy zainstalować narzędzie .NET. Wykonaj następujące polecenie:

dotnet tool install -g BundlerMinifier.Core

dotnet tool install -g BundlerMinifier.Core

Aby skompilować i zminimalizować pliki, uruchom:

dotnet bundle

dotnet bundle

Optymalizacja obrazów

Do optymalizacji obrazów można użyć ImageSharp lub innych narzędzi do optymalizacji obrazów zgodnych z .NET Core.

Zainstaluj ImageSharp

Zainstaluj pakiet SixLabors.ImageSharp:

dotnet add package SixLabors.ImageSharp

dotnet add package SixLabors.ImageSharp

Oto przykład fragmentu kodu służącego do optymalizacji obrazów:

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

Uruchom aplikację, aby upewnić się, że pakowanie i minifikacja działają zgodnie z zamierzeniami. Otwórz aplikację w przeglądarce, a następnie sprawdź, czy pliki JavaScript i CSS są zminimalizowane.

Postępując zgodnie z tymi krokami, można skonfigurować optymalizację podobną do WebGrease dla aplikacji .NET Core przy użyciu narzędzi zgodnych z aktualnym środowiskiem .NET.

Pierwsze kroki z IronPDF

Skonfigurowanie optymalizacji wydajności zasobów internetowych oraz użycie IronPDF do generowania i edycji plików PDF są niezbędne do zintegrowania optymalizacji typu WebGrease z IronPDF w aplikacji .NET Core. Oto jak zacząć, krok po kroku:

Czym jest IronPDF?

Bogata w funkcje biblioteka .NET IronPDF umożliwia programom napisanym w języku C# tworzenie, odczytywanie i edytowanie dokumentów PDF. Dzięki temu programowi programiści mogą z łatwością konwertować informacje HTML, CSS i JavaScript na wysokiej jakości pliki PDF gotowe do druku. Do najważniejszych zadań należą dodawanie nagłówków i stopek, dzielenie i łączenie plików PDF, dodawanie znaków wodnych do dokumentów oraz konwersja HTML do PDF.

IronPDF jest przydatny w wielu zastosowaniach, ponieważ obsługuje zarówno .NET Framework, jak i .NET Core. Ponieważ pliki PDF są przyjazne dla użytkownika i zawierają obszerne treści, programiści mogą z łatwością włączać je do swoich produktów. Ponieważ IronPDF potrafi obsługiwać złożone układy danych i formatowanie, generowane przez niego pliki PDF ściśle odzwierciedlają tekst HTML dostarczony pierwotnie przez klienta.

Funkcje IronPDF

Generowanie plików PDF z HTML

• Konwertuje JavaScript, HTML i CSS do formatu PDF.
• Obsługuje zapytania o media i responsywny projekt, zgodnie z nowoczesnymi standardami internetowymi.
• Przydatne do dynamicznego formatowania dokumentów PDF, raportów i faktur przy użyciu HTML i CSS.

Edycja plików PDF

• Umożliwia dodawanie tekstu, obrazów i innych treści do istniejących plików PDF.
• Wyodrębnia tekst i obrazy z plików PDF.
• Łączy wiele plików PDF w jeden.
• Dzieli pliki PDF na osobne dokumenty.
• Obejmuje znaki wodne, adnotacje, nagłówki i stopki.

Konwersja plików PDF

• Konwertuje wiele różnych formatów plików do formatu PDF, w tym pliki WORD, Excel i pliki graficzne.
• Umożliwia konwersję plików PDF na obrazy (PNG, JPEG itp.).

Wydajność i niezawodność

• Wysoka wydajność i niezawodność, odpowiednie do zastosowań przemysłowych.
• Z łatwością obsługuje duże zbiory dokumentów.

Zainstaluj IronPDF

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

dotnet add package IronPdf

Konfiguracja pakietowania i minifikacji

Upewnij sie, ze plik konfiguracyjny bundleconfig.json jest na miejscu, aby ponownie zapewnic ustawienia pakowania i minimalizacji:

[
  {
    "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
    }
  }
]

Połącz się z procesem tworzenia

Upewnij się, że plik .csproj zawiera instrukcje dotyczące wykonywania operacji minifikacji i pakowania podczas procesu kompilacji. Dodaj nastepujacy cel w elemencie <Project>:

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

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

Zintegruj IronPDF

Stwórz kontroler za pomocą IronPDF, aby generować pliki PDF. Utwórz nowy kontroler 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

Pierwszą rzeczą, jaką robimy w kodzie PdfController, jest zaimportowanie wymaganych przestrzeni nazw, którymi są Microsoft.AspNetCore.Mvc dla funkcjonalności ASP.NET Core MVC oraz IronPDF for .NET do generowania plików PDF. Ponieważ klasa PdfController pochodzi od klasy Controller, jest to kontroler MVC. Metoda GeneratePdf w tej klasie jest zdefiniowana, aby zarzadzac tworzeniem PDFów.

Aby przeksztalcic material HTML w PDF, ta funkcja tworzy instancje ChromePdfRenderer z IronPDF. Podstawowy lancuch HTML mozna przeksztalcic w dokument PDF za pomoca funkcji RenderHtmlAsPdf. Atrybut BinaryData jest potem uzywany do zapisania tego PDF do tablicy bajtów. Ostatecznie, plik PDF jest zwracany jako odpowiedz do pobrania za pomoca metody File, razem z zadana nazwa pliku (example.pdf) i wlasciwym typem MIME (application/pdf). Dzięki tej integracji program może teraz dynamicznie tworzyć i udostępniać dokumenty PDF na podstawie treści HTML.

Ścieżka do wygenerowania pliku PDF

Upewnij sie, ze routing generowania PDF jest zawarty w pliku 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

Uruchom i sprawdź

Uruchom aplikację, aby upewnić się, że możesz tworzyć pliki PDF oraz że funkcje pakowania i minifikacji działają poprawnie.

dotnet run

dotnet run

Otwórz przeglądarkę i przejdź do swojej aplikacji. Powinienes móc nawigowac do /pdf i pobrac dokument PDF.

Wnioski

Optymalizacja typu IronPDF i WebGrease stanowi potężne połączenie, które pozwala poprawić wydajność online i tworzyć wysokiej jakości dokumenty PDF w aplikacjach .NET Core. Programiści mogą zapewnić wydajność i elastyczność swoich aplikacji, korzystając z narzędzi takich jak IronPDF do tworzenia plików PDF oraz BundlerMinifier do optymalizacji zasobów. Oprócz kompresji obrazów, strategie optymalizacji zasobów, takie jak minifikacja CSS i JavaScript, również pomagają przyspieszyć ładowanie stron i poprawić komfort użytkowania. Jednocześnie IronPDF oferuje rozbudowane możliwości dynamicznego tworzenia plików PDF na podstawie tekstu HTML, co upraszcza proces tworzenia dobrze przygotowanych dokumentów, takich jak faktury, raporty i inne.

Ta integracja zapewnia kompletne rozwiązanie dla współczesnych potrzeb związanych z tworzeniem stron internetowych w ramach platformy .NET Core, nie tylko poprawiając wydajność aplikacji internetowych, ale także dodając przydatne funkcje do przetwarzania plików PDF.

Dzięki IronPDF i Iron Software możesz wzbogacić swój zestaw narzędzi do programowania w środowisku .NET, korzystając z funkcji OCR, skanowania kodów kreskowych, tworzenia plików PDF, integracji z programem Excel i wielu innych. Oferując konkurencyjne ceny, IronPDF zapewnia programistom dostęp do większej liczby aplikacji internetowych i funkcji, a także umożliwia bardziej wydajne tworzenie oprogramowania dzięki połączeniu swoich podstawowych koncepcji z wysoce elastycznym zestawem narzędzi Iron Software.

Dobrze zdefiniowane opcje licencyjne projektu ułatwiają programistom wybór optymalnego modelu, pomagając w szybkim, dobrze zorganizowanym i wydajnym wdrażaniu rozwiązań dla szerokiego zakresu problemów.