Tableaux de données .NET
using System;
using FireSharp.Config;
using FireSharp.Interfaces;
using FireSharp.Response;
using IronPdf;
class Program
{
static void Main(string[] args)
{
// Step 1: Configure FireSharp
IFirebaseConfig config = new FirebaseConfig
{
AuthSecret = "your_firebase_auth_secret",
BasePath = "https://your_project_id.firebaseio.com/"
};
IFirebaseClient client = new FireSharp.FirebaseClient(config);
// Step 2: Retrieve data from Firebase
FirebaseResponse response = client.Get("users/1");
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
Console.WriteLine($"Error retrieving data: {response.StatusCode}");
return;
}
else
{
Console.WriteLine(response.Body);
}
// Deserialize the data (assuming the data is in a simple format)
var user = response.ResultAs<User>();
// Step 3: Generate PDF using IronPDF
var htmlContent = $"<h1>User Information</h1><p>Name: {user.Name}</p><p>Age: {user.Age}</p><p>Email: {user.Email}</p>";
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(htmlContent);
// Save the PDF to a file
pdf.SaveAs("UserInformation.pdf");
Console.WriteLine("PDF generated and saved successfully");
}
public class User
{
public string Name { get; set; }
public int Age { get; set; }
public string Email { get; set; }
}
}
Install-Package IronPdf
Les développeurs ASP.NET recherchent souvent des moyens efficaces de présenter des données tabulaires ou des tableaux HTML avec des fonctions avancées telles que le tri, la recherche et la pagination. DataTables.NET est une bibliothèque jQuery, JavaScript puissante 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 verrons comment intégrer les fichiers de distribution DataTables.NET, une bibliothèque d'amélioration des 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.
Créer une application Web ASP.NET
Ajouter le paquetage de style côté client de DataTables
Installer les Entity Framework Core Packages, uniquement le logiciel de base
Ajouter une classe de modèle, un contrôleur et une page Razor
Ajouter du code JavaScript dans le fichier JS
Mise en place de la configuration
Construire et exécuter le programme
DataTables.NET est une bibliothèque JavaScript jQuery qui permet de créer et de manipuler des tableaux interactifs dans les applications .NET. Il est basé sur le plug-in jQuery DataTables, qui offre des fonctions API complètes telles que la pagination, le tri, le filtrage et le défilement pour les tableaux HTML dynamiques ou statiques. Il s'agit d'une bibliothèque d'amélioration des tables qui peut fonctionner avec différentes sources de données, telles que les bases de données SQL, AJAX ou les objets en mémoire.
Prenons l'exemple d'un point d'accès à une API qui fournit un vaste ensemble de données sur les produits. L'approche standard implique que jQuery DataTables fasse un appel AJAX à cette API, obtienne une liste de produits au format JSON et rende un tableau HTML. C'est ce que l'on appelle le traitement côté client, qui est efficace pour les petits ensembles de données, généralement compris entre 100 et 1 000 enregistrements. Mais que se passe-t-il lorsque l'ensemble de données s'étend à 10 000 enregistrements ou plus ?
Lorsqu'il s'agit d'un nombre important d'enregistrements, il n'est pas pratique d'envoyer l'ensemble des données au navigateur en une seule fois. La transmission de 10 000 enregistrements en une seule fois n'est pas seulement un gaspillage en termes de bande passante, mais elle sollicite également 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, plutôt que d'envoyer l'ensemble des données, l'API transmet les données par morceaux gérables, généralement paginés avec environ 50 enregistrements par page. En procédant ainsi, le temps de chargement est considérablement amélioré, car jQuery DataTables charge désormais un nombre modeste d'enregistrements (~50) au lieu de gérer l'ensemble du jeu de données en une seule fois. Cette approche réduit l'utilisation de l'unité centrale et de la bande passante, créant ainsi une interaction plus efficace entre l'API et le tableau de données.
Dans cet article, nous allons explorer la mise en œuvre du traitement côté serveur dans une application ASP.NET Razor Page, en démontrant comment traiter et afficher efficacement des ensembles de données volumineux tout en améliorant les performances globales de votre application web.
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 Web App selon vos besoins.
Pour ajouter une bibliothèque côté client, cliquez avec le bouton droit de la souris sur Solution>Ajouter>Bibliothèque côté client et recherchez les tables de données comme indiqué ci-dessous.
Nous devons maintenant ajouter la classe de modèle, le contexte de la base de données, le contrôleur, la table HTML et l'appel AJAX.
Mais avant cela, nous devons installer les paquets Nuget EntityFramework pour connecter notre application à la base de données. Cet article utilise l'approche du code d'abord, vous pouvez utiliser la base de données d'abord selon votre préférence.
Installez les paquets suivants hébergés localement :
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.EntityFrameworkCore.Tools
Installez le paquet ci-dessus en utilisant la commande install-package de la console NuGet Package Manager, ou installez-le à partir de la solution NuGet Package Manager en le recherchant.
J'utilise la classe de modèle de produit pour cet exemple, vous pouvez l'utiliser en fonction de 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 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; }
}Nous ajouterons le fichier ProductDatatables.js dans le dossier wwwroot>js pour ajouter des contrôles avancés tels que la pagination, la recherche, etc.
//add advanced interaction controls
$(document).ready(function () {
$("#productDatatable").DataTable({
"processing": true,
"serverSide": true,
"filter": true,
"ajax": {
"url": "/api/Product",
"type": "POST",
"datatype": "json"
},
"columnDefs": [{
"targets": [0].data,
"visible": false,
"searchable": false
}],
"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 },
{
"render": function (data, row) { return "<a href="#" class='btn btn-danger' onclick=DeleteProduct('" + row.id + "'); >Delete</a>"; }
},
]
});
});Nous devons maintenant ajouter un tableau HTML.
Écrivez le code suivant dans le fichier index.cshtml pour ajouter une page HTML statique.
//static HTML page
@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>
}//static HTML page
@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.
Ajout d'un contrôleur de produit pour créer des points d'extrémité et des demandes directes de téléchargement.
[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.ToList();
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 ex)
{
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.ToList();
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 ex)
{
throw;
}
}
}Ici, nous avons mis en œuvre la pagination et la recherche du côté du serveur.
Nous devons maintenant configurer notre base de données et ajouter la 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;"
},Ajoutez maintenant 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. You may want to change this for production scenarios, see .NET documentation https://aka.ms/aspnetcore-hsts.
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. You may want to change this for production scenarios, see .NET documentation https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapControllers();
app.MapRazorPages();
app.Run();
}Nous devons exécuter la migration, car nous utilisons une approche "code-first".
Exécutez la commande suivante dans la console du gestionnaire de paquets.
Add-Migration initLa 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 paquets.
Update-DatabaseLa commande ci-dessus créera des tables dans notre base de données. Ajoutez des données fictives dans la table Produit, vous pouvez générer des données aléatoires depuis Mockaroo.
Maintenant, créez et exécutez cette application.
Nous pouvons voir que nous avons une interface utilisateur très interactive avec des contrôles d'interaction avancés.
La pagination est maintenant mise en œuvre du côté du serveur, comme indiqué ci-dessous.
Les données sont ensuite rendues sur le côté client à l'aide d'un contrôle d'interface utilisateur riche.
Vous pouvez explorer davantage la documentation de DataTables.NET en cliquant sur explorer la documentation de DataTables.NET.
IronXL - Bibliothèque Excel pour .NET est une bibliothèque qui vous permet de travailler avec des fichiers Excel dans des applications .NET. Il peut créer des feuilles de calcul Excel, lire des fichiers CSV, modifier des fichiers Excel et exporter vers Excel dans divers formats, tels que XLS, XLSX, CSV et TSV. Il n'est pas nécessaire d'installer Microsoft Office ou Excel Interop. Elle 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. Nous allons maintenant écrire un code pour exporter nos données dans un fichier Excel.
Installez la bibliothèque IronXL dans notre projet en entrant la commande suivante dans la console du gestionnaire de paquets.
Install-Package ironXL.ExcelCeci installera IronXL et les dépendances nécessaires dans notre projet.
Ecrivons un code pour convertir notre liste de produits en fichier Excel.
public void ExportToExcel(List<Product> productList)
{
WorkBook wb = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet ws = wb.DefaultWorkSheet;
int rowCount = 1;
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");
}public void ExportToExcel(List<Product> productList)
{
WorkBook wb = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet ws = wb.DefaultWorkSheet;
int rowCount = 1;
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");
}Nous avons créé un fichier Excel à partir de la liste d'une manière très simple et facile.
IronXL fournit des tutoriels complets sur la création de fichiers XLSX, des exemples de code pour lire Excel, et une documentation API pour utiliser son API complète de la meilleure façon possible.
Pour optimiser les performances de ASP.NET, nous nous appuyons exclusivement sur Only Core Software, ce qui garantit un environnement de développement allégé et efficace. L'utilisation de DataTables.NET en tant que progiciels hébergés localement améliore encore la réactivité, en minimisant les dépendances externes pour un traitement des données et une exportation Excel rationalisés. En outre, la contribution au code devient transparente 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 d'origine des pages web sources. Cet outil est particulièrement efficace pour créer des rendus PDF de contenus web tels 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");
}
}En résumé, l'utilisation de DataTables.NET pour le traitement côté serveur dans les projets de distribution ASP.NET s'avère être une bonne stratégie pour traiter efficacement des ensembles de données importants. Cette approche permet d'optimiser les performances en transmettant les données en morceaux gérables, en réduisant l'utilisation de la bande passante et en améliorant l'expérience de l'utilisateur. L'intégration d'IronXL étend encore les capacités de l'application, permettant d'exporter sans effort des données tabulaires vers Excel pour une analyse complète des données et l'établissement de rapports.
En adoptant ces technologies, les développeurs peuvent créer des applications web qui trouvent un équilibre entre une interactivité riche et l'efficacité des ressources, offrant aux utilisateurs une expérience transparente et réactive, en particulier dans les scénarios où de grands ensembles de données sont impliqués. IronXL propose diverses options de licence pour IronXL, en fonction du nombre de développeurs, des projets et des besoins de redistribution. Les licences sont perpétuelles et comprennent une assistance et des mises à jour gratuites.
Install-Package IronPdf
Aucune carte de crédit n'est requise
Votre clé d'essai devrait se trouver dans l'email.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com
Aucune carte de crédit n'est requise
Commencez GRATUITEMENT
Aucune carte de crédit n'est requise
Testez en production sans filigranes.
Fonctionne là où vous en avez besoin.
Obtenez 30 jours de produit entièrement fonctionnel.
Faites-le fonctionner en quelques minutes.
Accès complet à notre équipe d'ingénieurs pendant la période d'essai du produit
Aucune carte de crédit ou création de compte n'est nécessaire
Votre clé d'essai devrait être dans l'e-mail.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com
Commencez GRATUITEMENT
Aucune carte de crédit n'est requise
Testez en production sans filigranes.
Fonctionne là où vous en avez besoin.
Obtenez 30 jours de produit entièrement fonctionnel.
Faites-le fonctionner en quelques minutes.
Accès complet à notre équipe d'ingénieurs pendant la période d'essai du produit
Licences à partir de 749 $. Vous avez une question ? Contactez-nous.
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
10 produits .NET API pour vos documents de bureau
