Wie kann ich Excel-Dateien in Blazor Server-Anwendungen exportieren?

Sie können IronXL verwenden, um Excel-Dateien in Blazor Server-Anwendungen zu exportieren, indem Sie XLSX-Dateien direkt von Ihrem Server erstellen, formatieren und herunterladen, ohne Microsoft Office zu benötigen.

Muss ich Microsoft Office installiert haben, um IronXL in Blazor zu verwenden?

Nein, IronXL erfordert nicht, dass Microsoft Office auf Ihrem Server installiert ist, um Excel-Dateien in Blazor-Anwendungen zu erstellen, zu formatieren und zu exportieren.

Kann IronXL mit Blazor Anwendungen integriert werden?

Ja, IronXL lässt sich nahtlos in Blazor-Anwendungen integrieren, so dass Sie problemlos Excel-Exportfunktionen hinzufügen können.

Was sind die häufigsten Verwendungszwecke für den Export von Excel-Dateien in Webanwendungen?

Zu den üblichen Anwendungen gehören die Erstellung von Berichten, die Erstellung von Inventarlisten und die Erstellung von Kundenrechnungen im Excel-Format.

Gibt es Code-Beispiele für den Export von Excel-Dateien mit IronXL?

Ja, der Leitfaden enthält Code-Beispiele, die Ihnen helfen, Excel-Exportfunktionen in Ihrer Blazor Server-Anwendung mit IronXL zu implementieren.

Ist es möglich, Excel-Dateien in Blazor mit IronXL zu formatieren?

Ja, IronXL ermöglicht es Ihnen, Excel-Dateien zu formatieren, einschließlich der Einstellung von Stilen, dem Hinzufügen von Formeln und mehr, direkt in Blazor-Anwendungen.

Welche Arten von Excel-Dateien kann ich mit IronXL erstellen?

Sie können XLSX-Dateien mit IronXL erstellen, einem weit verbreiteten Excel-Dateiformat, das mit den meisten Tabellenkalkulationsprogrammen kompatibel ist.

Do I need Microsoft Office installed to use IronXL in Blazor?

No, IronXL does not require Microsoft Office to be installed on the server or client. This makes it an efficient solution for applications that need to generate and export Excel files in Blazor Server apps.

What are the licensing options for deploying IronXL in production?

IronXL offers various licensing options for deploying in production environments. Details about these options can be found on Iron Software's website, along with the opportunity to start a free trial.

How does IronXL enhance Blazor applications?

IronXL enhances Blazor applications by simplifying the process of generating Excel files and providing access to a range of advanced Excel features. This enhances the app's functionality and user engagement through professional-grade reporting.

Die C# Excel-Bibliothek

Explore IronXL Excel Spreadsheet Library for C# .NET Gratis testen

Excel-Dateien ohne Interop lesen

Alle Codebeispiele anzeigen

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

IRONXL VERWENDEN

Blazor Export nach Excel: Vollständige Anleitung zur Verwendung von IronXL in C#

Curtis Chau

Updated: 5. Januar 2026

Das Exportieren von Daten nach Excel ist etwas, das fast jede Web-App benötigt, sei es für die Erstellung von Berichten, Inventarlisten oder Kundenrechnungen. In einer Blazor Server-Anwendung kann es eine Herausforderung sein, dies zuverlässig zu erreichen, ohne Microsoft Office zu benötigen. An dieser Stelle kommt IronXL ins Spiel. Es ermöglicht Ihnen, Excel-Dateien direkt von Ihrem Server zu erstellen, zu formatieren und herunterzuladen, ohne dass eine Office-Installation erforderlich ist, und es integriert sich nahtlos in Blazor. In diesem Leitfaden erfahren Sie, wie einfach es ist, Ihrer App professionelle Excel-Exportfunktionen hinzuzufügen. Lassen Sie uns beginnen.

Erste Schritte mit IronXL zum Exportieren von Daten nach Excel

Das Einrichten von IronXL in einer Blazor Server-Anwendung erfordert minimale Konfiguration. Beginnen Sie mit der Erstellung eines neuen Blazor Server-Projekts in Visual Studio 2022 oder später, das auf .NET 6 oder höher abzielt.

Installieren Sie IronXL über die NuGet-Paketmanager-Konsole (siehe unser vollständiges Installationshandbuch für alternative Methoden):

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

Erstellen Sie als Nächstes eine JavaScript-Hilfsfunktion für Dateidownloads. Fügen Sie in Ihrem wwwroot-Ordner eine neue JavaScript-Datei namens excelExport.js hinzu:

window.downloadFileFromStream = async (fileName, contentStreamReference) => {
    const arrayBuffer = await contentStreamReference.arrayBuffer();
    const blob = new Blob([arrayBuffer]);
    const url = URL.createObjectURL(blob);
    const anchorElement = document.createElement('a');
    anchorElement.href = url;
    anchorElement.download = fileName ?? 'export.xlsx';
    anchorElement.click();
    anchorElement.remove();
    URL.revokeObjectURL(url);
}

window.downloadFileFromStream = async (fileName, contentStreamReference) => {
    const arrayBuffer = await contentStreamReference.arrayBuffer();
    const blob = new Blob([arrayBuffer]);
    const url = URL.createObjectURL(blob);
    const anchorElement = document.createElement('a');
    anchorElement.href = url;
    anchorElement.download = fileName ?? 'export.xlsx';
    anchorElement.click();
    anchorElement.remove();
    URL.revokeObjectURL(url);
}

JavaScript

Integrieren Sie dieses Skript in Ihre _Host.cshtml Datei:

<script src="~/excelExport.js"></script>

<script src="~/excelExport.js"></script>

HTML

Diese JavaScript-Funktion behandelt den Browser-seitigen Downloadmechanismus, der den Bytestream Ihrer Blazor Server-Anwendung in eine herunterladbare Datei konvertiert. Die Funktion erstellt eine temporäre Blob-URL, löst den Download aus und räumt Ressourcen auf, um Speicherlecks zu vermeiden.

Wie exportiere ich eine Datenquelle in Excel-Dateien mit IronXL?

Erstellen Sie einen Excel-Exportdienst, um Ihre Geschäftslogik zu handhaben. Dieser Dienst kapselt die IronXL-Funktionalität ein und bietet wiederverwendbare Methoden für verschiedene Export-Szenarien in Ihrer Blazor Excel-Export-Implementierung:

using IronXL;
using System.IO;
using ExportExcel.Models;
public class ExcelExportService
{
    public byte[] GenerateSalesReport(List<SalesData> salesData)
    {
        try
        {
            var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            workbook.Metadata.Author = "Sales Department";
            var worksheet = workbook.CreateWorkSheet("Monthly Sales");
            worksheet["A1"].Value = "Date";
            worksheet["B1"].Value = "Product";
            worksheet["C1"].Value = "Quantity";
            worksheet["D1"].Value = "Revenue";
            worksheet["E1"].Value = "Profit Margin";
            var headerRange = worksheet["A1:E1"];
            headerRange.Style.Font.Bold = true;
            headerRange.Style.BackgroundColor = "#4472C4";
            headerRange.Style.Font.Color = "#FFFFFF";
            int row = 2;
            foreach (var sale in salesData)
            {
                worksheet[$"A{row}"].Value = sale.Date.ToString("yyyy-MM-dd");
                worksheet[$"B{row}"].Value = sale.Product ?? "Unknown";
                worksheet[$"C{row}"].Value = sale.Quantity;
                worksheet[$"D{row}"].Value = sale.Revenue;
                worksheet[$"E{row}"].Value = $"=D{row}*0.15";
                row++;
            }
            worksheet.AutoSizeColumn(0, true);
            using var ms = workbook.ToStream();
            return ms.ToArray();
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException("Failed to generate sales report", ex);
        }
    }
}

using IronXL;
using System.IO;
using ExportExcel.Models;
public class ExcelExportService
{
    public byte[] GenerateSalesReport(List<SalesData> salesData)
    {
        try
        {
            var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            workbook.Metadata.Author = "Sales Department";
            var worksheet = workbook.CreateWorkSheet("Monthly Sales");
            worksheet["A1"].Value = "Date";
            worksheet["B1"].Value = "Product";
            worksheet["C1"].Value = "Quantity";
            worksheet["D1"].Value = "Revenue";
            worksheet["E1"].Value = "Profit Margin";
            var headerRange = worksheet["A1:E1"];
            headerRange.Style.Font.Bold = true;
            headerRange.Style.BackgroundColor = "#4472C4";
            headerRange.Style.Font.Color = "#FFFFFF";
            int row = 2;
            foreach (var sale in salesData)
            {
                worksheet[$"A{row}"].Value = sale.Date.ToString("yyyy-MM-dd");
                worksheet[$"B{row}"].Value = sale.Product ?? "Unknown";
                worksheet[$"C{row}"].Value = sale.Quantity;
                worksheet[$"D{row}"].Value = sale.Revenue;
                worksheet[$"E{row}"].Value = $"=D{row}*0.15";
                row++;
            }
            worksheet.AutoSizeColumn(0, true);
            using var ms = workbook.ToStream();
            return ms.ToArray();
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException("Failed to generate sales report", ex);
        }
    }
}

Imports IronXL
Imports System.IO
Imports ExportExcel.Models

Public Class ExcelExportService
    Public Function GenerateSalesReport(salesData As List(Of SalesData)) As Byte()
        Try
            Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            workbook.Metadata.Author = "Sales Department"
            Dim worksheet = workbook.CreateWorkSheet("Monthly Sales")
            worksheet("A1").Value = "Date"
            worksheet("B1").Value = "Product"
            worksheet("C1").Value = "Quantity"
            worksheet("D1").Value = "Revenue"
            worksheet("E1").Value = "Profit Margin"
            Dim headerRange = worksheet("A1:E1")
            headerRange.Style.Font.Bold = True
            headerRange.Style.BackgroundColor = "#4472C4"
            headerRange.Style.Font.Color = "#FFFFFF"
            Dim row As Integer = 2
            For Each sale In salesData
                worksheet($"A{row}").Value = sale.Date.ToString("yyyy-MM-dd")
                worksheet($"B{row}").Value = If(sale.Product, "Unknown")
                worksheet($"C{row}").Value = sale.Quantity
                worksheet($"D{row}").Value = sale.Revenue
                worksheet($"E{row}").Value = $"=D{row}*0.15"
                row += 1
            Next
            worksheet.AutoSizeColumn(0, True)
            Using ms = workbook.ToStream()
                Return ms.ToArray()
            End Using
        Catch ex As Exception
            Throw New InvalidOperationException("Failed to generate sales report", ex)
        End Try
    End Function
End Class

Imports IronXL
Imports System.IO
Imports ExportExcel.Models

Public Class ExcelExportService
    Public Function GenerateSalesReport(salesData As List(Of SalesData)) As Byte()
        Try
            Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            workbook.Metadata.Author = "Sales Department"
            Dim worksheet = workbook.CreateWorkSheet("Monthly Sales")
            worksheet("A1").Value = "Date"
            worksheet("B1").Value = "Product"
            worksheet("C1").Value = "Quantity"
            worksheet("D1").Value = "Revenue"
            worksheet("E1").Value = "Profit Margin"
            Dim headerRange = worksheet("A1:E1")
            headerRange.Style.Font.Bold = True
            headerRange.Style.BackgroundColor = "#4472C4"
            headerRange.Style.Font.Color = "#FFFFFF"
            Dim row As Integer = 2
            For Each sale In salesData
                worksheet($"A{row}").Value = sale.Date.ToString("yyyy-MM-dd")
                worksheet($"B{row}").Value = If(sale.Product, "Unknown")
                worksheet($"C{row}").Value = sale.Quantity
                worksheet($"D{row}").Value = sale.Revenue
                worksheet($"E{row}").Value = $"=D{row}*0.15"
                row += 1
            Next
            worksheet.AutoSizeColumn(0, True)
            Using ms = workbook.ToStream()
                Return ms.ToArray()
            End Using
        Catch ex As Exception
            Throw New InvalidOperationException("Failed to generate sales report", ex)
        End Try
    End Function
End Class

Dieser Dienst demonstriert wichtige IronXL-Funktionen, einschließlich der Erstellung neuer Arbeitsmappen und Arbeitsblätter, dem Hinzufügen formatierter Überschriften, dem Ausfüllen von Datenzeilen mit importierten Daten aus Ihrer Datenquelle, der Anwendung von Formeln und der Handhabung potenzieller Fehler. Die AutoSizeColumn Methode stellt sicher, dass Spalten ordnungsgemäß angezeigt werden, unabhängig von der Inhaltslänge. Für erweiterte Formatierungsoptionen sehen Sie sich unseren Zellstil-Leitfaden an.

Wie implementieren Sie den Dateidownload in Blazor?

Erstellen Sie eine Razor-Komponente, die den Exportdienst nutzt und die Benutzerinteraktion handhabt:

@page "/excel-export"
@using ExportExcel.Models
@inject ExcelExportService ExcelService
@inject IJSRuntime JS
<h3>Excel Export Dashboard</h3>
<div class="export-section">
    <button class="btn btn-primary" @onclick="ExportSalesReport" disabled="@isExporting">
        @if (isExporting)
        {
            <span>Generating...</span>
        }
        else
        {
            <span>Export Sales Report</span>
        }
    </button>
    @if (!string.IsNullOrEmpty(errorMessage))
    {
        <div class="alert alert-danger mt-2">@errorMessage</div>
    }
</div>
@code {
    private bool isExporting = false;
    private string errorMessage = "";
    private async Task ExportSalesReport()
    {
        try
        {
            isExporting = true;
            errorMessage = "";
            var salesData = GetSalesData();
            var fileBytes = ExcelService.GenerateSalesReport(salesData);
            using var stream = new MemoryStream(fileBytes);
            using var streamRef = new DotNetStreamReference(stream);
            await JS.InvokeVoidAsync("downloadFileFromStream",
                $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx", streamRef);
        }
        catch (Exception ex)
        {
            errorMessage = "Export failed. Please try again.";
        }
        finally
        {
            isExporting = false;
        }
    }
    private List<SalesData> GetSalesData()
    {
        return new List<SalesData>
        {
            new() { Date = DateTime.Now, Product = "Widget A",
                   Quantity = 100, Revenue = 5000 },
            new() { Date = DateTime.Now.AddDays(-1), Product = "Widget B",
                   Quantity = 75, Revenue = 3750 }
        };
    }
}

@page "/excel-export"
@using ExportExcel.Models
@inject ExcelExportService ExcelService
@inject IJSRuntime JS
<h3>Excel Export Dashboard</h3>
<div class="export-section">
    <button class="btn btn-primary" @onclick="ExportSalesReport" disabled="@isExporting">
        @if (isExporting)
        {
            <span>Generating...</span>
        }
        else
        {
            <span>Export Sales Report</span>
        }
    </button>
    @if (!string.IsNullOrEmpty(errorMessage))
    {
        <div class="alert alert-danger mt-2">@errorMessage</div>
    }
</div>
@code {
    private bool isExporting = false;
    private string errorMessage = "";
    private async Task ExportSalesReport()
    {
        try
        {
            isExporting = true;
            errorMessage = "";
            var salesData = GetSalesData();
            var fileBytes = ExcelService.GenerateSalesReport(salesData);
            using var stream = new MemoryStream(fileBytes);
            using var streamRef = new DotNetStreamReference(stream);
            await JS.InvokeVoidAsync("downloadFileFromStream",
                $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx", streamRef);
        }
        catch (Exception ex)
        {
            errorMessage = "Export failed. Please try again.";
        }
        finally
        {
            isExporting = false;
        }
    }
    private List<SalesData> GetSalesData()
    {
        return new List<SalesData>
        {
            new() { Date = DateTime.Now, Product = "Widget A",
                   Quantity = 100, Revenue = 5000 },
            new() { Date = DateTime.Now.AddDays(-1), Product = "Widget B",
                   Quantity = 75, Revenue = 3750 }
        };
    }
}

Text

Diese Komponente bietet dem Benutzer während des Exports Feedback, behandelt Fehler anmutig und generiert Dateinamen mit Zeitstempel. Der DotNetStreamReference Wrapper ermöglicht effizientes Streaming von Binärdaten zu JavaScript.

Ausgabe

Wenn wir unseren Code ausführen, sehen wir unsere Seite geladen mit dem Button, der für den Exportvorgang verwendet wird.

Blazor Export nach Excel: Vollständige Anleitung mit IronXL in C#: Bild 1 - Beispiel für eine Blazor-Seite

Wenn wir den Button klicken, werden die Daten in einem neuen Excel-Dokument gespeichert und die exportierte Datei heruntergeladen.

Blazor Export nach Excel: Vollständige Anleitung mit IronXL in C#: Bild 2 - Daten in eine Excel-Datei exportiert

Welche erweiterten Funktionen kann IronXL zu Ihrem Excel-Export hinzufügen?

IronXL unterstützt anspruchsvolle Excel-Funktionen für professionell aussehende Exporte. Für ein Inventarverwaltungsszenario könnten Sie bedingte Formatierung und mehrere Arbeitsblätter hinzufügen:

using IronXL;
using ExportExcel.Models;
using System.IO;
namespace ExportExcel.Services
{
    public class InventoryExportService
    {
        public byte[] GenerateInventoryReport(List<InventoryItem> items)
        {
            var workbook = WorkBook.Create();
            var details = workbook.CreateWorkSheet("Inventory Details");
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var row = i + 2;
                var item = items[i];
                details[$"A{row}"].Value = item.SKU;
                details[$"B{row}"].Value = item.Name;
                details[$"C{row}"].Value = item.Quantity;
                if (item.Quantity < item.ReorderLevel)
                {
                    details[$"C{row}"].Style.BackgroundColor = "#FFB6B6";
                }
            }
            using var stream = workbook.ToStream();
            return stream.ToArray();
        }
    }
}

using IronXL;
using ExportExcel.Models;
using System.IO;
namespace ExportExcel.Services
{
    public class InventoryExportService
    {
        public byte[] GenerateInventoryReport(List<InventoryItem> items)
        {
            var workbook = WorkBook.Create();
            var details = workbook.CreateWorkSheet("Inventory Details");
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var row = i + 2;
                var item = items[i];
                details[$"A{row}"].Value = item.SKU;
                details[$"B{row}"].Value = item.Name;
                details[$"C{row}"].Value = item.Quantity;
                if (item.Quantity < item.ReorderLevel)
                {
                    details[$"C{row}"].Style.BackgroundColor = "#FFB6B6";
                }
            }
            using var stream = workbook.ToStream();
            return stream.ToArray();
        }
    }
}

Imports IronXL
Imports ExportExcel.Models
Imports System.IO

Namespace ExportExcel.Services
    Public Class InventoryExportService
        Public Function GenerateInventoryReport(items As List(Of InventoryItem)) As Byte()
            Dim workbook = WorkBook.Create()
            Dim details = workbook.CreateWorkSheet("Inventory Details")
            details("A1").Value = "SKU"
            details("B1").Value = "Name"
            details("C1").Value = "Quantity"
            Dim headerRange = details("A1:C1")
            headerRange.Style.Font.Bold = True
            For i As Integer = 0 To items.Count - 1
                Dim row = i + 2
                Dim item = items(i)
                details($"A{row}").Value = item.SKU
                details($"B{row}").Value = item.Name
                details($"C{row}").Value = item.Quantity
                If item.Quantity < item.ReorderLevel Then
                    details($"C{row}").Style.BackgroundColor = "#FFB6B6"
                End If
            Next
            Using stream = workbook.ToStream()
                Return stream.ToArray()
            End Using
        End Function
    End Class
End Namespace

Imports IronXL
Imports ExportExcel.Models
Imports System.IO

Namespace ExportExcel.Services
    Public Class InventoryExportService
        Public Function GenerateInventoryReport(items As List(Of InventoryItem)) As Byte()
            Dim workbook = WorkBook.Create()
            Dim details = workbook.CreateWorkSheet("Inventory Details")
            details("A1").Value = "SKU"
            details("B1").Value = "Name"
            details("C1").Value = "Quantity"
            Dim headerRange = details("A1:C1")
            headerRange.Style.Font.Bold = True
            For i As Integer = 0 To items.Count - 1
                Dim row = i + 2
                Dim item = items(i)
                details($"A{row}").Value = item.SKU
                details($"B{row}").Value = item.Name
                details($"C{row}").Value = item.Quantity
                If item.Quantity < item.ReorderLevel Then
                    details($"C{row}").Style.BackgroundColor = "#FFB6B6"
                End If
            Next
            Using stream = workbook.ToStream()
                Return stream.ToArray()
            End Using
        End Function
    End Class
End Namespace

IronXL handhabt mehrere Arbeitsblätter mühelos, wendet bedingte Formatierungen basierend auf Geschäftsregeln an und unterstützt fortgeschrittene Excel-Funktionen wie Pivot-Tabellen und Diagramme, wenn nötig. Für detaillierte API-Dokumentation besuchen Sie unseren umfassenden Referenzleiter.

Blazor Export nach Excel: Vollständige Anleitung mit IronXL in C#: Bild 3 - Beispielausgabe erweiterter Funktionen

Abschluss

IronXL verwandelt die Erstellung von Excel-Dateien in Blazor Server-Anwendungen von einer komplexen Herausforderung in eine unkomplizierte Aufgabe. Seine intuitive API beseitigt die Notwendigkeit von Microsoft Office-Installationen und bietet gleichzeitig Zugang zu erweiterten Excel-Funktionen. Von einfachen Datenexporten bis hin zu komplexen Mehrblattberichten mit Formeln und Formatierungen, IronXL bewältigt alles mit ausgezeichneter Leistung und Zuverlässigkeit.

Bereit, Ihre Blazor-Anwendungen mit professionellen Excel-Exportfähigkeiten zu erweitern? Starten Sie noch heute Ihre kostenlose Testversion von IronXL, oder erforschen Sie unsere Lizenzierungsoptionen für den Produktionseinsatz.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.

...