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

.NET Core Polly (Wie es für Entwickler funktioniert)

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

Polly ist eine .NET-Bibliothek für Resilienzstrategien und transientes Fehlerhandling, die es Entwicklern ermöglicht, Resilienzrichtlinien wie Retry, Circuit Breakers, Timeout, Bulkhead Isolation und Fallback auszudrücken. Polly zielt auf ASP.NET Core ab und ist damit ein wesentliches Werkzeug für die Resilienz von .NET Core. Polly ist thread-sicher und unterstützt die Bearbeitung mehrerer gleichzeitiger Anfragen mit erfolgreichen Antworten.

Dieses Tutorial bietet weitere Details über die .NET-Bibliothek für transientes Fehlerhandling, Polly, und wie man sie mit IronPDF in einer ASP.NET Core-Anwendung verwendet. Wir werden tief in jeden Aspekt von Polly eintauchen, die Mechanismen des Circuit-Breaker-Musters erklären, Bulkhead-Isolation und Timeouts diskutieren und zeigen, wie man spezifische Ausnahmen oder fehlerhafte Dienste mit Fehlerantworten in kontrollierter, thread-sicherer Weise behandelt.

Polly-Richtlinien

Transiente Fehler treten häufig auf, wenn Ihre Anwendung versucht, über eine HTTP-Anfrage eine Verbindung zu einem Webdienst herzustellen, oder mit einer Datenbank oder anderen externen Ressourcen. Diese Fehler, wie Netzwerkfehler, temporäre Verbindungsprobleme oder Timeouts, sind kurzzeitig und beheben sich in der Regel nach kurzer Zeit von selbst.

Polly verwaltet diese transienten Fehler, indem es verschiedene Strategien anwendet und Richtlinien wie Retry Policy, erweiterte Circuit Breaker Policy, Timeout Policy, Fallback Policy und Bulkhead Isolation Policy ausdrückt.

Rettungspolitik

Die Retry Policy wiederholt fehlgeschlagene gleichzeitige Anfragen automatisch mit einer Wiederholungslogik. Es kann so konfiguriert werden, dass es ewig versucht oder automatisch eine bestimmte Anzahl von Wiederholungen macht ...

Schaltkreisunterbrecher

Die Circuit Breaker Policy ermöglicht es Ihrem System, ein Abbruch-Token zu unterstützen, um nach einer vorab konfigurierten Schwelle gescheiterter Anfragen einen bestimmten Dienst erneut zu versuchen. Die Circuit Breaker-Strategie ist vergleichbar mit Chaos Engineering oder einem Schiff, das wasserdichte Türen schließt, um den Schaden zu lokalisieren: Ein Fehler versenkt nicht das gesamte Schiff.

Timeout-Richtlinie

Die Timeout Policy erzwingt eine maximale Zeit, die ein bestimmter Abschnitt von .NET-Resilienzkode ausführen darf. Es kommt in zwei Varianten: optimistisches Timeout und pessimistisches Timeout.

Rückrufpolitik

Die Fallback-Policy wird verwendet, um im Falle eines Fehlers einen Ersatzwert oder ein Ersatzverhalten bereitzustellen. Diese Richtlinie kann nützlich sein, wenn ein scheiternder Dienst den gesamten Prozess nicht stoppen sollte.

Bulkhead-Isolierung

Bulkhead Isolation wird verwendet, um die Anzahl gleichzeitiger Anfragen an einen bestimmten Vorgang zu begrenzen, wodurch das Potenzial für Socket-Auspuffung begrenzt und eine kontrollierte Anzahl von Ausführungsplätzen aufrechterhalten wird.

Cache-Richtlinie

Die Cache Policy speichert die erfolgreiche Antwort einer Ausführung, sodass Polly den verteilten Cache-Wert zurückgeben kann, wenn dieselbe Ausführung erneut aufgerufen wird.

Richtlinienübersicht

Ermöglicht uns, mehrere Richtlinien zusammenzubinden, sodass sie als eine einzige Einheit arbeiten.

Richtlinien erstellen und konfigurieren

Rettungspolitik

Eine Retry-Policy ist einfach: Wenn eine spezifische Ausnahme oder ein Fehler auftritt, versucht Polly, den zugrunde liegenden Delegaten erneut auszuführen. Sie können definieren, wie oft erneut versucht werden soll, das Zeitintervall zwischen den Wiederholungen oder eine exponentielle Back-off-Strategie verwenden, andernfalls versucht es ewig erneut. Hier ist ein Beispiel:

// Retry policy for handling HttpRequestException with exponential back-off
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
    (exception, timeSpan, retryCount, context) =>
    {
        // This is the OnRetry delegate, where you can log or monitor failed requests
        Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}");
    });
// Retry policy for handling HttpRequestException with exponential back-off
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
    (exception, timeSpan, retryCount, context) =>
    {
        // This is the OnRetry delegate, where you can log or monitor failed requests
        Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}");
    });
$vbLabelText   $csharpLabel

Schaltkreisunterbrecher-Richtlinie

Die Circuit Breaker Policy lässt die Polly-Bibliothek nach Fehlern überwachen, und wenn die Anzahl der Fehler einen konfigurierten Schwellenwert in einem bestimmten Zeitraum überschreitet, wird der Stromkreis "unterbrochen" und weitere Anfragen werden für einen bestimmten Zeitraum blockiert. Dies wird als "offener" Zustand bezeichnet. Nach dieser Zeit geht der Stromkreis in einen "halb-offenen" Zustand über, in dem er etwas Verkehr zulässt, um die Gesundheit des bestimmten Dienstes zu überprüfen. Wenn diese Anfragen erfolgreich sind und keine Fehler auftreten, schließt sich der Stromkreis; ansonsten öffnet er sich wieder.

// Circuit breaker policy to handle failing requests with open and half-open states
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));
// Circuit breaker policy to handle failing requests with open and half-open states
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));
$vbLabelText   $csharpLabel

Timeout-Richtlinie

Timeout-Policies behandeln Szenarien, in denen ein Dienst nicht innerhalb eines angemessenen Zeitrahmens antwortet. Polly bietet zwei Arten von Timeouts: optimistisch und pessimistisch. Ein optimistisches Timeout arbeitet auf einem separaten Thread und bricht die zugrunde liegende Operation über ein CancellationToken ab. Ein pessimistisches Timeout blockiert den übergeordneten Thread, bis die Operation abgeschlossen ist oder die Timeout-Periode abgelaufen ist.

// Timeout policy with a 30-second optimistic timeout
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 seconds
// Timeout policy with a 30-second optimistic timeout
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 seconds
$vbLabelText   $csharpLabel

Bulkhead-Isolierung

Bulkhead Isolation wird verwendet, um die Anzahl gleichzeitiger Aktionen gegen einen bestimmten Dienst zu begrenzen. Es bietet eine Möglichkeit, Fehler zu isolieren und zu verhindern, dass sie sich fortpflanzen. Es begrenzt auch die Last, die wir auf unsere Abhängigkeiten legen.

// Bulkhead isolation policy to limit concurrency and queue length
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, 20 queue slots
// Bulkhead isolation policy to limit concurrency and queue length
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, 20 queue slots
$vbLabelText   $csharpLabel

Rückrufpolitik

Fallback-Policies sind nützlich, wenn Sie ein Standardverhalten oder einen Ersatzwert bereitstellen müssen, wenn alle anderen Maßnahmen versagen.

// Fallback policy to provide a default result on failure
var fallbackPolicy = Policy
    .Handle<Exception>()
    .FallbackAsync<FallbackResult>(
        FallbackResult.SomethingWentWrong, 
        (exception, context) => 
        {
            Console.WriteLine($"Fallback triggered due to: {exception.Message}");
            return Task.CompletedTask;
        });
// Fallback policy to provide a default result on failure
var fallbackPolicy = Policy
    .Handle<Exception>()
    .FallbackAsync<FallbackResult>(
        FallbackResult.SomethingWentWrong, 
        (exception, context) => 
        {
            Console.WriteLine($"Fallback triggered due to: {exception.Message}");
            return Task.CompletedTask;
        });
$vbLabelText   $csharpLabel

Verpacken der Richtlinien

Mehrere Richtlinien können flexibel mithilfe eines PolicyWrap kombiniert werden:

// Combining multiple policies using PolicyWrap
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);
// Combining multiple policies using PolicyWrap
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);
$vbLabelText   $csharpLabel

Einstieg

Um Polly mit IronPDF zu verwenden, stellen Sie sicher, dass Sie Visual Studio installiert haben und erstellen Sie ein neues Konsolenanwendungsprojekt in .NET Core. Öffnen Sie die NuGet-Paket-Manager-Konsole in Visual Studio und installieren Sie die Pakete Polly und IronPDF:

Install-Package Polly
Install-Package IronPdf

Verwendung von Polly mit IronPDF Konvertierung einer URL in PDF

Ein herausragendes Merkmal von IronPDF ist seine HTML-zu-PDF-Fähigkeit, die sicherstellt, dass Layouts und Stile intakt bleiben. Diese Funktion verwandelt Webinhalte in PDFs, was sich perfekt für Berichte, Rechnungen und Dokumentationen eignet. Es unterstützt die Konvertierung von HTML-Dateien, URLs und HTML-Zeichenfolgen in PDFs.

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");
    }
}
$vbLabelText   $csharpLabel

Lassen Sie uns ein Beispiel für die Verwendung von Polly mit IronPDF zum Konvertieren einer URL in PDF durchgehen. Angenommen, wir haben einen Webdienst, der gelegentlich aufgrund transienter Fehler ausfällt, und wir möchten diese Fehler mit Polly elegant handhaben.

Lassen Sie uns zunächst die notwendigen Namespaces in unserer Program.cs-Datei importieren:

using System;
using System.Threading.Tasks;
using Polly;
using Polly.Wrap;
using IronPdf;
using System;
using System.Threading.Tasks;
using Polly;
using Polly.Wrap;
using IronPdf;
$vbLabelText   $csharpLabel

Als Nächstes definieren wir unsere Richtlinien. In diesem Beispiel verwenden wir eine Kombination aus Retry- und Circuit-Breaker-Richtlinien, um Fehler zu handhaben:

// Retry policy with exponential backoff
var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));

// Circuit breaker policy to block requests after consecutive failures
var circuitBreakerPolicy = Policy
    .Handle<Exception>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));
// Retry policy with exponential backoff
var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));

// Circuit breaker policy to block requests after consecutive failures
var circuitBreakerPolicy = Policy
    .Handle<Exception>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));
$vbLabelText   $csharpLabel

Die retryPolicy wird die fehlgeschlagene Anfrage bis zu dreimal mit einer exponentiellen Back-off-Strategie erneut versuchen, wobei 2 Sekunden, 4 Sekunden und 8 Sekunden zwischen den Wiederholungen gewartet werden. Die circuitBreakerPolicy öffnet den Stromkreis, wenn zwei aufeinanderfolgende Fehler innerhalb eines 30-Sekunden-Zeitintervalls auftreten.

Nun definieren wir unseren IronPDF-Code, um eine URL in ein PDF zu konvertieren:

var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
    .WrapAsync(circuitBreakerPolicy)
    .ExecuteAsync(async () =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
        var result = await htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
        Console.WriteLine("Conversion successful!");
        return result;
    });

pdfBytes.SaveAs("output.pdf");
var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
    .WrapAsync(circuitBreakerPolicy)
    .ExecuteAsync(async () =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
        var result = await htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
        Console.WriteLine("Conversion successful!");
        return result;
    });

pdfBytes.SaveAs("output.pdf");
$vbLabelText   $csharpLabel

Im obigen Beispielcode umschließen wir unsere retryPolicy und circuitBreakerPolicy mithilfe der WrapAsync-Methode. Dies ermöglicht es uns, mehrere Richtlinien nacheinander auf neue Anfragen anzuwenden. Die ExecuteAsync-Methode führt den bereitgestellten Delegaten aus, der in diesem Code die RenderUrlAsPdfAsync-Methode von IronPDF ist.

Durch die Anwendung von Polly-Richtlinien stellen wir sicher, dass unser Code gegen transiente Fehler widerstandsfähig ist. Wenn eine Anfrage fehlschlägt, wird Polly sie automatisch gemäß der Retry-Policy erneut versuchen. Wenn die Anzahl der aufeinanderfolgenden Fehler die vorab konfigurierte Schwelle überschreitet, öffnet die Circuit-Breaker-Policy den Stromkreis und verhindert weitere Anfragen für eine bestimmte Dauer.

Testfälle für Polly Policies

Um die Effektivität unserer Polly-Richtlinien zu testen, simulieren wir einige fehlgeschlagene Anfragen. Ändern Sie die URL zu einem nicht existierenden Endpunkt und fügen Sie einige Testfälle hinzu:

var testUrls = new[]
{
    "https://ironpdf.com",
    "https://notexistingdomain.com/",
    "http://httpbin.org/delay/120"
};

foreach (var url in testUrls)
{
    try
    {
        var pdfBytes = await retryPolicy
            .WrapAsync(circuitBreakerPolicy)
            .ExecuteAsync(() => htmlToPdf.RenderUrlAsPdfAsync(url));

        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf");
        Console.WriteLine($"Successfully converted {url} to PDF.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}");
    }
}
var testUrls = new[]
{
    "https://ironpdf.com",
    "https://notexistingdomain.com/",
    "http://httpbin.org/delay/120"
};

foreach (var url in testUrls)
{
    try
    {
        var pdfBytes = await retryPolicy
            .WrapAsync(circuitBreakerPolicy)
            .ExecuteAsync(() => htmlToPdf.RenderUrlAsPdfAsync(url));

        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf");
        Console.WriteLine($"Successfully converted {url} to PDF.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}");
    }
}
$vbLabelText   $csharpLabel

Im obigen Code iterieren wir über eine Reihe von Test-URLs und versuchen, jede von ihnen in PDF zu konvertieren. Wenn eine Anfrage fehlschlägt, wird die Ausnahme abgefangen und eine entsprechende Nachricht in der Konsole angezeigt.

.NET Core Polly (Wie es für Entwickler funktioniert): Abbildung 1 - URL zu PDF Ausgabe

Abschluss

Polly ist eine leistungsstarke und flexible Bibliothek für die Implementierung von Resilienz und transientem Fehlerhandling in .NET Core-Anwendungen. Durch das Kombinieren von Richtlinien wie Retry und Circuit Breaker können Entwickler robuste und fehlertolerante Systeme bauen, die Fehler elegant handhaben.

In diesem Tutorial haben wir gelernt, wie man Polly mit IronPDF verwendet, um eine URL in PDF zu konvertieren. Wir haben gelernt, wie man Polly-Richtlinien definiert und anwendet, einschließlich Retry und Circuit Breaker. Wir haben auch unsere Richtlinien mit verschiedenen URLs getestet. Wir können es auch für die Konvertierung von HTML zu PDF tun.

IronPDF bietet eine kostenlose Testversion, und Lizenzen beginnen zu wettbewerbsfähigen Preisen, sodass Sie seine Fähigkeiten in Ihren Projekten nutzen können.

Häufig gestellte Fragen

Was ist Polly und wie verbessert es die Resilienz von .NET Core?

Polly ist eine .NET-Bibliothek, die für Resilienz und die Handhabung von temporären Fehlern entwickelt wurde, insbesondere für ASP.NET Core-Anwendungen. Sie verbessert die Resilienz, indem sie Strategien wie Wiederholung, Schutzschalter, Timeout, Schott-Isolation und Fallback bietet, um robuste und fehlertolerante Systeme zu gewährleisten.

Wie kann ich Polly verwenden, um eine Wiederholungsrichtlinie in .NET Core umzusetzen?

In .NET Core können Sie Polly verwenden, um eine Wiederholungsrichtlinie zu implementieren, indem Sie es konfigurieren, fehlgeschlagene Anfragen automatisch zu wiederholen. Dies kann durch Festlegen der Anzahl der Wiederholungen und des Zeitintervalls zwischen den Versuchen geschehen, was ein effektives Management von temporären Fehlern ermöglicht.

Wie verhindert die Schutzschalter-Richtlinie Kaskadenfehler in .NET-Anwendungen?

Die Schutzschalter-Richtlinie in Polly verhindert Kaskadenfehler, indem sie Fehler überwacht und den Stromkreis öffnet, um Anfragen zu blockieren, wenn ein Fehlerschwellenwert erreicht wird. Dadurch werden weitere Anfragen gestoppt, bis der Stromkreis zurückgesetzt wird, sodass sich das System erholen kann, bevor es neue Anfragen annimmt.

Welche Rolle spielt die Schott-Isolation bei der Verwaltung von Ressourcenauslastung?

Die Schott-Isolation in Polly begrenzt die Anzahl gleichzeitiger Anfragen an einen Dienst und verhindert Ressourcenauslastung, indem sie Ausführungsslots kontrolliert. Diese Richtlinie hilft, Fehler einzudämmen und sorgt für ein effizientes Ressourcenmanagement innerhalb einer .NET Core-Anwendung.

Wie kann die Timeout-Richtlinie von Polly die Reaktionsfähigkeit meiner Anwendung verbessern?

Die Timeout-Richtlinie von Polly erzwingt eine maximale Ausführungszeit für Operationen, was bei der Bewältigung von Szenarien hilft, in denen Dienste nicht sofort reagieren. Durch Festlegung von optimistischen oder pessimistischen Zeitlimits können Entwickler sicherstellen, dass ihre Anwendungen reaktionsfähig bleiben.

Kann Polly verwendet werden, um die Zuverlässigkeit der URL-zu-PDF-Konvertierung zu verbessern?

Ja, Polly kann die Zuverlässigkeit der URL-zu-PDF-Konvertierung verbessern, indem es seine Wiederholungs- und Schutzschalter-Richtlinien mit PDF-Generierungswerkzeugen integriert. Dies stellt sicher, dass Konversionsprozesse gegenüber temporären Fehlern widerstandsfähig sind und die Zuverlässigkeit erhalten bleibt.

Wie stellt eine Fallback-Richtlinie in Polly einen anmutigen Dienstabbau sicher?

Eine Fallback-Richtlinie in Polly bietet alternative Antworten oder Verhaltensweisen, wenn ein Dienst ausfällt. Dies hilft sicherzustellen, dass ein Fehler nicht die gesamte Anwendung anhält, sondern einen anmutigen Abbau und fortlaufenden Betrieb ermöglicht.

Wie kombiniert man mehrere Polly-Richtlinien in einer .NET-Anwendung?

In einer .NET-Anwendung können mehrere Polly-Richtlinien mit Policy Wraps kombiniert werden. Dadurch können Entwickler verschiedene Resilienzstrategien zusammen ausführen und eine umfassendere und flexiblere Fehlermanagementstrategie ermöglichen.

Wie kann die Integration von Polly mit IronPDF temporäre Fehler in der PDF-Generierung behandeln?

Durch die Integration von Polly mit IronPDF können Entwickler temporäre Fehler während der PDF-Generierung durch Richtlinien wie Wiederholung und Schutzschalter behandeln. Diese Integration sorgt für eine stabile und zuverlässige PDF-Generierung trotz gelegentlicher Dienstunterbrechungen.

Was sind einige häufige Strategien zur Fehlerbehebung bei der Verwendung von Polly mit .NET Core?

Häufige Strategien zur Fehlerbehebung umfassen die Überprüfung der Richtlinienkonfigurationen, wie Wiederholungsintervalle und Schutzschalterschwellen, und das Testen der Richtlinien mit unterschiedlichen Szenarien, um einen ordnungsgemäßen Umgang mit Fehlern und Systemresilienz sicherzustellen.

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