WebGrease .NET Core (How It Works For Developers)

Add instructions to execute the bundling and minification operations during the build process in your project file (.csproj).

Add the following element inside the <Project> element in your .csproj file:

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

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

Install and Run BundlerMinifier

To use the BundlerMinifier tool, you must install the .NET utility. Execute the following command:

dotnet tool install -g BundlerMinifier.Core

dotnet tool install -g BundlerMinifier.Core

To bundle and minify your files, run:

dotnet bundle

dotnet bundle

Optimize Images

You can use ImageSharp or other .NET Core-compliant image optimization tools for image optimization.

Install ImageSharp

Install the SixLabors.ImageSharp package:

dotnet add package SixLabors.ImageSharp

dotnet add package SixLabors.ImageSharp

Here is an example of a code snippet for image optimization:

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.
    }
}

Run your application to ensure bundling and minification are operating as intended. Open your application in the browser, then verify that the JavaScript and CSS files are minified.

By following these steps, you can set up and configure WebGrease-like optimization for a .NET Core application using tools compatible with the current .NET environment.

To gain the tools you need to work with PDFs in .NET projects, install the IronPDF package.

dotnet add package IronPdf

dotnet add package IronPdf

Configure Bundling and Minification

Ensure that the bundleconfig.json config file is in place to provide the bundling and minification settings again as needed:

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

Connect to the Building Process

Ensure that your .csproj file contains instructions for executing the minification and bundling operations during the build process. Add the following Target within the <Project> element:

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

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

Integrate IronPDF

Build a controller with IronPDF to produce PDFs. Create a new PdfController controller.

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

The first thing we do in the PdfController code is import the required namespaces, which are Microsoft.AspNetCore.Mvc for ASP.NET Core MVC functionality and IronPDF for PDF generation. Because it derives from Controller, the PdfController class is an MVC controller. The GeneratePdf method in this class is defined to manage the creation of PDFs.

To convert HTML material into a PDF, this function creates an instance of IronPDF's ChromePdfRenderer. A basic HTML string can be transformed into a PDF document using the RenderHtmlAsPdf function. The BinaryData attribute is then used to save this PDF to a byte array. Lastly, the PDF file is returned as a downloadable response using the File method, along with the requested filename (example.pdf) and the correct MIME type (application/pdf). The program can now dynamically create and serve PDF documents based on HTML content thanks to this integration.

Route to Generate PDF

Make sure that the PDF generation routing is included in your Startup.cs file.

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

Run and Verify

Run your application to ensure that you can create PDFs and that the bundling and minification are functioning properly.

dotnet run

dotnet run

Open the browser and navigate to your application. It should be possible for you to navigate to /pdf and download a PDF document.