WebGrease .NET Core (jak to działa dla programistów)

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

Dodaj następujący element wewnątrz elementu <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

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.

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

dotnet add package IronPdf

dotnet add package IronPdf

Konfiguracja pakietowania i minifikacji

Upewnij się, że plik konfiguracyjny bundleconfig.json jest na swoim miejscu, aby w razie potrzeby ponownie zapewnić ustawienia pakowania i minifikacji:

[
  {
    "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 następujący element Target 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

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 została zdefiniowana w celu zarządzania tworzeniem plików PDF.

Aby przekonwertować materiał HTML na PDF, funkcja ta tworzy instancję ChromePdfRenderer biblioteki IronPDF. Podstawowy ciąg znaków HTML można przekształcić w dokument PDF za pomocą funkcji RenderHtmlAsPdf. Następnie używa się atrybutu BinaryData, aby zapisać ten plik PDF w tablicy bajtów. Na koniec plik PDF jest zwracany jako odpowiedź do pobrania przy użyciu metody File, wraz z żądaną nazwą pliku (example.pdf) i prawidłowym 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 się, że routing generowania plików 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

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. Powinno być możliwe przejście do /pdf i pobranie dokumentu PDF.