Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. jQuery DataTable
.NET HILFE

Jquery Datatable (Wie es für Entwickler funktioniert)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Die Datenpräsentation ist ein entscheidender Aspekt der Webentwicklung. Wenn es um tabellarische Daten geht, ist eine interaktive und funktionsreiche Tabelle unerlässlich. jQuery DataTables ist eine leistungsstarke JavaScript-Bibliothek, die erweiterte Funktionen zur Erstellung dynamischer und reaktionsschneller Tabellen bietet. In diesem Artikel werden wir erkunden, wie man jQuery DataTables in eine ASP.NET-Webanwendung integriert und verwendet, um die Präsentation tabellarischer Daten zu verbessern.

Wie verwendet man jQuery DataTables in einer ASP.NET Web App?

  1. Erstellen oder öffnen Sie eine Webanwendung.
  2. Installieren Sie Entity-Framework-Pakete.
  3. Fügen Sie Modell, DB-Kontext und Controller hinzu.
  4. DB-Verbindungszeichenfolge hinzufügen und Konfiguration einrichten.
  5. Migration hinzufügen und Datenbank aktualisieren.
  6. Clientseitige Bibliothek von jQuery DataTables hinzufügen.
  7. Fügen Sie eine HTML-Tabelle und JavaScript-Code hinzu.
  8. Bauen und führen Sie die Anwendung aus.
  9. Exportieren Sie Daten in Excel mit IronXL für Excel-Verarbeitung.

Was ist jQuery DataTables?

jQuery DataTables ist ein leichtgewichtiger, flexibler und funktionsreicher jQuery-Plugin zur Verarbeitung tabellarischer Daten. Es bietet eine Vielzahl von Funktionen, wie Sortieren, Suchen und Paginierung, was es zur idealen Wahl macht, um große Datensätze benutzerfreundlich zu präsentieren.

Client-seitige Verarbeitung

Bei der clientseitigen Verarbeitung ist der Browser in der Lage, den Datensatz lokal zu bearbeiten. jQuery DataTables ermöglicht durch seine leistungsstarken Funktionen eine dynamische Interaktion und Bearbeitung der Daten direkt im Browser des Benutzers. Während dieser Ansatz nahtlos bei kleineren Datensätzen funktioniert, kann er bei umfangreichen Datensätzen auf Herausforderungen stoßen, aufgrund möglicher Leistungsengpässe und erhöhtem Ressourcenverbrauch.

In diesem Artikel werden wir die clientseitige Verarbeitung in einer ASP.NET Razor Page Anwendung erkunden, wobei wir die Vorteile für kleinere Datensätze hervorheben sowie Einblicke in potenzielle Überlegungen und Optimierungen geben, um ein reibungsloses und reaktionsfreudiges Nutzererlebnis zu gewährleisten.

Einstieg in jQuery DataTables in einer ASP.NET-Webanwendung

Dieser Artikel verwendet eine ASP.NET Razor Page-Webanwendung, die auf .NET Framework 4.8 abzielt. Sie können Blazor, MVC oder Web Forms nach Ihren Anforderungen verwenden.

Der Code-First-Ansatz wird in diesem Artikel verwendet. Sie können den Database-First-Ansatz nach Belieben verwenden. Wir müssen die folgenden Pakete installieren, um den Code First-Ansatz zu verwenden.

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

Installieren Sie die obigen Pakete, indem Sie den Install-Package-Befehl in der NuGet Package Manager-Konsole verwenden oder installieren Sie sie im NuGet Package Manager durch Suchen nach ihnen.

Richten wir unser Projekt ein, indem wir die Modellklasse, die ApplicationDbContext-Klasse, den Controller, die Verbindungszeichenfolge und die Dienste-Konfiguration in der Program.cs hinzufügen.

Modellklasse hinzufügen

Ich verwende die Employee-Modellklasse für dieses Beispiel. Sie können sie nach Belieben verwenden.

public class Employee
{
    public int Id { get; set; }
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public string PhoneNumber { get; set; } = string.Empty;
    public string Gender { get; set; } = string.Empty;
    public string Designation { get; set; } = string.Empty;
}
public class Employee
{
    public int Id { get; set; }
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public string PhoneNumber { get; set; } = string.Empty;
    public string Gender { get; set; } = string.Empty;
    public string Designation { get; set; } = string.Empty;
}
Public Class Employee
	Public Property Id() As Integer
	Public Property FirstName() As String = String.Empty
	Public Property LastName() As String = String.Empty
	Public Property Email() As String = String.Empty
	Public Property PhoneNumber() As String = String.Empty
	Public Property Gender() As String = String.Empty
	Public Property Designation() As String = String.Empty
End Class
$vbLabelText   $csharpLabel

Add ApplicationDbContext Klasse

Wir müssen die ApplicationDbContext-Klasse hinzufügen, um das Entity Framework einzurichten.

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
    {
    }

    public DbSet<Employee> Employees { get; set; }
}
public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
    {
    }

    public DbSet<Employee> Employees { get; set; }
}
Public Class ApplicationDbContext
	Inherits DbContext

	Public Sub New(ByVal options As DbContextOptions(Of ApplicationDbContext))
		MyBase.New(options)
	End Sub

	Public Property Employees() As DbSet(Of Employee)
End Class
$vbLabelText   $csharpLabel

Mitarbeiter-Controller hinzufügen

Fügen Sie den EmployeeController hinzu, um den Endpunkt zu erstellen.

[Route("api/[controller]")]
[ApiController]
public class EmployeeController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    public EmployeeController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public IActionResult GetEmployees()
    {
        try
        {
            var employeeData = _context.Employees.ToList();
            var jsonData = new { data = employeeData };
            return Ok(jsonData);
        }
        catch (Exception ex)
        {
            // Log exception here
            throw;
        }
    }
}
[Route("api/[controller]")]
[ApiController]
public class EmployeeController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    public EmployeeController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public IActionResult GetEmployees()
    {
        try
        {
            var employeeData = _context.Employees.ToList();
            var jsonData = new { data = employeeData };
            return Ok(jsonData);
        }
        catch (Exception ex)
        {
            // Log exception here
            throw;
        }
    }
}
<Route("api/[controller]")>
<ApiController>
Public Class EmployeeController
	Inherits ControllerBase

	Private ReadOnly _context As ApplicationDbContext

	Public Sub New(ByVal context As ApplicationDbContext)
		_context = context
	End Sub

	<HttpGet>
	Public Function GetEmployees() As IActionResult
		Try
			Dim employeeData = _context.Employees.ToList()
			Dim jsonData = New With {Key .data = employeeData}
			Return Ok(jsonData)
		Catch ex As Exception
			' Log exception here
			Throw
		End Try
	End Function
End Class
$vbLabelText   $csharpLabel

Hier verwenden wir die HttpGet-Methode, da wir die vollständigen Daten vom Server auf der Clientseite abrufen und Paginierung, Suchen und Sortieren auf der Clientseite implementieren werden. Wir geben ein JSON-Array zurück, das auf der Clientseite gerendert wird.

Anschlusszeichenfolge hinzufügen

Fügen Sie die folgende Verbindungszeichenfolge in die appsettings.json-Datei ein.

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

Fügen Sie die folgende Zeile in die Program.cs-Klasse unter der webApplication.CreateBuilder()-Zeile hinzu, um eine Verbindung mit dem SQL Server herzustellen.

builder.Services.AddDbContext<ApplicationDbContext>(options =>
{
    options.UseSqlServer(builder.Configuration.GetConnectionString("EmployeeDB"));
});
builder.Services.AddDbContext<ApplicationDbContext>(options =>
{
    options.UseSqlServer(builder.Configuration.GetConnectionString("EmployeeDB"));
});
builder.Services.AddDbContext(Of ApplicationDbContext)(Sub(options)
	options.UseSqlServer(builder.Configuration.GetConnectionString("EmployeeDB"))
End Sub)
$vbLabelText   $csharpLabel

Laufende Migration

Der nächste Schritt ist das Ausführen der Migration, da wir den Code First-Ansatz verwenden. Führen Sie den folgenden Befehl in der Package Manager-Konsole aus.

Add-Migration init
Add-Migration init
SHELL

Dieser Befehl erstellt eine Migration. Führen Sie nun den folgenden Befehl aus, um diese Migration auf die Datenbank anzuwenden.

update-database
update-database
SHELL

Da unser Projekt eingerichtet ist und die Datenbank bereit ist, müssen wir nur die jQuery-Bibliothek und HTML-Tabellen hinzufügen, um unsere Benutzeroberfläche bereitzustellen. Wir haben in diesem Beispiel SQL Server als Datenquelle verwendet, Sie können jedoch eine andere Datenbank nutzen.

Hinzufügen jQuery DataTables Bibliothek

Wir müssen die jQuery DataTables-Bibliothek hinzufügen, die ein Tabellenverbesserungs-Plugin für die jQuery-JavaScript-Bibliothek ist, in unser Projekt. Wir fügen es über einen Rechtsklick auf das Projekt und Auswahl von "Hinzufügen" und dann "Clientseitige Bibliothek hinzufügen" hinzu. Ein kleines Fenster wird angezeigt, in dem wir nach "jquery datatables" suchen und es installieren können, wie unten gezeigt:

jQuery DataTables Bibliothek hinzufügen

HTML-Tabelle hinzufügen

Fügen wir eine HTML-Tabelle mit leerem Tabellenkörper hinzu. Wir werden die erforderlichen Spaltenüberschriften beim Einrichten des jQuery DataTable hinzufügen. Fügen Sie den folgenden Code zur Index.cshtml-Datei hinzu.

@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="employeeDatatable" class="table table-striped table-bordered dt-responsive nowrap" width="100%" cellspacing="0">
        </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/EmployeeDatatable.js"></script>
}

Wir müssen die Datei EmployeeDatatable.js im wwwroot/Js-Ordner hinzufügen. In dieser Datei werden wir einen Ajax-Aufruf und erweiterte Funktionen der jQuery DataTable wie Filterung, Paginierung, Suchen, Sortieren usw. haben.

Erstellen der Datei EmployeeDatatable.js

Erstellen Sie eine EmployeeDatatable.js-Datei im Ordner wwwroot/Js. Fügen Sie folgenden Code hinzu.

$(document).ready(function () {
    $("#employeeDatatable").DataTable({
        "processing": true,
        "serverSide": false,
        "filter": true,
        "ajax": {
            "url": "/api/Employee",
            "type": "GET",
            "datatype": "json"
        },
        "columnDefs": [{
            "targets": [0],
            "visible": false,
            "searchable": false
        }],
        "columns": [
            { "data": "id", "title": "Employee ID", "name": "Employee ID", "autoWidth": true },
            { "data": "firstName", "title": "First Name", "name": "First Name", "autoWidth": true },
            { "data": "lastName", "title": "Last Name", "name": "Last Name", "autoWidth": true },
            { "data": "email", "title": "Email", "name": "Email", "autoWidth": true },
            { "data": "phoneNumber", "title": "Phone Number", "name": "Phone Number", "autoWidth": true },
            { "data": "gender", "title": "Gender", "name": "Gender", "autoWidth": true },
            { "data": "designation", "title": "Designation", "name": "Designation", "autoWidth": true }
        ]
    });
});
$(document).ready(function () {
    $("#employeeDatatable").DataTable({
        "processing": true,
        "serverSide": false,
        "filter": true,
        "ajax": {
            "url": "/api/Employee",
            "type": "GET",
            "datatype": "json"
        },
        "columnDefs": [{
            "targets": [0],
            "visible": false,
            "searchable": false
        }],
        "columns": [
            { "data": "id", "title": "Employee ID", "name": "Employee ID", "autoWidth": true },
            { "data": "firstName", "title": "First Name", "name": "First Name", "autoWidth": true },
            { "data": "lastName", "title": "Last Name", "name": "Last Name", "autoWidth": true },
            { "data": "email", "title": "Email", "name": "Email", "autoWidth": true },
            { "data": "phoneNumber", "title": "Phone Number", "name": "Phone Number", "autoWidth": true },
            { "data": "gender", "title": "Gender", "name": "Gender", "autoWidth": true },
            { "data": "designation", "title": "Designation", "name": "Designation", "autoWidth": true }
        ]
    });
});
JAVASCRIPT

Wir haben die funktionsreiche jQuery DataTables-Bibliothek genutzt. Dieses leistungsstarke jQuery-Plugin ermöglicht es uns, erweiterte Funktionen auf der Clientseite mit minimalem Aufwand zu implementieren.

Erstellen und führen Sie nun diese Anwendung aus.

Ausgabe

Wir können sehen, dass wir eine sehr interaktive Benutzeroberfläche mit Hilfe von jQuery in ASP.NET bereit haben. Die angezeigten Daten sind wie folgt:

jQuery DataTables Output

Jetzt ist die Paginierung auf der Clientseite implementiert, deshalb werden die vollständigen Daten wie unten gezeigt vom Server gesendet:

Paginierung

Ausgabeschnittstelle

Wir können suchen, sortieren und die Seite wechseln, alles wird auf der Clientseite wie unten gezeigt durchgeführt:

Ausgabe-Benutzeroberfläche

Einführung in IronXL

IronXL für .NET Excel-Dateiverarbeitung ist eine Bibliothek, die es Ihnen ermöglicht, mit Excel-Dateien in .NET-Anwendungen zu arbeiten. Es kann Excel-Dokumente in verschiedenen Formaten wie XLS, XLSX, CSV und TSV erstellen, lesen, bearbeiten und speichern. Es erfordert weder die Installation von Microsoft Office noch von Excel Interop. Es unterstützt .NET 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 Code schreiben, um unsere Daten in eine Excel-Datei zu exportieren.

IronXL installieren

Installieren Sie die IronXL-Bibliothek in Ihrem Projekt, indem Sie den folgenden Befehl in der Package Manager-Konsole eingeben.

Install-Package IronPdf

Dies wird IronXL und die erforderlichen Abhängigkeiten in unserem Projekt installieren. Sie können sie auch direkt von IronXL NuGet-Paket herunterladen.

Daten nach Excel exportieren

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

public void ExportToExcel(List<Employee> employeeList)
{
    // Create a new workbook instance
    WorkBook wb = WorkBook.Create(ExcelFileFormat.XLSX);
    // Get the default worksheet
    WorkSheet ws = wb.DefaultWorkSheet;

    // Add Header Row
    ws["A1"].Value = "Employee ID";
    ws["B1"].Value = "First Name";
    ws["C1"].Value = "Last Name";
    ws["D1"].Value = "Designation";
    ws["E1"].Value = "Gender";
    ws["F1"].Value = "Phone Number";
    ws["G1"].Value = "Email";

    int rowCount = 2;

    // Add Data Rows
    foreach (Employee employee in employeeList)
    {
        ws["A" + rowCount].Value = employee.Id.ToString();
        ws["B" + rowCount].Value = employee.FirstName;
        ws["C" + rowCount].Value = employee.LastName;
        ws["D" + rowCount].Value = employee.Designation;
        ws["E" + rowCount].Value = employee.Gender;
        ws["F" + rowCount].Value = employee.PhoneNumber;
        ws["G" + rowCount].Value = employee.Email;

        rowCount++;
    }

    // Save the workbook as an Excel file
    wb.SaveAs("Employee.xlsx");
}
public void ExportToExcel(List<Employee> employeeList)
{
    // Create a new workbook instance
    WorkBook wb = WorkBook.Create(ExcelFileFormat.XLSX);
    // Get the default worksheet
    WorkSheet ws = wb.DefaultWorkSheet;

    // Add Header Row
    ws["A1"].Value = "Employee ID";
    ws["B1"].Value = "First Name";
    ws["C1"].Value = "Last Name";
    ws["D1"].Value = "Designation";
    ws["E1"].Value = "Gender";
    ws["F1"].Value = "Phone Number";
    ws["G1"].Value = "Email";

    int rowCount = 2;

    // Add Data Rows
    foreach (Employee employee in employeeList)
    {
        ws["A" + rowCount].Value = employee.Id.ToString();
        ws["B" + rowCount].Value = employee.FirstName;
        ws["C" + rowCount].Value = employee.LastName;
        ws["D" + rowCount].Value = employee.Designation;
        ws["E" + rowCount].Value = employee.Gender;
        ws["F" + rowCount].Value = employee.PhoneNumber;
        ws["G" + rowCount].Value = employee.Email;

        rowCount++;
    }

    // Save the workbook as an Excel file
    wb.SaveAs("Employee.xlsx");
}
Public Sub ExportToExcel(ByVal employeeList As List(Of Employee))
	' Create a new workbook instance
	Dim wb As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
	' Get the default worksheet
	Dim ws As WorkSheet = wb.DefaultWorkSheet

	' Add Header Row
	ws("A1").Value = "Employee ID"
	ws("B1").Value = "First Name"
	ws("C1").Value = "Last Name"
	ws("D1").Value = "Designation"
	ws("E1").Value = "Gender"
	ws("F1").Value = "Phone Number"
	ws("G1").Value = "Email"

	Dim rowCount As Integer = 2

	' Add Data Rows
	For Each employee As Employee In employeeList
		ws("A" & rowCount).Value = employee.Id.ToString()
		ws("B" & rowCount).Value = employee.FirstName
		ws("C" & rowCount).Value = employee.LastName
		ws("D" & rowCount).Value = employee.Designation
		ws("E" & rowCount).Value = employee.Gender
		ws("F" & rowCount).Value = employee.PhoneNumber
		ws("G" & rowCount).Value = employee.Email

		rowCount += 1
	Next employee

	' Save the workbook as an Excel file
	wb.SaveAs("Employee.xlsx")
End Sub
$vbLabelText   $csharpLabel

Wir haben auf einfache und unkomplizierte Weise eine Excel-Datei aus einer Liste erstellt.

AUSGABEBild Excel-Datei

IronXL bietet umfassende Tutorials zur Erstellung von XLSX-Dateien, Codebeispiele zum Lesen von Excel-Dateien und detaillierte Dokumentation, um Ihnen zu helfen, die umfassende API bestmöglich zu nutzen.

Abschluss

Abschließend lässt sich sagen, dass jQuery DataTables als leistungsstarkes Werkzeug erschienen ist, um die Präsentation von tabellarischen Daten in ASP.NET-Webanwendungen zu transformieren. Sein leichtgewichtiges, aber funktionsreiches Wesen erleichtert die Erstellung interaktiver Tabellen und bringt Sortierung, Suche und Paginierung in den Vordergrund. Wir haben die Nuancen der clientseitigen Verarbeitung erforscht und die Möglichkeiten des Browsers für kleinere Datensätze genutzt, während wir potenzielle Herausforderungen bei größeren Datenmengen anerkannt haben. Die Schritt-für-Schritt-Anleitung zur Einrichtung einer ASP.NET Razor Page-Anwendung und der Integration von jQuery DataTables bietet Entwicklern praktische Einblicke. Produktcontroller hinzufügen zur Erstellung des Endpunkts und Abruf von Pull-Anfragen. Mit diesen Werkzeugen können Entwickler das Benutzererlebnis verbessern, indem sie Daten auf eine überzeugende und zugängliche Weise präsentieren.

IronXL bietet verschiedene Lizenzierungsoptionen an, abhängig von der Anzahl der Entwickler, Projekte und Neuverteilungserfordernissen. Die Lizenzen sind unbefristet und beinhalten kostenlosen Support sowie Updates.

Häufig gestellte Fragen

Wie kann jQuery DataTables die Darstellung von Daten in ASP.NET-Webanwendungen verbessern?

jQuery DataTables verbessert die Datenpräsentation durch Funktionen wie Sortieren, Suchen und Paginierung, die es Benutzern erleichtern, mit großen Datensätzen auf eine reaktionsschnelle und benutzerfreundliche Weise zu interagieren.

Was sind die grundlegenden Schritte zur Integration von jQuery DataTables in eine ASP.NET Razor Page-Anwendung?

Um jQuery DataTables in eine ASP.NET Razor Page-Anwendung zu integrieren, beginnt man mit dem Einrichten von Modell, DbContext und Controller, konfiguriert die Datenbankverbindung und implementiert die clientseitige Verarbeitung, um Daten effizient mit dem Code-First-Ansatz von Entity Framework zu verwalten.

Wie profitieren jQuery DataTables von der serverseitigen Verarbeitung beim Umgang mit großen Datensätzen?

Die serverseitige Verarbeitung entlastet jQuery DataTables, indem Datenoperationen auf den Server ausgelagert werden, was die Leistung und Effizienz beim Umgang mit großen Datensätzen erhöht, im Gegensatz zur clientseitigen Verarbeitung, die bei großen Datenmengen langsamer werden kann.

Welche Rolle spielt IronXL beim Exportieren von Daten zu Excel aus einer ASP.NET-Anwendung?

IronXL ermöglicht Entwicklern, Daten zu Excel zu exportieren, indem es ein neues Arbeitsbuch erstellt, es mit Datenreihen aus dem Datensatz füllt und als Excel-Datei speichert. Es vereinfacht die Bearbeitung von Excel-Dateien, ohne dass Microsoft Office benötigt wird.

Ist es möglich, mit Excel-Dateien in .NET-Anwendungen ohne Microsoft Office zu arbeiten?

Ja, IronXL ermöglicht .NET-Anwendungen, unabhängig von Microsoft Office mit Excel-Dateien zu arbeiten und unterstützt verschiedene Formate wie XLS, XLSX, CSV und TSV.

Welche Lizenzoptionen gibt es für die Nutzung von IronXL in .NET-Projekten?

IronXL bietet verschiedene Lizenzoptionen basierend auf der Anzahl der Entwickler, Projekte und Vertriebsanforderungen. Lizenzen sind unbefristet und beinhalten kostenlosen Support und Updates.

Welche Vorteile bietet der Code-First-Ansatz in ASP.NET mit jQuery DataTables?

Der Code-First-Ansatz in ASP.NET mit jQuery DataTables unterstützt die einfache Einrichtung und Konfiguration des Datenbankmodells und -kontexts, was eine dynamische Datenverwaltung und Integration mit den front-end DataTables für verbesserte Interaktivität ermöglicht.

Wie können Sie häufige Probleme mit jQuery DataTables in einer ASP.NET-Anwendung beheben?

Häufige Probleme mit jQuery DataTables können behoben werden, indem die korrekte Einbindung von Skripten und Stylesheets sichergestellt wird, die Pfade der Datenquelle überprüft werden, Konsolenfehler aufgrund von JavaScript-Problemen geprüft werden und ob eine korrekte serverseitige Verarbeitung eingerichtet ist.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen