Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. Migration von Fluid zu IronPDF
MIGRATIONSLEITFäDEN

Umstellung von Fluid (Templating) auf IronPDF

Curtis Chau
Curtis Chau
Veröffentlicht:

Fluid ist eine .NET-Bibliothek, die die Liquid-Templating-Sprache implementiert und Entwicklern eine flexible Möglichkeit bietet, dynamische Templates zu rendern und Inhalte von der Präsentationslogik zu trennen. Fluid eignet sich zwar gut zur Erzeugung dynamischer Textausgaben, unterstützt aber nicht direkt die PDF-Generierung – Entwickler müssen eine zusätzliche PDF-Bibliothek integrieren, um die HTML-Ausgabe in PDF-Dokumente zu konvertieren. Dieser Ansatz mit zwei Bibliotheken führt zu einer Komplexität, die viele Entwicklungsteams vermeiden möchten.

Dieser Leitfaden bietet einen vollständigen Migrationspfad von Fluid (Templating) mit externen PDF-Bibliotheken zuIronPDFmit Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen für professionelle .NET-Entwickler, die diesen Übergang evaluieren.

Warum von Fluid (Templating) zuIronPDFmigrieren

Fluid ist eine solide, auf Flüssigkeiten basierende Template-Engine, deren Verwendung zur PDF-Generierung jedoch erhebliche Komplexität mit sich bringt:

Zwei Bibliotheken erforderlich: Fluid generiert nur HTML – Sie benötigen eine separate PDF-Bibliothek (wkhtmltopdf, PuppeteerSharp usw.), um PDFs zu erstellen, was Ihre Abhängigkeiten und Ihren Wartungsaufwand verdoppelt.

Integrationskomplexität: Die Koordination zweier Bibliotheken bedeutet die Verwaltung zweier Konfigurationssätze, Fehlerbehandlung und Aktualisierungen. Wenn etwas nicht funktioniert, wird die Fehlersuche schwieriger.

Lernkurve der Liquid-Syntax: Entwickler müssen die Liquid-Templating-Syntax ( {{ }} , {% %} ) erlernen, obwohl C# bereits über leistungsstarke integrierte Funktionen zur Stringverarbeitung verfügt.

Eingeschränkte PDF-Kontrolle: Die Qualität Ihrer PDF-Ausgabe hängt von der PDF-Bibliothek ab, die Sie mit Fluid kombinieren, und nicht von einer dedizierten Rendering-Engine.

Herausforderungen bei der Fehlersuche: Fehler können sowohl bei der Erstellung der Vorlagen als auch bei der PDF-Generierung auftreten, was die Fehlersuche schwieriger macht als bei einer einzigen integrierten Lösung.

Bedenken hinsichtlich der Thread-Sicherheit: Vorlagenkontextist nicht threadsicher und erfordert in parallelen Anwendungen eine sorgfältige Verwaltung.

IronPDFvs. Fluid (Templating): Funktionsvergleich

Das Verständnis der architektonischen Unterschiede hilft technischen Entscheidungsträgern, die Investition in die Migration zu bewerten:

Aspekt Fluid + PDF-Bibliothek IronPDF
Abhängigkeiten 2+ Pakete (Fluid + PDF-Bibliothek) Einzelnes Paket
Vorlagen erstellen Flüssige Syntax ({{ }}) C# String-Interpolation oder Razor
PDF-Erstellung Externe Bibliothek erforderlich Eingebaute Chromium-Engine
CSS-Unterstützung Abhängig von der PDF-Bibliothek Vollständiges CSS3 mit Flexbox/Grid
JavaScript Abhängig von der PDF-Bibliothek Volle JavaScript-Unterstützung
Thread-Sicherheit TemplateContext nicht thread-sicher ChromePdfRenderer ist thread-sicher
Lernkurve Liquid + PDF-Bibliothek API HTML/CSS (Web-Standards)
Fehlerbehandlung Zwei Fehlerquellen Einzelne Fehlerquelle

Schnellstart: Migration von Fluid zu IronPDF

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Ersetzen von NuGet-Paketen

Entfernen Sie Fluid und alle externen PDF-Bibliotheken:

# Remove Fluid and external PDF library
dotnet remove package Fluid.Core
dotnet remove package WkHtmlToPdf-DotNet  # or whatever PDF library you used
dotnet remove package PuppeteerSharp       # if used
# Remove Fluid and external PDF library
dotnet remove package Fluid.Core
dotnet remove package WkHtmlToPdf-DotNet  # or whatever PDF library you used
dotnet remove package PuppeteerSharp       # if used
SHELL

IronPDF installieren:

# InstallIronPDF(all-in-one solution)
dotnet add package IronPdf
# InstallIronPDF(all-in-one solution)
dotnet add package IronPdf
SHELL

Schritt 2: Namespaces aktualisieren

Ersetzen Sie Fluid-Namensräume durch IronPdf:

// Before (Fluid + external PDF library)
using Fluid;
using Fluid.Values;
using SomeExternalPdfLibrary;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
// Before (Fluid + external PDF library)
using Fluid;
using Fluid.Values;
using SomeExternalPdfLibrary;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
$vbLabelText   $csharpLabel

Schritt 3: Lizenz initialisieren

Hinzufügen der Lizenzinitialisierung beim Start der Anwendung:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
$vbLabelText   $csharpLabel

Beispiele für die Code-Migration

Einfaches HTML zu PDF

Der grundlegendste Vorgang offenbart den Hauptunterschied zwischen diesen Ansätzen.

Flüssiger Ansatz:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse("<html><body><h1>Hello {{name}}!</h1></body></html>");
        var context = new TemplateContext();
        context.SetValue("name", "World");
        var html = await template.RenderAsync(context);

        // Fluid only generates HTML - you'd need another library to convert to PDF
        File.WriteAllText("output.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse("<html><body><h1>Hello {{name}}!</h1></body></html>");
        var context = new TemplateContext();
        context.SetValue("name", "World");
        var html = await template.RenderAsync(context);

        // Fluid only generates HTML - you'd need another library to convert to PDF
        File.WriteAllText("output.html", html);
    }
}
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World!</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World!</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
$vbLabelText   $csharpLabel

Fluid erfordert das Erstellen eines FluidParser, das Parsen des Template-Strings, das Erstellen eines TemplateContext, das Aufrufen von SetValue() für jede Variable, das asynchrone Rendering, um HTML zu erhalten, und das anschließende Schreiben in eine Datei, die immer noch kein PDF ist. Der Kommentar im Code besagt ausdrücklich: "Fluid erzeugt nur HTML - für die Konvertierung in PDF benötigen Sie eine andere Bibliothek."

IronPDF macht Schluss mit dieser Komplexität: Erstellen Sie einen Renderer, rufen Sie RenderHtmlAsPdf() auf und speichern Sie direkt im PDF-Format. Keine HTML-Zwischendateien, keine zusätzlichen Bibliotheken.

Für fortgeschrittene HTML-zu-PDF-Szenarien siehe den HTML-zu-PDF-Konvertierungsleitfaden.

Rechnungsvorlage mit dynamischen Daten

Dokumentvorlagen mit mehreren Variablen zeigen die Unterschiede in den Templates deutlich auf.

Flüssiger Ansatz:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>Invoice #{{invoiceNumber}}</h1>
                <p>Date: {{date}}</p>
                <p>Customer: {{customer}}</p>
                <p>Total: ${{total}}</p>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("invoiceNumber", "12345");
        context.SetValue("date", DateTime.Now.ToShortDateString());
        context.SetValue("customer", "John Doe");
        context.SetValue("total", 599.99);

        var html = await template.RenderAsync(context);
        // Fluid outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>Invoice #{{invoiceNumber}}</h1>
                <p>Date: {{date}}</p>
                <p>Customer: {{customer}}</p>
                <p>Total: ${{total}}</p>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("invoiceNumber", "12345");
        context.SetValue("date", DateTime.Now.ToShortDateString());
        context.SetValue("customer", "John Doe");
        context.SetValue("total", 599.99);

        var html = await template.RenderAsync(context);
        // Fluid outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html);
    }
}
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var invoiceNumber = "12345";
        var date = DateTime.Now.ToShortDateString();
        var customer = "John Doe";
        var total = 599.99;

        var html = $@"
            <html><body>
                <h1>Invoice #{invoiceNumber}</h1>
                <p>Date: {date}</p>
                <p>Customer: {customer}</p>
                <p>Total: ${total}</p>
            </body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var invoiceNumber = "12345";
        var date = DateTime.Now.ToShortDateString();
        var customer = "John Doe";
        var total = 599.99;

        var html = $@"
            <html><body>
                <h1>Invoice #{invoiceNumber}</h1>
                <p>Date: {date}</p>
                <p>Customer: {customer}</p>
                <p>Total: ${total}</p>
            </body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
$vbLabelText   $csharpLabel

Fluid verwendet die {{Variable}}-Syntax von Liquid mit context.SetValue() für jede Variable. Im Kommentar wird ausdrücklich darauf hingewiesen, dass "Fluid HTML ausgibt - zusätzliche PDF-Bibliothek erforderlich"IronPDFverwendet die standardmäßige C#-Stringinterpolation ($"{Variable}") - eine Syntax, die Entwickler bereits kennen - und gibt sie direkt als PDF aus.

In den IronPDF-Tutorials finden Sie weitere Muster für die Dokumentenerstellung.

Dynamische Daten mit Schleifen

Vorlagen mit Sammlungen und Schleifen demonstrieren die Unterschiede im Kontrollfluss.

Flüssiger Ansatz:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>{{title}}</h1>
                <ul>
                {% for item in items %}
                    <li>{{item}}</li>
                {% endfor %}
                </ul>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("title", "My List");
        context.SetValue("items", new[] { "Item 1", "Item 2", "Item 3" });

        var html = await template.RenderAsync(context);
        // Fluid generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>{{title}}</h1>
                <ul>
                {% for item in items %}
                    <li>{{item}}</li>
                {% endfor %}
                </ul>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("title", "My List");
        context.SetValue("items", new[] { "Item 1", "Item 2", "Item 3" });

        var html = await template.RenderAsync(context);
        // Fluid generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html);
    }
}
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var title = "My List";
        var items = new[] { "Item 1", "Item 2", "Item 3" };

        var html = $@"
            <html><body>
                <h1>{title}</h1>
                <ul>";

        foreach (var item in items)
        {
            html += $"<li>{item}</li>";
        }

        html += "</ul></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("template-output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var title = "My List";
        var items = new[] { "Item 1", "Item 2", "Item 3" };

        var html = $@"
            <html><body>
                <h1>{title}</h1>
                <ul>";

        foreach (var item in items)
        {
            html += $"<li>{item}</li>";
        }

        html += "</ul></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("template-output.pdf");
    }
}
$vbLabelText   $csharpLabel

Fluid verwendet die {% for item in items %}...{% endfor %}-Syntax von Liquid - eine Schablonensprache, die Entwickler erlernen müssen. Im Kommentar heißt es: "Fluid generiert nur HTML - separate PDF-Konvertierung erforderlich."IronPDFverwendet standardmäßige C# foreach-Schleifen - es muss keine neue Syntax erlernt werden - und gibt die Daten direkt im PDF-Format aus.

Fluid API zuIronPDFMapping Referenz

Dieses Mapping beschleunigt die Migration, indem es direkte API-Entsprechungen aufzeigt:

Kernklassen-Zuordnung

Fluid-Klasse IronPDF-Äquivalent Notizen
FluidParser Nicht anwendbar Nicht erforderlich - verwenden Sie C#-Strings
FluidTemplate Nicht anwendbar Nicht erforderlich
Vorlagenkontext C# Objekte/Strings Daten direkt weitergeben
VorlageOptionen RenderingOptions Konfiguration der PDF-Ausgabe
FluidValue Native C#-Typen Keine Konvertierung erforderlich
Externe PDF-Klasse ChromePdfRenderer Haupt-Rendering-Klasse

Methoden-Mapping

Flüssige Methode IronPDF-Äquivalent Notizen
new FluidParser() new ChromePdfRenderer() Stattdessen Renderer erstellen
parser.Parse(source) Nicht anwendbar Nicht erforderlich - HTML ist eine Zeichenkette
template.RenderAsync(context) renderer.RenderHtmlAsPdf(html) Direkte PDF-Wiedergabe
context.SetValue("Schlüssel", Wert) var Schlüssel = Wert; C#-Variablen verwenden

Flüssige Syntaxzu C# Mapping

Flüssige Syntax C# Äquivalent Notizen
{{ variable }} $"{Variable}" String-Interpolation
{% for item in items %} foreach (var item in items) C#-Schleife
{% if condition %} if (Bedingung) C# bedingt
{{ x \| upcase }} x.ToUpper() C#-Methode
{{ x \| datum: '%Y-%m-%d' }} x.ToString("jjjj-MM-tt") C#-Formatierung
{{ x \| anzahl_mit_Genauigkeit: 2 }} x.ToString("F2") C# Zahlenformatierung

Gängige Migrationsprobleme und Lösungen

Aufgabe 1: Flüssige Syntaxumwandlung

Fluid: Verwendet {{ Variable }} und {% control %} Syntax.

Lösung: Ersetzen Sie durch C# String-Interpolation und Kontrollfluss:

// Liquid: {{ name | upcase }}
// C#: $"{name.ToUpper()}"

// Liquid: {% for item in items %}{{item}}{% endfor %}
// C#: foreach (var item in items) { html += $"{item}"; }
// Liquid: {{ name | upcase }}
// C#: $"{name.ToUpper()}"

// Liquid: {% for item in items %}{{item}}{% endfor %}
// C#: foreach (var item in items) { html += $"{item}"; }
$vbLabelText   $csharpLabel

Ausgabe 2: TemplateContext-Variablen

Fluid: Verwendet context.SetValue("Schlüssel", Wert)um Daten zu übergeben.

Lösung: Verwenden Sie Standard-C#-Variablen:

// Before (Fluid)
var context = new TemplateContext();
context.SetValue("customer", customerName);

// After (IronPDF)
var customer = customerName;
var html = $"<p>Customer: {customer}</p>";
// Before (Fluid)
var context = new TemplateContext();
context.SetValue("customer", customerName);

// After (IronPDF)
var customer = customerName;
var html = $"<p>Customer: {customer}</p>";
$vbLabelText   $csharpLabel

Ausgabe 3: Thread-Sicherheit

Fluid: Vorlagenkontextist nicht thread-sicher und erfordert eine sorgfältige Verwaltung in nebenläufigen Anwendungen.

Lösung: ChromePdfRendererist thread-sicher und kann über Threads hinweg gemeinsam genutzt werden:

// Thread-safe usage
private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] GeneratePdf(string html)
{
    var pdf = _renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;
}
// Thread-safe usage
private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] GeneratePdf(string html)
{
    var pdf = _renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;
}
$vbLabelText   $csharpLabel

Ausgabe 4: Zweistufige Fehlerbehandlung

Fluid: Fehler können bei der Erstellung von Vorlagen ODER bei der PDF-Erzeugung auftreten.

Lösung:IronPDFhat eine einzige Fehlerquelle:

try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    // Single point of failure—easier debugging
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    // Single point of failure—easier debugging
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}
$vbLabelText   $csharpLabel

Checkliste für die flüssige Migration

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um alle Fluid-Verwendungen zu identifizieren:

# Find all Fluid references
grep -r "FluidParser\|FluidTemplate\|TemplateContext\|using Fluid" --include="*.cs" --include="*.csproj" .

# Find Liquid template files
find . -name "*.liquid" -o -name "*.html" | xargs grep -l "{{"
# Find all Fluid references
grep -r "FluidParser\|FluidTemplate\|TemplateContext\|using Fluid" --include="*.cs" --include="*.csproj" .

# Find Liquid template files
find . -name "*.liquid" -o -name "*.html" | xargs grep -l "{{"
SHELL

Dokumentieren Sie alle Vorlagen: Dateispeicherorte, verwendete Variablen, Schleifen und Bedingungen sowie die Konfiguration der externen PDF-Bibliothek.

Aufgaben der Code-Aktualisierung

  1. Fluid.Core NuGet-Paket entfernen
  2. Externes PDF-Bibliothekspaket entfernen
  3. IronPdf NuGet-Paket installieren
  4. Aktualisierung der Namespace-Importe von Fluid nach IronPdf
  5. Konvertiere {{ Variable }} in $"{Variable}"
  6. Konvertieren Sie {% for item in collection %} in C# foreach
  7. Konvertieren Sie {% if condition %}in C# if-Anweisungen
  8. Konvertieren Sie Liquid-Filter in C#-Methoden (z. B. | upcase→.ToUpper())
  9. Ersetzen Sie FluidParsermit ChromePdfRenderer
  10. Ersetzen Sie TemplateContext.SetValue() durch direkte C#-Variablen
  11. Externe PDF-Bibliotheksaufrufe entfernen
  12. IronPDF-Lizenzinitialisierung beim Start hinzufügen

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

  • Überprüfen der PDF-Ausgabe auf Übereinstimmung mit den Erwartungen
  • Testen Sie die korrekte Wiedergabe aller Vorlagenvarianten
  • Prüfen Sie die korrekte Darstellung von Bildern und Stilen
  • Validierung der korrekten Seitenumbrüche
  • Test mit verschiedenen Datengrößen
  • Leistungstests vs. Fluid + externe Bibliothek
  • Testen der Thread-Sicherheit in gleichzeitigen Szenarien

Bereinigungsaufgaben

  • Löschen der .liquid-Vorlagendateien (falls nicht mehr benötigt)
  • Fluid-bezogenen Hilfscode entfernen
  • Dokumentation aktualisieren
  • Bereinigen Sie ungenutzte Abhängigkeiten

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von Fluid (Templating) mit externen PDF-Bibliotheken zuIronPDFbietet mehrere entscheidende Vorteile:

Lösung mit einem einzigen Paket: Beseitigung der Abhängigkeit von zwei Bibliotheken.IronPDFbeherrscht sowohl das Templating (über HTML/CSS) als auch die PDF-Generierung in einem Paket.

Keine neue Syntax zu lernen: Verwenden Sie die standardmäßige C#-Stringinterpolation und den Kontrollfluss, anstatt die Liquid-Templating-Syntax zu erlernen.

Threadsicheres Rendering: ChromePdfRendererist im Gegensatz zu Vorlagenkontextthreadsicher, was die gleichzeitige PDF-Generierung vereinfacht.

Chromium Rendering Engine: Branchenübliches Rendering gewährleistet volle CSS3-Unterstützung einschließlich Flexbox und Grid sowie die vollständige Ausführung von JavaScript.

Eine einzige Fehlerquelle: Die Fehlersuche wird einfacher, da nur eine Bibliothek zur Fehlerbehebung benötigt wird, anstatt die Phasen der Vorlagenerstellung und der PDF-Generierung zu koordinieren.

Aktive Weiterentwicklung: Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleisten die regelmäßigen Updates vonIronPDFdie Kompatibilität mit aktuellen und zukünftigen .NET-Versionen.

Curtis Chau
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 ...

Weiterlesen

Verwandte Artikel

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