Datentabellen .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
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-, JavaScript-Bibliothek und ein äußerst flexibles Werkzeug, das die Erstellung interaktiver und funktionsreicher 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.
ASP.NET-Webanwendung erstellen
DataTables Client Side Styling Paket hinzufügen
Installieren Sie Entity Framework Core Packages, nur die Kernsoftware
Modellklasse, Controller und Razor-Seite hinzufügen
Hinzufügen von JavaScript-Code in der JS-Datei
Konfiguration einrichten
Erstellen und Ausführen des Programms
DataTables.NET ist eine jQuery-JavaScript-Bibliothek, mit der Sie interaktive Tabellen in .NET-Anwendungen erstellen und manipulieren können. 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.
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. Dadurch wird die Ladezeit erheblich verbessert, da jQuery DataTables nun eine überschaubare Anzahl von Datensätzen (~50) lädt, anstatt den gesamten Datensatz auf einmal zu verarbeiten. 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.
Um zu beginnen, müssen wir die DataTables.NET Client Side Library zu unserem Projekt hinzufügen. Dieser Artikel wird das ASP.NET Core Web App (Razor Pages) Projekt mit .NET 8 verwenden. Sie können jedes beliebige Web App-Projekt gemäß 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.
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:
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer
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.
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 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; }
}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>"; }
},
]
});
});Nun müssen wir eine 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>
}Wir müssen den 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;
}
}
}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();
}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 initMit 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-DatabaseMit dem obigen Befehl werden Tabellen in unserer Datenbank erstellt. Fügen Sie Dummy-Daten in die Produkttabelle ein, Sie können zufällige Daten von Mockaroo generieren.
Erstellen Sie nun diese Anwendung und führen Sie sie aus.
Wir können sehen, dass wir eine sehr interaktive Benutzeroberfläche mit fortschrittlichen Interaktionssteuerungen haben.
Jetzt wird die Paginierung auf der Serverseite wie unten gezeigt implementiert.
Die Daten werden dann auf der Client-Seite mit Rich UI Control gerendert.
Sie können mehr aus der DataTables.NET-Dokumentation erkunden, indem Sie auf DataTables.NET-Dokumentation erkunden klicken.
IronXL - Excel-Bibliothek für .NET ist eine Bibliothek, die es Ihnen ermöglicht, in .NET-Anwendungen mit Excel-Dateien zu arbeiten. Es kann Excel-Tabellen erstellen, CSV-Dateien lesen, Excel-Dateien bearbeiten und in verschiedene Formate nach Excel exportieren, wie XLS, XLSX, CSV und TSV. Es erfordert keine Installation von Microsoft Office oder Excel Interop. Es werden .NET 8, 7, 6, 5, Core, Framework und Azure unterstützt.
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.
Installieren Sie die IronXL-Bibliothek in unserem Projekt, indem Sie den folgenden Befehl in der Paketmanager-Konsole eingeben.
Install-Package ironXL.ExcelDadurch werden IronXL und die erforderlichen Abhängigkeiten in unserem Projekt installiert.
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");
}Wir haben aus der Liste auf sehr einfache Weise eine Excel-Datei erstellt.
IronXL bietet umfassende Anleitungen zum Erstellen von XLSX-Dateien, Codebeispiele zum Lesen von Excel-Dateien und API-Dokumentation, um seine umfassende API auf die bestmögliche Weise 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.
IronPDF ist eine Lösung, die entwickelt wurde, um Webseiten, URLs und HTML in PDF-Dokumente zu konvertieren. Die generierten PDFs behalten die ursprüngliche Formatierung und die stilistischen Elemente der Quell-Webseiten bei. Dieses Tool ist besonders effektiv bei der Erstellung von PDF-Darstellungen webbasierter Inhalte wie Berichten und Rechnungen.
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");
}
}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 Lizenzierungsoptionen für IronXL, abhängig von der Anzahl der Entwickler, Projekte und der Notwendigkeit der Weiterverbreitung. Die Lizenzen sind unbefristet und beinhalten kostenlosen Support und Updates.
Install-Package IronPdf
Keine Kreditkarte erforderlich
Ihr Testschlüssel sollte in der E-Mail sein.
Wenn nicht, kontaktieren Sie bitte
support@ironsoftware.com
Keine Kreditkarte erforderlich
Starten Sie kostenlos
Keine Kreditkarte erforderlich
Testen Sie in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es benötigen.
Erhalten Sie 30 Tage lang ein voll funktionsfähiges Produkt.
Haben Sie es in wenigen Minuten einsatzbereit.
Vollständiger Zugang zu unserem technischen Support-Team während Ihrer Produkttestphase
Keine Kreditkarte oder Kontoerstellung erforderlich
Ihr Testschlüssel sollte sich in der E-Mail befinden.
Falls nicht, kontaktieren Sie bitte
support@ironsoftware.com
Starten Sie kostenlos
Keine Kreditkarte erforderlich
Testen Sie in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es benötigen.
Erhalten Sie 30 Tage lang ein voll funktionsfähiges Produkt.
Haben Sie es in wenigen Minuten einsatzbereit.
Vollständiger Zugang zu unserem technischen Support-Team während Ihrer Produkttestphase
Lizenzen ab $749. Haben Sie eine Frage? Kontaktieren Sie uns.
Buchen Sie eine persönliche 30-minütige Demo.
Kein Vertrag, keine Kartendetails, keine Verpflichtungen.
10 .NET API-Produkte für Ihre Bürodokumente
