.NET-HILFE

Datatables .NET (Wie es für Entwickler funktioniert)

Veröffentlicht 14. Januar 2024
Teilen Sie:

ASP.NET-Entwickler suchen oft nach effizienten Möglichkeiten zur Darstellung von Tabellendaten oder HTML-Tabellen mit erweiterten Funktionen wie Sortieren, Suchen und Paginierung. DataTables.NET ist eine leistungsstarke jQuery- und JavaScript-Bibliothek und ein hochflexibles Tool, das die Erstellung von interaktiven und funktionsreichen Tabellen in Webanwendungen erleichtert. In diesem Artikel erfahren Sie, wie Sie DataTables.NET-Distributionsdateien, eine Bibliothek zur Tabellenerweiterung für die serverseitige Verarbeitung, in ein ASP.NET-Projekt integrieren, um die Darstellung und die Benutzerfreundlichkeit von Tabellendaten zu verbessern.

Wie verwendet man DataTables in ASP.NET-Webanwendungen?

  1. ASP.NET-Webanwendung erstellen

  2. DataTables Client Side Styling Paket hinzufügen

  3. Installieren Sie Entity Framework Core Packages, nur die Kernsoftware

  4. Modellklasse, Controller und Razor-Seite hinzufügen

  5. Hinzufügen von JavaScript-Code in der JS-Datei

  6. Konfiguration einrichten

  7. Erstellen und Ausführen des Programms

  8. Daten in eine Excel-Datei exportieren mit IronXL

Was ist Datatables.NET?

Datatables.NET ist eine jQuery JavaScript-Bibliothek, die es Ihnen ermöglicht, CDN zu erstellen und interaktive Tabellen in .NET-Anwendungen zu manipulieren. Es basiert auf dem jQuery DataTables-Plugin, das umfassende API-Funktionen wie Paginierung, Sortierung, Filterung und Scrolling für dynamische und statische HTML-Tabellen bietet. Es handelt sich um eine Bibliothek zur Tabellenerweiterung, die mit verschiedenen Datenquellen arbeiten kann, z. B. mit SQL-Datenbanken, AJAX oder In-Memory-Objekten.

Serverseitige Verarbeitung

Stellen Sie sich ein Szenario vor, in dem Sie einen API-Endpunkt haben, der einen umfangreichen Datensatz von Produkten liefert. Der Standardansatz besteht darin, dass jQuery DataTables einen AJAX-Aufruf an diese API macht, eine Liste von Produkten im JSON-Format abruft und eine HTML-Tabelle rendert. Dies wird als clientseitige Verarbeitung bezeichnet, die für kleinere Datensätze, in der Regel zwischen 100 und 1000 Datensätzen, effizient ist. Was passiert jedoch, wenn der Datensatz auf 10.000 oder mehr Datensätze anwächst?

Bei einer großen Anzahl von Datensätzen ist es unpraktisch, den gesamten Datensatz auf einmal an den Browser zu senden. Die gleichzeitige Übertragung von 10.000 Datensätzen ist nicht nur eine Verschwendung von Bandbreite, sondern belastet auch die Browser-Ressourcen. In solchen Fällen wird ein alternativer Ansatz, die serverseitige Verarbeitung, für die Optimierung der Leistung entscheidend.

Bei der serverseitigen Verarbeitung sendet die API nicht den gesamten Datensatz, sondern Daten in überschaubaren Paketen, in der Regel paginiert mit etwa 50 Datensätzen pro Seite. Auf diese Weise wird die Ladezeit erheblich verbessert, da jQuery DataTables nun eine bescheidene Anzahl von Datensätzen lädt (~50) anstatt den gesamten Datensatz auf einmal zu bearbeiten. Dieser Ansatz reduziert die CPU- und Bandbreitennutzung und schafft eine effizientere Interaktion zwischen der API und der DataTable.

In diesem Artikel wird die Implementierung der serverseitigen Verarbeitung in einer ASP.NET Razor Page-Anwendung untersucht. Es wird gezeigt, wie umfangreiche Datensätze effizient verarbeitet und angezeigt werden können, während gleichzeitig die Gesamtleistung Ihrer Webanwendung verbessert wird.

Erste Schritte mit Datatables.NET in ASP.NET 8

Um zu beginnen, müssen wir Datatables.NET Client Side Library in unser Projekt hinzufügen. Dieser Artikel verwendet die ASP.NET Core Web App (Rasierklingen-Seiten) projekt mit .NET 8. Sie können ein beliebiges Web-App-Projekt nach Ihren Anforderungen verwenden.

Um eine clientseitige Bibliothek hinzuzufügen, klicken Sie mit der rechten Maustaste auf Lösung>Hinzufügen>Clientseitige Bibliothek und suchen Sie nach Datentabellen, wie unten gezeigt.

Datentabellen .NET (Wie es für Entwickler funktioniert): Abbildung 1 - Client-seitige Bibliothek hinzufügen

Jetzt müssen wir die Modellklasse, den DB-Kontext, den Controller, die HTML-Tabelle und den AJAX-Aufruf hinzufügen.

Aber vorher müssen wir die EntityFramework Nuget-Pakete installieren, um unsere Anwendung mit der Datenbank zu verbinden. In diesem Artikel wird der "Code First"-Ansatz verwendet, Sie können aber auch den "Database First"-Ansatz verwenden, wenn Sie dies bevorzugen.

Installieren Sie die folgenden lokal gehosteten Pakete:

  1. Microsoft.EntityFrameworkCore

  2. Microsoft.EntityFrameworkCore.Entwurf

  3. Microsoft.EntityFrameworkCore.SqlServer

  4. Microsoft.EntityFrameworkCore.Tools

    Installieren Sie das obige Paket mit dem Befehl install-package aus der NuGet Package Manager Console oder installieren Sie es aus der NuGet Package Manager-Lösung, indem Sie es suchen.

Modellklasse hinzufügen

Ich verwende die Produktmodellklasse für dieses Beispiel, Sie können sie je nach Ihren Anforderungen verwenden.

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
VB   C#

ApplicationDBContext-Klasse hinzufügen

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
VB   C#

Erweiterte Interaktionssteuerungen hinzufügen

Wir fügen die Datei ProductDatatables.js in den Ordner wwwroot>js ein, um erweiterte Steuerelemente wie Seitennummerierung, Suche usw. hinzuzufügen.

//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>"; }
            },
        ]
    });
});
//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>"; }
            },
        ]
    });
});
'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>"; }
		},
		)
}); })
VB   C#

Nun müssen wir eine HTML-Tabelle hinzufügen.

HTML-Tabelle hinzufügen

Schreiben Sie den folgenden Code in die Datei index.cshtml, um eine statische HTML-Seite hinzuzufügen.

//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>
}
'static HTML page
page model ReadOnly Property () As IndexModel
	ViewData ("Title") = "Home page"
End Property
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: <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
"100%" cellspacing="0"> (Of thead) (Of tr) (Of th) Id</th> (Of th) Product Name</th> (Of th) Product Price</th> (Of th) Product Weight</th> (Of th) Product Description</th> (Of th) Product Manufacturing [Date]</th> (Of th) Product Expiry [Date]</th> (Of th) Actions</th> </tr> </thead> </table> </div> </div> section Scripts
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: Friend <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
"table table-striped table-bordered dt-responsive nowrap" width="100%" cellspacing
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: Private Friend <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
"productDatatable" class="table table-striped table-bordered dt-responsive nowrap" width
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: Private Private Friend <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
"width:90%; margin:0 auto;"> <table id="productDatatable" class
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: Private Private Private Friend <link href="~/lib/datatables/css/dataTables.bootstrap4.min.css" rel="stylesheet" /> <div Class="container"> <br /> <div style="width:90%; margin:0 auto;"> <table id
'INSTANT VB WARNING: Instant VB cannot determine whether both operands of this division are integer types - if they are then you should use the VB integer division operator:
"container"> <br /> <div style="width:90%; margin:0 auto;"> <table id
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: Private Private Private Private Friend <link href="~/lib/datatables/css/dataTables.bootstrap4.min.css" rel="stylesheet" /> <div Class="container"> <br /> <div style
'INSTANT VB WARNING: Instant VB cannot determine whether both operands of this division are integer types - if they are then you should use the VB integer division operator:
"stylesheet" /> <div Class="container"> <br /> <div style
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: Private Private Private Private Private Friend <link href="~/lib/datatables/css/dataTables.bootstrap4.min.css" rel="stylesheet" /> <div Class
"~/lib/datatables/css/dataTables.bootstrap4.min.css" rel="stylesheet" /> <div Class
Private Private Private Private Private Private Private Friend <link href="~/lib/datatables/css/dataTables.bootstrap4.min.css" rel
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: <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>
	"~/lib/datatables/js/dataTables.bootstrap4.min.js"></script> <script src="~/js/ProductDatatable.js"></script>
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: Private <script src="~/lib/datatables/js/jquery.dataTables.min.js"></script> <script src="~/lib/datatables/js/dataTables.bootstrap4.min.js"></script> <script src
	"~/lib/datatables/js/jquery.dataTables.min.js"></script> <script src="~/lib/datatables/js/dataTables.bootstrap4.min.js"></script> <script src
	Private Private Private <script src="~/lib/datatables/js/jquery.dataTables.min.js"></script> <script src
End Class
VB   C#

Wir müssen den Controller hinzufügen.

Produkt-Controller hinzufügen

Produkt-Controller für die Erstellung von Endpunkten und direkten Pull-Anfragen hinzufügen.

[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;
        }
    }
}
<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.ToList()
			If Not String.IsNullOrEmpty(searchValue) Then
				productData = productData.Where(Function(m) m.ProductName.Contains(searchValue) m.ProductDescription.Contains(searchValue) 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 ex As Exception
			Throw
		End Try
	End Function
End Class
VB   C#

Hier haben wir die Paginierung und die Suche auf der Serverseite implementiert.

Nun müssen wir unsere Datenbank einrichten und der Klasse Program.cs eine Konfiguration hinzufügen. Wenn Sie .NET 5 oder eine niedrigere Version verwenden, müssen Sie dies möglicherweise in der Klasse Startup.cs tun.

Fügen Sie zunächst den folgenden Connection String in die Datei appsettings.json ein.

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

Fügen Sie nun der Klasse Program.cs den folgenden Code hinzu.

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();
 }
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. You may want to change this for production scenarios, see .NET documentation https://aka.ms/aspnetcore-hsts.
		 app.UseHsts()
	 End If
	 app.UseHttpsRedirection()
	 app.UseStaticFiles()
	 app.UseRouting()
	 app.UseAuthorization()
	 app.MapControllers()
	 app.MapRazorPages()
	 app.Run()
End Sub
VB   C#

Wir müssen die Migration durchführen, da wir einen Code-First-Ansatz verwenden.

Führen Sie den folgenden Befehl in der Paketmanager-Konsole aus.

Add-Migration init

Mit dem obigen Befehl wird eine Migration erstellt. Nun müssen wir diese Migrationen auf unsere Datenbank anwenden. Führen Sie den folgenden Befehl in der Paketmanager-Konsole aus.

Update-Database

Mit dem obigen Befehl werden Tabellen in unserer Datenbank erstellt. Fügen Sie Dummy-Daten in die Produkttabelle ein, Sie können Zufallsdaten aus Mockaroo.

Erstellen Sie nun diese Anwendung und führen Sie sie aus.

Ausgabe

Wir können sehen, dass wir eine sehr interaktive Benutzeroberfläche mit fortschrittlichen Interaktionssteuerungen haben.

Datentabellen .NET (Wie es für Entwickler funktioniert): Abbildung 2 - Ausgabe

Jetzt wird die Paginierung auf der Serverseite wie unten gezeigt implementiert.

Datentabellen .NET (So funktioniert es für Entwickler): Abbildung 3 - Paginierung

Ausgabe UI

Die Daten werden dann auf der Client-Seite mit Rich UI Control gerendert.

Datentabellen .NET (Wie es für Entwickler funktioniert): Abbildung 4 - UI

Weitere Informationen finden Sie in der DataTables.NET-Dokumentation, indem Sie auf hier.

Einführung von IronXL

IronXL ist eine Bibliothek, die es Ihnen ermöglicht, mit Excel-Dateien in .NET-Anwendungen zu arbeiten. Sie kann erstellen, lesen, bearbeitenund speichern Excel-Dokumente in verschiedenen Formaten, wie XLS, XLSX, CSV und TSV. Die Installation von Microsoft Office oder Excel Interop ist nicht erforderlich. Es unterstützt .NET 8, 7, 6, 5, Core, Framework und Azure.

Wir haben oft die Anforderung, Daten in Excel- oder CSV-Dateien zu exportieren. IronXL ist in diesem Fall die beste Wahl. Jetzt werden wir einen Code schreiben, um unsere Daten in eine Excel-Datei zu exportieren.

IronXL installieren

Installieren Sie die IronXL-Bibliothek in unserem Projekt, indem Sie den folgenden Befehl in der Paketmanager-Konsole eingeben.

Install-Package ironXL.Excel

Dadurch werden IronXL und die erforderlichen Abhängigkeiten in unserem Projekt installiert.

Daten nach Excel exportieren

Lassen Sie uns einen Code schreiben, um unsere Produktliste in eine Excel-Datei zu konvertieren.

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");
   }
Public Sub ExportToExcel(ByVal productList As List(Of Product))
	   Dim wb As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
	   Dim ws As WorkSheet = wb.DefaultWorkSheet
	   Dim rowCount As Integer = 1
	   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")
End Sub
VB   C#

Wir haben aus der Liste auf sehr einfache Weise eine Excel-Datei erstellt.

Datentabellen .NET (Wie es für Entwickler funktioniert): Abbildung 5 - Excel-Ausgabe

IronXL bietet umfassende tutorials, code-Beispieleund dokumentation seine umfassende API optimal zu nutzen.

Bei der Optimierung der ASP.NET-Performance setzen wir ausschließlich auf Only Core Software, um eine schlanke und effiziente Entwicklungsumgebung zu gewährleisten. Die Verwendung von DataTables.NET als lokal gehostete Pakete verbessert die Reaktionsfähigkeit weiter und minimiert die externen Abhängigkeiten für eine optimierte Datenverarbeitung und den Excel-Export. Darüber hinaus wird das Einbringen von Code innerhalb dieses optimierten und in sich geschlossenen Ökosystems nahtlos möglich.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Nutzung von DataTables.NET für die serverseitige Verarbeitung in ASP.NET-Distributionsprojekten eine gute Strategie für die effiziente Verarbeitung umfangreicher Datensätze ist. Dieser Ansatz gewährleistet eine optimierte Leistung durch die Übertragung von Daten in überschaubaren Paketen, die Verringerung der Bandbreitennutzung und die Verbesserung der Benutzerfreundlichkeit. Die Integration von IronXL erweitert die Möglichkeiten der Anwendung und ermöglicht den mühelosen Export von Tabellendaten nach Excel für umfassende Datenanalysen und Berichte.

Durch den Einsatz dieser Technologien können Entwickler Webanwendungen erstellen, die ein Gleichgewicht zwischen reichhaltiger Interaktivität und Ressourceneffizienz herstellen und den Nutzern ein nahtloses und reaktionsschnelles Erlebnis bieten, insbesondere in Szenarien, in denen große Datensätze involviert sind. IronXL bietet verschiedene lizenzierungabhängig von der Anzahl der Entwickler, der Projekte und dem Verteilungsbedarf. Die Lizenzen sind unbefristet und beinhalten kostenlosen Support und Updates.

< PREVIOUS
Sqlite C# .NET (So funktioniert es für Entwickler)
NÄCHSTES >
C# Null-Koaleszenz (So funktioniert es für Entwickler)

Sind Sie bereit, loszulegen? Version: 2024.10 gerade veröffentlicht

Gratis NuGet-Download Downloads insgesamt: 11,308,499 Lizenzen anzeigen >