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

Polly Retry (Funktionsweise für Entwickler)

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

Der Umgang mit vorübergehenden Fehlern, Zeitüberschreitungen und Ausnahmen auf elegante Weise ist entscheidend für den Aufbau robuster und widerstandsfähiger Anwendungen. Polly ist eine beliebte .NET-Bibliothek, die Resilienz- und transienten Fehlerbehandlungsmöglichkeiten bietet. Unter den vielen Funktionen ist "retry" eine der am häufigsten verwendeten Richtlinien.

In diesem Artikel werden wir uns mit Pollys Retrierrichtlinie in C# befassen, ihre Verwendung und Konfigurationsoptionen erkunden und praktische Codebeispiele bereitstellen. Außerdem verwenden wir die IronPDF Library für die PDF-Erstellung mit dem Polly Retry-Versuch, um ein PDF der Formularanfrageergebnisse zu erstellen.

Was ist Polly Retry?

Polly Retry ist eine von der Polly-Bibliothek bereitgestellte Richtlinie, die es Entwicklern ermöglicht, Operationen, die aufgrund eines Fehlers oder vorübergehender Fehler fehlschlagen könnten, automatisch erneut durchzuführen. Vorübergehende Fehler sind temporäre Fehler, die aufgrund von Netzwerkstörungen, Nichtverfügbarkeit von Diensten oder anderen vorübergehenden Problemen auftreten.

Mit Pollys Retrierrichtlinie können Sie Regeln für das erneute Durchführen von Operationen definieren, einschließlich der maximalen Anzahl von Wiederholungen, der Verzögerung zwischen mehreren Wiederholungen und den Bedingungen für das erneute Durchführen einer fehlgeschlagenen Anfrage. Dies hilft beim Aufbau widerstandsfähiger Anwendungen, die sich von vorübergehenden Fehlern erholen können, ohne abzustürzen oder Unterbrechungen für Endbenutzer zu verursachen.

Einstieg mit Polly Retry

Bevor wir in Codebeispiele eintauchen, verschaffen wir uns ein grundlegendes Verständnis dafür, wie Polly in einem C#-Projekt installiert und konfiguriert wird.

Installation von Polly

Sie können Polly über die NuGet-Package-Manager-Konsole mit dem folgenden Befehl installieren:

Install-Package Polly

Oder über die .NET CLI:

dotnet add package Polly

Hinzufügen von Polly using statements

Fügen Sie in Ihrer C#-Datei den Polly-Namespace ein:

using Polly;
using Polly;
$vbLabelText   $csharpLabel

Basic Retry Policy Beispiel

Beginnen wir mit einem einfachen Beispiel, bei dem wir eine Operation erneut durchführen, die das Abrufen von Daten von einem Remote-Dienst simuliert. Wir werden eine Retrierichtlinie mit maximal 3 Wiederholungen und einer festen Zeitverzögerung von 2 Sekunden zwischen den Wiederholungen einrichten.

using System;
using System.Net.Http;
using Polly;

namespace PollyRetryExample
{
    public class Program
    {
        public static void Main(string[] args)
        {
            // Define a retry policy that handles HttpRequestException with a maximum of 3 retries
            var retryPolicy = Policy
                .Handle<HttpRequestException>() // Specify the exception type to handle
                .WaitAndRetry(
                    3, // Max retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2), // Fixed retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry {0} due to {1}", retryCount, exception.Message);
                    });

            try
            {
                // Execute the action within the context of the retry policy
                retryPolicy.Execute(() =>
                {
                    FetchDataFromRemoteService();
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed after 3 retries: {0}", ex.Message);
            }
        }

        // Simulate fetching data that throws HttpRequestException
        public static void FetchDataFromRemoteService()
        {
            throw new HttpRequestException("Failed to fetch data from remote service");
        }
    }
}
using System;
using System.Net.Http;
using Polly;

namespace PollyRetryExample
{
    public class Program
    {
        public static void Main(string[] args)
        {
            // Define a retry policy that handles HttpRequestException with a maximum of 3 retries
            var retryPolicy = Policy
                .Handle<HttpRequestException>() // Specify the exception type to handle
                .WaitAndRetry(
                    3, // Max retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2), // Fixed retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry {0} due to {1}", retryCount, exception.Message);
                    });

            try
            {
                // Execute the action within the context of the retry policy
                retryPolicy.Execute(() =>
                {
                    FetchDataFromRemoteService();
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed after 3 retries: {0}", ex.Message);
            }
        }

        // Simulate fetching data that throws HttpRequestException
        public static void FetchDataFromRemoteService()
        {
            throw new HttpRequestException("Failed to fetch data from remote service");
        }
    }
}
$vbLabelText   $csharpLabel

In diesem Beispiel:

  • Handle<HttpRequestException>() gibt an, dass wir HttpRequestException behandeln und die Operation wiederholen möchten, wenn sie auftritt.
  • WaitAndRetry() konfiguriert die Retrierichtlinie mit 3 Wiederholungen und einer festen Verzögerung von 2 Sekunden zwischen den Wiederholungen (angegebene maximale Dauer).
  • onRetry-Delegat protokolliert eine Nachricht, wenn eine Wiederholung auftritt.

Polly Retry (How It Works For Developers): Abbildung 1

Erweiterte Konfiguration der Wiederholungsrichtlinie

Exponentialer Backoff

Exponentielles Backoff ist eine beliebte Retriermethode, bei der sich die Verzögerung zwischen Anfragen und Wiederholungen exponentiell erhöht. Polly bietet eine bequeme Möglichkeit, exponentielles Backoff mit WaitAndRetry() umzusetzen.

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), // Exponential delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), // Exponential delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });
$vbLabelText   $csharpLabel

Polly Retry (How It Works For Developers): Abbildung 2

Rhetorik mit Circuit Breaker

Das Kombinieren von Retrierichtlinie mit einem Circuit Breaker verbessert die Resilienz, indem wiederholte Versuche bei Dienstfehlern verhindert werden. Polly ermöglicht es Ihnen, Retrierichtlinien und Circuit Breaker-Richtlinien einfach zu kombinieren.

// Define a circuit breaker policy
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3, // Number of exceptions before breaking
        durationOfBreak: TimeSpan.FromSeconds(30), // Time circuit stays open
        onBreak: (ex, breakDelay) =>
        {
            Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuit reset.");
        });

// Define a retry policy
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(2), // Fixed retry delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

// Combine both policies into a single policy wrap
var policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy);
// Define a circuit breaker policy
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3, // Number of exceptions before breaking
        durationOfBreak: TimeSpan.FromSeconds(30), // Time circuit stays open
        onBreak: (ex, breakDelay) =>
        {
            Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuit reset.");
        });

// Define a retry policy
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(2), // Fixed retry delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

// Combine both policies into a single policy wrap
var policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy);
$vbLabelText   $csharpLabel

In diesem Beispiel:

  • CircuitBreaker() definiert eine Circuit Breaker-Richtlinie, die nach 3 Ausnahmen abbricht und 30 Sekunden lang geöffnet bleibt.
  • Policy.Wrap() kombiniert die Circuit Breaker- und Retrierichtlinien in eine einzige Richtlinie.

Polly Retry (How It Works For Developers): Abbildung 3

Einführung in IronPDF

IronPDF C# PDF Library Übersicht ist eine leistungsstarke C#-Bibliothek, die Entwicklern ermöglicht, PDF-Dokumente innerhalb ihrer .NET-Anwendungen zu erstellen, zu bearbeiten und zu manipulieren. Ob Sie Rechnungen, Berichte oder andere Arten von PDF-Dokumenten erstellen müssen, IronPDF bietet eine intuitive API, die den Prozess vereinfacht.

Mit IronPDF können Sie einfach HTML, CSS und sogar ASP.NET-Webseiten in PDFs umwandeln und so ein vielseitiges Werkzeug für eine Vielzahl von Anwendungen nutzen. Darüber hinaus bietet es erweiterte Funktionen wie das Hinzufügen von Text, Bildern und interaktiven Elementen zu PDFs sowie deren Sicherung mit Verschlüsselung und digitalen Signaturen.

IronPDF ist hervorragend in der HTML-zu-PDF-Konvertierung und gewährleistet die präzise Erhaltung der ursprünglichen Layouts und Stile. Es ist perfekt zum Erstellen von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. IronPDF unterstützt die Konvertierung von HTML-Dateien, URLs und rohen HTML-Strings in hochwertige PDF-Dateien.

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

Polly Retry mit IronPDF

Bei der Arbeit mit IronPDF kann es Szenarien geben, in denen Sie Daten aus externen Quellen abrufen oder komplexe Operationen durchführen müssen, bevor Sie ein PDF erstellen.

In solchen Fällen können vorübergehende Fehler oder temporäre Probleme auftreten, die zu PDF-Erstellungsausfällen führen könnten. Um diese vorübergehenden Fehler elegant zu behandeln, können Sie Polly Retry in Verbindung mit IronPDF verwenden.

Installation von IronPDF und Polly

Bevor Sie beginnen, stellen Sie sicher, dass Sie das IronPDF NuGet-Paket in Ihr Projekt installieren.

Install-Package IronPdf

Verwendung von Polly Retry mit IronPDF

Lassen Sie uns ein Beispiel betrachten, in dem wir Polly Retry verwenden, um vorübergehende Fehler zu behandeln, wenn ein PDF mit IronPDF erstellt wird. Im folgenden Beispiel simulieren wir das Abrufen von Daten von einer externen API und dann die Erstellung eines PDFs basierend auf diesen Daten. Wir verwenden Polly Retry, um die Datenabrufoperation bei Fehlern auszuführen.

using System;
using System.Net.Http;
using System.Threading.Tasks;
using IronPdf;
using Polly;

namespace IronPdfWithPollyRetry
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            // Define a retry policy with async capability
            var retryPolicy = Policy
                .Handle<HttpRequestException>() // Specify exception type to handle
                .WaitAndRetryAsync(
                    3, // Retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2), // Calculated retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry " + retryCount + " due to " + exception.Message);
                    });

            // Execute the retry policy asynchronously
            var pdf = await retryPolicy.ExecuteAsync(async () =>
            {
                var data = await FetchDataFromExternalApiAsync(); // Fetch data from an external source
                return GeneratePdfFromData(data); // Generate PDF using fetched data
            });

            pdf.SaveAs("GeneratedDocument.pdf");
        }

        // Simulate fetching data from an external API
        static async Task<string> FetchDataFromExternalApiAsync()
        {
            await Task.Delay(100); // Simulate delay
            throw new HttpRequestException("Failed to fetch data from external API");
        }

        // Generate PDF using IronPDF based on the fetched data
        static PdfDocument GeneratePdfFromData(string data)
        {
            var htmlContent = "<html><body><h1>Data: " + data + "</h1></body></html>";
            var renderer = new ChromePdfRenderer();
            return renderer.RenderHtmlAsPdf(htmlContent);
        }
    }
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
using IronPdf;
using Polly;

namespace IronPdfWithPollyRetry
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            // Define a retry policy with async capability
            var retryPolicy = Policy
                .Handle<HttpRequestException>() // Specify exception type to handle
                .WaitAndRetryAsync(
                    3, // Retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2), // Calculated retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry " + retryCount + " due to " + exception.Message);
                    });

            // Execute the retry policy asynchronously
            var pdf = await retryPolicy.ExecuteAsync(async () =>
            {
                var data = await FetchDataFromExternalApiAsync(); // Fetch data from an external source
                return GeneratePdfFromData(data); // Generate PDF using fetched data
            });

            pdf.SaveAs("GeneratedDocument.pdf");
        }

        // Simulate fetching data from an external API
        static async Task<string> FetchDataFromExternalApiAsync()
        {
            await Task.Delay(100); // Simulate delay
            throw new HttpRequestException("Failed to fetch data from external API");
        }

        // Generate PDF using IronPDF based on the fetched data
        static PdfDocument GeneratePdfFromData(string data)
        {
            var htmlContent = "<html><body><h1>Data: " + data + "</h1></body></html>";
            var renderer = new ChromePdfRenderer();
            return renderer.RenderHtmlAsPdf(htmlContent);
        }
    }
}
$vbLabelText   $csharpLabel

Dieser C#-Code zeigt, wie die Polly-Bibliothek zur Implementierung von Retrierichtlinien mit IronPDF zur Erstellung eines PDF-Dokuments verwendet wird. Die Main-Methode initialisiert eine Retrierichtlinie unter Verwendung von Polly's WaitAndRetryAsync-Methode.

Diese Richtlinie gibt an, dass sie HttpRequestException behandeln und die Operation bis zu 3 Mal erneut durchführen soll, mit einem Verzögerungsraum von 2 Sekunden zwischen dem ersten Versuch und den Wiederholungen. Wenn ein Wiederholungsfehler auftritt, wird eine Nachricht in der Konsole ausgegeben, die die Anzahl der Wiederholungsversuche und die Ausnahmemeldung angibt.

Innerhalb der Main-Methode wird die Logik der Retrierichtlinie asynchron mit retryPolicy.ExecuteAsync() ausgeführt. Innerhalb dieser Ausführung werden zwei asynchrone Operationen miteinander verkettet: FetchDataFromExternalApiAsync() und GeneratePdfFromData(data).

Wenn FetchDataFromExternalApiAsync() fehlschlägt (da es absichtlich so eingerichtet ist, dass eine simulierte Ausnahme auftritt), fängt die Retrierichtlinie die HttpRequestException ab, protokolliert den Wiederholungsversuch und versucht die Operation erneut.

Die FetchDataFromExternalApiAsync()-Methode simuliert das Abrufen von Daten von einer externen API mit einer Verzögerung und löst absichtlich eine HttpRequestException aus, um fehlschlagende Anfragen zu simulieren.

Polly Retry (How It Works For Developers): Abbildung 4

Abschluss

Abschließend erweist sich Pollys Retrierrichtlinie als unschätzbar wertvoll für die Handhabung vorübergehender Fehler und zur Gewährleistung von Robustheit in C#-Anwendungen. Seine Flexibilität bei der Konfiguration von Wiederholungsversuchen, Verzögerungen und Bedingungen ermöglicht Entwicklern die Anpassung von Resilienzstrategien an bestimmte Anforderungen.

Ob eigenständig oder in Verbindung mit Bibliotheken wie IronPDF verwendet, erleichtert Polly die Erstellung von Anwendungen, die sich von vorübergehenden Fehlern erholen und so die Benutzererfahrung und Zuverlässigkeit der Software verbessern.

Durch die Integration von Pollys Retrierfähigkeiten können Entwickler widerstandsfähigere Systeme aufbauen, die sich anpassen und von vorübergehenden Problemen erholen können, wodurch letztendlich die allgemeine Qualität und Zuverlässigkeit ihrer Anwendungen verbessert wird.

IronPDF ist die beste C#-PDF-Bibliothek auf dem Markt, sie bietet auch eine Testlizenz für IronPDF, die Preise beginnen bei $799 USD.

Um mehr über die HTML-zu-PDF-Konvertierung mit IronPDF zu erfahren, besuchen Sie das folgende IronPDF-HTML-zu-PDF-Konvertierungstutorial.

Häufig gestellte Fragen

Was ist Polly Retry in C#?

Polly Retry ist ein Feature der Polly-Bibliothek in C#, das es Entwicklern ermöglicht, Operationen, die aufgrund vorübergehender Probleme wie Netzwerkstörungen oder Dienstunverfügbarkeit fehlschlagen, automatisch erneut zu versuchen. Dies hilft beim Aufbau widerstandsfähiger Anwendungen, indem vorübergehende Fehler elegant gehandhabt werden.

Wie kann ich eine grundlegende Retry-Richtlinie mit Polly implementieren?

Sie können eine grundlegende Retry-Richtlinie in Polly implementieren, indem Sie Ausnahmen wie HttpRequestException behandeln und sie so einstellen, dass sie maximal dreimal mit einer festen Verzögerung von zwei Sekunden zwischen jedem Versuch erneut versuchen.

Was ist die Bedeutung von Exponential Backoff in Polly?

Exponential Backoff in Polly wird verwendet, um die Verzögerung zwischen Wiederholungen exponentiell zu erhöhen, was hilft, die Last auf Diensten bei Ausfällen zu reduzieren. Dies kann mit der WaitAndRetry-Methode von Polly implementiert werden, die Verzögerungen basierend auf exponentiellem Wachstum berechnet.

Wie installiere ich Polly für ein C#-Projekt?

Sie können Polly in einem C#-Projekt mit der NuGet Package Manager Console über den Befehl Install-Package Polly oder über die .NET CLI mit dotnet add package Polly installieren.

Kann Polly's Retry-Richtlinie mit anderen Resilienzstrategien kombiniert werden?

Ja, Polly ermöglicht es, seine Retry-Richtlinie mit anderen Resilienzstrategien zu kombinieren, wie zum Beispiel einem Circuit Breaker, mithilfe der Policy.Wrap-Methode, um die Resilienz der Anwendung zu verbessern und wiederholte Wiederholungen zu verhindern, wenn ein Dienst konstant ausfällt.

Wie kann ich HTML in PDF in C# konvertieren?

Sie können die Methoden von IronPDF wie RenderHtmlAsPdf verwenden, um HTML-Strings in PDFs zu konvertieren. IronPDF unterstützt auch die Konvertierung von HTML-Dateien und Webseiten, einschließlich CSS, ins PDF-Format.

Warum ist Polly's Retry-Richtlinie wichtig für C#-Anwendungen?

Polly's Retry-Richtlinie ist entscheidend für die Behandlung vorübergehender Fehler in C#-Anwendungen, um Robustheit zu gewährleisten und die Benutzererfahrung zu verbessern, indem das System in der Lage ist, sich von vorübergehenden Ausfällen ohne Absturz zu erholen.

Wie können Retry-Strategien in einem PDF-Erstellungsprozess implementiert werden?

Beim Generieren von PDFs können Retry-Strategien mit Polly implementiert werden, um vorübergehende Fehler zu behandeln. Durch die Integration von Polly's Retry-Fähigkeiten mit IronPDF können Sie PDF-Operationen in Fällen von vorübergehenden Netzwerk- oder Dienstproblemen mehrmals versuchen.

Wie installiere ich eine C#-PDF-Bibliothek wie IronPDF?

IronPDF kann über den NuGet Package Manager mit dem Befehl Install-Package IronPdf installiert werden, wodurch Sie PDF-Dokumente innerhalb Ihrer C#-Anwendungen erstellen, bearbeiten und manipulieren können.

Welche Vorteile bietet IronPDF für die PDF-Erstellung?

IronPDF bietet leistungsstarke Funktionen zur Erstellung und Bearbeitung von PDF-Dokumenten in .NET-Anwendungen. Es unterstützt die Konvertierung von HTML, CSS und Webseiten in PDFs, das Hinzufügen von Text und Bildern und das Sichern von Dokumenten mit Verschlüsselung.

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