Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Datatables .NET
.NET AIDE

Datatables .NET (Comment cela fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Les développeurs ASP.NET recherchent souvent des moyens efficaces de présenter des données tabulaires ou des tableaux HTML avec des fonctionnalités avancées telles que le tri, la recherche et la pagination. DataTables.NET est une puissante bibliothèque jQuery, JavaScript, et un outil très flexible qui facilite la création de tableaux interactifs et riches en fonctionnalités dans les applications web. Dans cet article, nous explorerons comment intégrer les fichiers de distribution de DataTables.NET, une bibliothèque améliorant les tableaux pour le traitement côté serveur dans un projet ASP.NET afin d'améliorer la présentation et l'expérience utilisateur des données tabulaires.

Comment utiliser DataTables dans une application Web ASP.NET ?

  1. Créer une application Web ASP.NET
  2. Ajouter le package de style Client-Side de DataTables
  3. Installer les packages Entity Framework Core, uniquement le logiciel de base
  4. Ajouter la Classe Modèle, le Contrôleur et la Page Razor
  5. Ajouter le code JavaScript dans le fichier JS
  6. Configurer le programme
  7. Construire et exécuter le programme
  8. Exporter les données dans un fichier Excel en utilisant IronXL pour l'exportation de données vers Excel

Qu'est-ce que DataTables.NET ?

DataTables.NET est une bibliothèque jQuery JavaScript qui vous permet de créer et de manipuler des tableaux interactifs dans des applications .NET. Elle est basée sur le plug-in jQuery DataTables, qui fournit des fonctionnalités API complètes telles que la pagination, le tri, le filtrage et le défilement pour les tableaux HTML dynamiques ainsi que statiques. C'est une bibliothèque améliorant les tableaux qui peut fonctionner avec diverses sources de données, telles que les bases de données SQL, AJAX ou les objets en mémoire.

Traitement côté serveur

Considérez un scénario où vous avez un point d'extrémité API fournissant un vaste ensemble de données de produits. L'approche standard consiste à ce que jQuery DataTables effectue un appel AJAX à cette API, obtienne une liste de produits au format JSON et rende un tableau HTML. Cela est connu comme le traitement côté client, qui est efficace pour les ensembles de données plus petits, allant généralement de 100 à 1000 enregistrements. Cependant, que se passe-t-il lorsque l'ensemble de données s'étend à 10 000 enregistrements ou plus ?

Lorsqu'on traite un nombre important d'enregistrements, il devient peu pratique d'envoyer l'ensemble de données entier au navigateur en une fois. Transmettre 10 000 enregistrements à la fois est non seulement gaspilleur en termes de bande passante mais met également à rude épreuve les ressources du navigateur. Dans de tels cas, une approche alternative, le traitement côté serveur, devient cruciale pour optimiser les performances.

Dans le traitement côté serveur, au lieu d'envoyer l'ensemble entier de données, l'API transmet les données en morceaux gérables, généralement paginés avec environ 50 enregistrements par page. Ce faisant, le temps de chargement est considérablement amélioré, car jQuery DataTables charge maintenant un nombre modeste d'enregistrements (~50) au lieu de traiter l'ensemble entier de données à la fois. Cette approche réduit l'utilisation du CPU et de la bande passante, créant une interaction plus efficace entre l'API et le DataTable.

Dans cet article, nous explorerons la mise en œuvre du traitement côté serveur dans une application ASP.NET Razor Page, démontrant comment gérer et afficher efficacement de vastes ensembles de données tout en améliorant la performance générale de votre application web.

Démarrer avec DataTables.NET dans ASP.NET 8

Pour commencer, nous devons ajouter la bibliothèque côté client DataTables.NET à notre projet. Cet article utilisera le projet ASP.NET Core Web App (Razor Pages) avec .NET 8. Vous pouvez utiliser n'importe quel projet d'application Web selon vos besoins.

Pour ajouter une bibliothèque côté client, cliquez avec le bouton droit sur la solution>Ajouter> Bibliothèque côté client, et recherchez les tableaux de données comme indiqué ci-dessous.

DataTables.NET (Comment cela fonctionne pour le développeur) : Figure 1 - Ajouter une bibliothèque côté client

Maintenant, nous devons ajouter la Classe Modèle, le Contexte DB, le Contrôleur, le tableau HTML et l'appel AJAX.

Mais avant cela, nous devons installer les packages Nuget EntityFramework pour connecter notre application à la base de données. Cet article utilisera l'approche Code First, vous pouvez utiliser Database first selon votre préférence.

Installez les packages hébergés localement suivants :

  1. Microsoft.EntityFrameworkCore
  2. Microsoft.EntityFrameworkCore.Design
  3. Microsoft.EntityFrameworkCore.SqlServer
  4. Microsoft.EntityFrameworkCore.Tools

Installez le package ci-dessus en utilisant la commande install-package depuis la console du gestionnaire de packages NuGet, ou installez-le depuis la solution du gestionnaire de packages NuGet en le recherchant.

Ajouter une classe de modèle

J'utilise la classe de modèle de produit pour cet exemple, vous pouvez l'utiliser selon vos besoins.

public class Product
{
    public int Id { get; set; }
    public string ProductName { get; set; } = string.Empty;
    public string ProductPrice { get; set; } = string.Empty;
    public string ProductWeight { get; set; } = string.Empty;
    public string ProductDescription { get; set; } = string.Empty;
    public DateTime ProductManufacturingDate { get; set; }
    public DateTime ProductExpiryDate { get; set; }
}
public class Product
{
    public int Id { get; set; }
    public string ProductName { get; set; } = string.Empty;
    public string ProductPrice { get; set; } = string.Empty;
    public string ProductWeight { get; set; } = string.Empty;
    public string ProductDescription { get; set; } = string.Empty;
    public DateTime ProductManufacturingDate { get; set; }
    public DateTime ProductExpiryDate { get; set; }
}
Public Class Product
	Public Property Id() As Integer
	Public Property ProductName() As String = String.Empty
	Public Property ProductPrice() As String = String.Empty
	Public Property ProductWeight() As String = String.Empty
	Public Property ProductDescription() As String = String.Empty
	Public Property ProductManufacturingDate() As DateTime
	Public Property ProductExpiryDate() As DateTime
End Class
$vbLabelText   $csharpLabel

Ajouter la classe ApplicationDBContext

public class ApplicationDBContext : DbContext
{
    public ApplicationDBContext(DbContextOptions<ApplicationDBContext> options) : base(options)
    {
    }
    public DbSet<Product> Products { get; set; }
}
public class ApplicationDBContext : DbContext
{
    public ApplicationDBContext(DbContextOptions<ApplicationDBContext> options) : base(options)
    {
    }
    public DbSet<Product> Products { get; set; }
}
Public Class ApplicationDBContext
	Inherits DbContext

	Public Sub New(ByVal options As DbContextOptions(Of ApplicationDBContext))
		MyBase.New(options)
	End Sub
	Public Property Products() As DbSet(Of Product)
End Class
$vbLabelText   $csharpLabel

Ajouter des contrôles d'interaction avancée

Nous ajouterons le ProductDatatables.js dans le dossier wwwroot/js pour ajouter des contrôles avancés tels que la pagination, la recherche, etc.

// Initialize the DataTables plugin for the HTML element with 'productDatatable' ID
$(document).ready(function () {
    $("#productDatatable").DataTable({
        "processing": true, // Enable processing indicator
        "serverSide": true, // Enable server-side processing
        "ajax": {
            "url": "/api/Product", // API endpoint for fetching product data
            "type": "POST",
            "datatype": "json"
        },
        "columnDefs": [{
            // Define properties for columns
            "targets": [0],
            "visible": false, // Hide the 'Id' column
            "searchable": false // Disable searching for the 'Id' column
        }],
        "columns": [
            { "data": "id", "name": "Id", "autoWidth": true },
            { "data": "productName", "name": "ProductName", "autoWidth": true },
            { "data": "productPrice", "name": "ProductPrice", "autoWidth": true },
            { "data": "productWeight", "name": "ProductWeight", "autoWidth": true },
            { "data": "productDescription", "name": "ProductDescription", "autoWidth": true },
            { "data": "productManufacturingDate", "name": "ProductManufacturingDate", "autoWidth": true },
            { "data": "productExpiryDate", "name": "ProductExpiryDate", "autoWidth": true },
            {
                // Add a 'Delete' button with an onclick event for deleting the product
                "render": function (data, type, row) { 
                    return "<a href='#' class='btn btn-danger' onclick=DeleteProduct('" + row.id + "');>Delete</a>"; 
                }
            }
        ]
    });
});
// Initialize the DataTables plugin for the HTML element with 'productDatatable' ID
$(document).ready(function () {
    $("#productDatatable").DataTable({
        "processing": true, // Enable processing indicator
        "serverSide": true, // Enable server-side processing
        "ajax": {
            "url": "/api/Product", // API endpoint for fetching product data
            "type": "POST",
            "datatype": "json"
        },
        "columnDefs": [{
            // Define properties for columns
            "targets": [0],
            "visible": false, // Hide the 'Id' column
            "searchable": false // Disable searching for the 'Id' column
        }],
        "columns": [
            { "data": "id", "name": "Id", "autoWidth": true },
            { "data": "productName", "name": "ProductName", "autoWidth": true },
            { "data": "productPrice", "name": "ProductPrice", "autoWidth": true },
            { "data": "productWeight", "name": "ProductWeight", "autoWidth": true },
            { "data": "productDescription", "name": "ProductDescription", "autoWidth": true },
            { "data": "productManufacturingDate", "name": "ProductManufacturingDate", "autoWidth": true },
            { "data": "productExpiryDate", "name": "ProductExpiryDate", "autoWidth": true },
            {
                // Add a 'Delete' button with an onclick event for deleting the product
                "render": function (data, type, row) { 
                    return "<a href='#' class='btn btn-danger' onclick=DeleteProduct('" + row.id + "');>Delete</a>"; 
                }
            }
        ]
    });
});
JAVASCRIPT

Maintenant, nous devons ajouter un tableau HTML.

Ajouter un tableau HTML

Écrivez le code suivant dans le fichier index.cshtml pour ajouter une page HTML statique.

@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}
<link href="~/lib/datatables/css/dataTables.bootstrap4.min.css" rel="stylesheet" />
<div class="container">
    <br />
    <div style="width:90%; margin:0 auto;">
        <table id="productDatatable" class="table table-striped table-bordered dt-responsive nowrap" width="100%" cellspacing="0">
            <thead>
                <tr>
                    <th>Id</th>
                    <th>Product Name</th>
                    <th>Product Price</th>
                    <th>Product Weight</th>
                    <th>Product Description</th>
                    <th>Product Manufacturing Date</th>
                    <th>Product Expiry Date</th>
                    <th>Actions</th>
                </tr>
            </thead>
        </table>
    </div>
</div>

@section Scripts {
    <script src="~/lib/datatables/js/jquery.dataTables.min.js"></script>
    <script src="~/lib/datatables/js/dataTables.bootstrap4.min.js"></script>
    <script src="~/js/ProductDatatable.js"></script>
}

Nous devons ajouter le contrôleur.

Ajouter le contrôleur de produit

Ajoutez le contrôleur de produit pour créer un point de terminaison et des demandes d'extraction directe.

[Route("api/[controller]")]
[ApiController]
public class ProductController : ControllerBase
{
    private readonly ApplicationDBContext context;
    public ProductController(ApplicationDBContext context)
    {
        this.context = context;
    }

    [HttpPost]
    public IActionResult GetProducts()
    {
        try
        {
            var draw = Request.Form["draw"].FirstOrDefault();
            var start = Request.Form["start"].FirstOrDefault();
            var length = Request.Form["length"].FirstOrDefault();
            var searchValue = Request.Form["search[value]"].FirstOrDefault();
            int pageSize = length != null ? Convert.ToInt32(length) : 0;
            int skip = start != null ? Convert.ToInt32(start) : 0;
            int recordsTotal = 0;
            var productData = context.Products.ToLis();

            // Filtering data based on provided search value
            if (!string.IsNullOrEmpty(searchValue))
            {
                productData = productData.Where(m => m.ProductName.Contains(searchValue)
                                            || m.ProductDescription.Contains(searchValue)
                                            || m.Id.ToString().Contains(searchValue)).ToList();
            }

            recordsTotal = productData.Count();
            var data = productData.Skip(skip).Take(pageSize).ToList();
            var jsonData = new { draw = draw, recordsFiltered = recordsTotal, recordsTotal = recordsTotal, data = data };
            return Ok(jsonData);
        }
        catch (Exception)
        {
            throw;
        }
    }
}
[Route("api/[controller]")]
[ApiController]
public class ProductController : ControllerBase
{
    private readonly ApplicationDBContext context;
    public ProductController(ApplicationDBContext context)
    {
        this.context = context;
    }

    [HttpPost]
    public IActionResult GetProducts()
    {
        try
        {
            var draw = Request.Form["draw"].FirstOrDefault();
            var start = Request.Form["start"].FirstOrDefault();
            var length = Request.Form["length"].FirstOrDefault();
            var searchValue = Request.Form["search[value]"].FirstOrDefault();
            int pageSize = length != null ? Convert.ToInt32(length) : 0;
            int skip = start != null ? Convert.ToInt32(start) : 0;
            int recordsTotal = 0;
            var productData = context.Products.ToLis();

            // Filtering data based on provided search value
            if (!string.IsNullOrEmpty(searchValue))
            {
                productData = productData.Where(m => m.ProductName.Contains(searchValue)
                                            || m.ProductDescription.Contains(searchValue)
                                            || m.Id.ToString().Contains(searchValue)).ToList();
            }

            recordsTotal = productData.Count();
            var data = productData.Skip(skip).Take(pageSize).ToList();
            var jsonData = new { draw = draw, recordsFiltered = recordsTotal, recordsTotal = recordsTotal, data = data };
            return Ok(jsonData);
        }
        catch (Exception)
        {
            throw;
        }
    }
}
<Route("api/[controller]")>
<ApiController>
Public Class ProductController
	Inherits ControllerBase

	Private ReadOnly context As ApplicationDBContext
	Public Sub New(ByVal context As ApplicationDBContext)
		Me.context = context
	End Sub

	<HttpPost>
	Public Function GetProducts() As IActionResult
		Try
			Dim draw = Request.Form("draw").FirstOrDefault()
			Dim start = Request.Form("start").FirstOrDefault()
			Dim length = Request.Form("length").FirstOrDefault()
			Dim searchValue = Request.Form("search[value]").FirstOrDefault()
			Dim pageSize As Integer = If(length IsNot Nothing, Convert.ToInt32(length), 0)
			Dim skip As Integer = If(start IsNot Nothing, Convert.ToInt32(start), 0)
			Dim recordsTotal As Integer = 0
			Dim productData = context.Products.ToLis()

			' Filtering data based on provided search value
			If Not String.IsNullOrEmpty(searchValue) Then
				productData = productData.Where(Function(m) m.ProductName.Contains(searchValue) OrElse m.ProductDescription.Contains(searchValue) OrElse m.Id.ToString().Contains(searchValue)).ToList()
			End If

			recordsTotal = productData.Count()
			Dim data = productData.Skip(skip).Take(pageSize).ToList()
			Dim jsonData = New With {
				Key .draw = draw,
				Key .recordsFiltered = recordsTotal,
				Key .recordsTotal = recordsTotal,
				Key .data = data
			}
			Return Ok(jsonData)
		Catch e1 As Exception
			Throw
		End Try
	End Function
End Class
$vbLabelText   $csharpLabel

Ici, nous avons mis en œuvre la pagination et la recherche côté serveur.

Maintenant, nous devons configurer notre base de données et ajouter une configuration à la classe Program.cs. Si vous utilisez .NET 5 ou une version inférieure, vous devrez peut-être le faire dans la classe Startup.cs.

Tout d'abord, ajoutez la chaîne de connexion suivante dans le fichier appsettings.json.

"ConnectionStrings": {
   "ProductDB": "Server=localserver\\SQLEXPRESS;Database=ProductDB;Trusted_Connection=True;MultipleActiveResultSets=true;TrustServerCertificate=True;"
}

Maintenant ajoutez le code suivant à la classe Program.cs.

public static void Main(string[] args)
{
    var builder = WebApplication.CreateBuilder(args);
    builder.Services.AddDbContext<ApplicationDBContext>(options =>
    {
         options.UseSqlServer(builder.Configuration.GetConnectionString("ProductDB"));
    });
    builder.Services.AddControllers();
    // Add services to the container.
    builder.Services.AddRazorPages();
    var app = builder.Build();
    // Configure the HTTP request pipeline.
    if (!app.Environment.IsDevelopment())
    {
         app.UseExceptionHandler("/Error");
         // The default HSTS value is 30 days.
         app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.MapControllers();
    app.MapRazorPages();
    app.Run();
}
public static void Main(string[] args)
{
    var builder = WebApplication.CreateBuilder(args);
    builder.Services.AddDbContext<ApplicationDBContext>(options =>
    {
         options.UseSqlServer(builder.Configuration.GetConnectionString("ProductDB"));
    });
    builder.Services.AddControllers();
    // Add services to the container.
    builder.Services.AddRazorPages();
    var app = builder.Build();
    // Configure the HTTP request pipeline.
    if (!app.Environment.IsDevelopment())
    {
         app.UseExceptionHandler("/Error");
         // The default HSTS value is 30 days.
         app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.MapControllers();
    app.MapRazorPages();
    app.Run();
}
Public Shared Sub Main(ByVal args() As String)
	Dim builder = WebApplication.CreateBuilder(args)
	builder.Services.AddDbContext(Of ApplicationDBContext)(Sub(options)
		 options.UseSqlServer(builder.Configuration.GetConnectionString("ProductDB"))
	End Sub)
	builder.Services.AddControllers()
	' Add services to the container.
	builder.Services.AddRazorPages()
	Dim app = builder.Build()
	' Configure the HTTP request pipeline.
	If Not app.Environment.IsDevelopment() Then
		 app.UseExceptionHandler("/Error")
		 ' The default HSTS value is 30 days.
		 app.UseHsts()
	End If
	app.UseHttpsRedirection()
	app.UseStaticFiles()
	app.UseRouting()
	app.UseAuthorization()
	app.MapControllers()
	app.MapRazorPages()
	app.Run()
End Sub
$vbLabelText   $csharpLabel

Nous devons exécuter la migration, car nous utilisons une approche code-first.

Exécutez la commande suivante dans la console du gestionnaire de packages.

Add-Migration init
Add-Migration init
SHELL

La commande ci-dessus créera une migration. Nous devons maintenant appliquer ces migrations à notre base de données. Exécutez la commande suivante dans la console du gestionnaire de packages.

Update-Database
Update-Database
SHELL

La commande ci-dessus créera des tables dans notre base de données. Ajoutez des données factices dans la table des produits; vous pouvez générer des données aléatoires depuis Mockaroo.

Maintenant, construisez et exécutez cette application.

Sortie

Nous pouvons voir que nous avons une interface utilisateur très interactive avec des contrôles d'interaction avancés.

DataTables.NET (Comment cela fonctionne pour le développeur) : Figure 2 - Sortie

Maintenant, la pagination est implémentée côté serveur comme indiqué ci-dessous.

DataTables.NET (Comment cela fonctionne pour le développeur) : Figure 3 - Pagination

Sortie UI

Les données sont ensuite rendues côté client avec des contrôles d'interface utilisateur riches.

DataTables.NET (Comment cela fonctionne pour le développeur) : Figure 4 - Interface utilisateur

Vous pouvez explorer plus en détail la documentation de DataTables.NET en cliquant sur explorer la documentation DataTables.NET.

Introduction à IronXL

IronXL - Bibliothèque Excel pour .NET est une bibliothèque qui vous permet de travailler avec des fichiers Excel dans des applications .NET. It can create Excel spreadsheets, read CSV files, edit Excel files, and export to Excel in various formats, such as XLS, XLSX, CSV, and TSV. It does not require Microsoft Office or Excel Interop to be installed. Il prend en charge .NET 8, 7, 6, 5, Core, Framework et Azure.

Nous avons souvent besoin d'exporter des données dans des fichiers Excel ou CSV. IronXL est le meilleur choix dans ce cas. Maintenant, nous allons écrire un code pour exporter nos données dans un fichier Excel.

Installer IronXL

Installez la bibliothèque IronXL dans notre projet en entrant la commande suivante dans la console du gestionnaire de packages.

Install-Package IronPdf

Cela installera IronXL et les dépendances requises dans notre projet.

Exporter des données vers Excel

Écrivons un code pour convertir notre liste de produits en fichier Excel.

public void ExportToExcel(List<Product> productList)
{
    WorkBook wb = WorkBook.Create(ExcelFileFormat.XLSX); // Create a new workbook instance
    WorkSheet ws = wb.DefaultWorkSheet; // Access the default worksheet
    int rowCount = 1;

    // Iterate over the product list and fill the worksheet
    foreach (Product product in productList)
    {
        ws["A" + rowCount].Value = product.Id.ToString();
        ws["B" + rowCount].Value = product.ProductName;
        ws["C" + rowCount].Value = product.ProductDescription;
        ws["D" + rowCount].Value = product.ProductPrice;
        ws["E" + rowCount].Value = product.ProductWeight;
        ws["F" + rowCount].Value = product.ProductManufacturingDate;
        ws["G" + rowCount].Value = product.ProductExpiryDate;
        rowCount++;
    }
    wb.SaveAs("product.xlsx"); // Save the workbook as an Excel file
}
public void ExportToExcel(List<Product> productList)
{
    WorkBook wb = WorkBook.Create(ExcelFileFormat.XLSX); // Create a new workbook instance
    WorkSheet ws = wb.DefaultWorkSheet; // Access the default worksheet
    int rowCount = 1;

    // Iterate over the product list and fill the worksheet
    foreach (Product product in productList)
    {
        ws["A" + rowCount].Value = product.Id.ToString();
        ws["B" + rowCount].Value = product.ProductName;
        ws["C" + rowCount].Value = product.ProductDescription;
        ws["D" + rowCount].Value = product.ProductPrice;
        ws["E" + rowCount].Value = product.ProductWeight;
        ws["F" + rowCount].Value = product.ProductManufacturingDate;
        ws["G" + rowCount].Value = product.ProductExpiryDate;
        rowCount++;
    }
    wb.SaveAs("product.xlsx"); // Save the workbook as an Excel file
}
Public Sub ExportToExcel(ByVal productList As List(Of Product))
	Dim wb As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX) ' Create a new workbook instance
	Dim ws As WorkSheet = wb.DefaultWorkSheet ' Access the default worksheet
	Dim rowCount As Integer = 1

	' Iterate over the product list and fill the worksheet
	For Each product As Product In productList
		ws("A" & rowCount).Value = product.Id.ToString()
		ws("B" & rowCount).Value = product.ProductName
		ws("C" & rowCount).Value = product.ProductDescription
		ws("D" & rowCount).Value = product.ProductPrice
		ws("E" & rowCount).Value = product.ProductWeight
		ws("F" & rowCount).Value = product.ProductManufacturingDate
		ws("G" & rowCount).Value = product.ProductExpiryDate
		rowCount += 1
	Next product
	wb.SaveAs("product.xlsx") ' Save the workbook as an Excel file
End Sub
$vbLabelText   $csharpLabel

Nous avons créé un fichier Excel à partir de la liste de manière très simple et facile.

DataTables.NET (Comment cela fonctionne pour le développeur) : Figure 5 - Sortie Excel

IronXL provides comprehensive tutorials on creating XLSX files, code examples for reading Excel, and API documentation to use its comprehensive API in the best way possible.

En optimisant les performances ASP.NET, nous nous appuyons exclusivement sur Seul le logiciel de base, assurant un environnement de développement léger et efficace. L'utilisation de DataTables.NET en tant que packages hébergés localement améliore encore la réactivité, minimisant les dépendances externes pour une gestion des données rationalisée et une exportation Excel. De plus, contribuer efficacement au code devient fluide dans cet écosystème optimisé et autonome.

IronPDF est une solution conçue pour convertir des pages Web, des URL, et du HTML en documents PDF. Les PDF générés conservent la mise en forme et les éléments stylistiques originaux des pages Web sources. Cet outil est particulièrement efficace pour créer des rendus PDF de contenu basé sur le Web tel que des rapports et des factures.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Conclusion

En résumé, tirer parti de DataTables.NET pour le traitement côté serveur dans les projets du dépôt de distribution ASP.NET s'avère être une bonne stratégie pour gérer efficacement des ensembles de données substantiels. Cette approche assure des performances optimisées en transmettant les données en morceaux gérables, atténuant l'utilisation de la bande passante et améliorant l'expérience utilisateur. L'intégration d'IronXL étend encore les capacités de l'application, permettant une exportation facile des données tabulaires vers Excel pour une analyse et un reporting complets des données.

En adoptant ces technologies, les développeurs peuvent créer des applications Web qui trouvent un équilibre entre interactivité riche et efficacité des ressources, offrant aux utilisateurs une expérience sans faille et réactive, notamment dans les scénarios où de grands ensembles de données sont impliqués. IronXL offre diverses options de licence pour IronXL, selon le nombre de développeurs, de projets et de besoins en redistribution. Les licences sont perpétuelles et incluent une assistance et des mises à jour gratuites.

Questions Fréquemment Posées

Comment intégrer DataTables.NET dans un projet ASP.NET ?

Pour intégrer DataTables.NET dans un projet ASP.NET, vous devez créer une application Web ASP.NET, ajouter des packages de style côté client de DataTables, installer des packages Entity Framework Core, ajouter des classes de modèle, des contrôleurs et des pages Razor, configurer JavaScript pour le traitement côté serveur, puis construire et exécuter votre projet.

Qu'est-ce que le traitement côté serveur dans DataTables.NET ?

Le traitement côté serveur dans DataTables.NET implique la transmission de données en morceaux gérables du serveur au client, plutôt que de charger l'ensemble du jeu de données en une fois. Cela améliore les performances en réduisant les temps de chargement et en minimisant l'utilisation du CPU et de la bande passante, notamment avec de grands jeux de données.

Pourquoi le traitement côté serveur est-il important dans DataTables.NET ?

Le traitement côté serveur est crucial pour optimiser les performances lors de la gestion de grands jeux de données. Il permet au serveur d'envoyer uniquement les données nécessaires au client, réduisant la charge sur le navigateur et améliorant l'efficacité globale.

Comment puis-je exporter des données tabulaires vers Excel dans une application ASP.NET ?

Vous pouvez utiliser la bibliothèque IronXL pour exporter des données tabulaires vers Excel dans une application ASP.NET. IronXL vous permet de créer et de manipuler des fichiers Excel directement à partir de vos listes de données sans avoir besoin de Microsoft Office ou d'Excel Interop.

Comment configurer une bibliothèque côté client dans ASP.NET pour DataTables ?

Pour configurer une bibliothèque côté client dans ASP.NET, cliquez avec le bouton droit sur votre solution dans Visual Studio, sélectionnez 'Ajouter', puis choisissez 'Bibliothèque côté client'. Vous pouvez rechercher et ajouter la bibliothèque souhaitée, telle que DataTables, ce qui améliorera la fonctionnalité de votre projet.

Quelles sont les étapes pour configurer DataTables.NET pour le traitement côté serveur ?

Pour configurer DataTables.NET pour le traitement côté serveur, assurez-vous d'avoir configuré une classe modèle, un contexte de base de données, un contrôleur et une table HTML. Vous devez également effectuer un appel AJAX et configurer la logique de traitement côté serveur dans vos fichiers JavaScript pour gérer la récupération et la manipulation des données.

Comment fonctionnent le filtrage et la pagination avec DataTables.NET ?

Le filtrage et la pagination dans DataTables.NET sont gérés via le traitement côté serveur. Le serveur filtre les données en fonction des critères de recherche et gère la pagination en envoyant des morceaux de données au client, assurant une gestion efficace des données.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit