Jak mogę przekonwertować HTML na PDF w języku C#?

Możesz użyć metody RenderHtmlAsPdf biblioteki IronPDF do konwersji ciągów HTML na pliki PDF. Możesz również konwertować pliki HTML na pliki PDF za pomocą metody RenderHtmlFileAsPdf .

Dlaczego programowanie zdarzeniowe jest ważne w aplikacjach .NET?

Programowanie zdarzeniowe jest kluczowe w aplikacjach .NET, aby poprawić responsywność i zapewnić płynne doświadczenia użytkownika, pozwalając na asynchroniczne uruchamianie zadań bez blokowania głównego wątku.

Jak zainstalować niezbędne narzędzie do generowania PDF w projekcie .NET?

Można zainstalować IronPDF przez NuGet, uruchamiając polecenie 'Install-Package IronPdf' w konsoli Package Manager programu Visual Studio.

Jak zadeklarować zdarzenie w C#?

W C# zdarzenia są deklarowane z użyciem słowa kluczowego 'event', często z typem delegata, takim jak 'EventHandler'. Na przykład: public event EventHandler PdfGenerated; .

Co to jest delegat w obsłudze zdarzeń C#?

Delegat w C# to bezpieczny typowo wskaźnik funkcji, który pozwala zdefiniować metody, które mogą być wywołane w odpowiedzi na zdarzenie.

Jak można dodać metody do zdarzeń w C#?

Można dodawać metody do zdarzeń w C# dynamicznie w czasie wykonywania, używając składni '+=' do subskrypcji zdarzeń.

Jaki jest cel tworzenia niestandardowej klasy EventArgs?

Niestandardowa klasa EventArgs jest używana do przekazywania specyficznych dla zdarzenia danych, takich jak ścieżka pliku, do obsługi zdarzeń w sposób strukturalny i bezpieczny typowo.

Dlaczego warto używać BackgroundWorker do generowania dużych plików PDF?

Użycie BackgroundWorker pozwala na asynchroniczne uruchamianie zadań generowania PDF, zapobiegając blokowaniu interfejsu użytkownika i poprawiając doświadczenie użytkownika.

Jakie są wskazówki dotyczące pracy ze zdarzeniami w .NET?

Kluczowe wskazówki obejmują unikanie blokowania wątku interfejsu użytkownika, aktualizując UI tylko po zakończeniu zadań w tle, łagodne obsługiwanie wyjątków oraz wypisywanie się z obsługi zdarzeń, gdy nie są już potrzebne, aby zapobiec wyciekom pamięci.

Jakie są alternatywy dla używania obsługi zdarzeń w .NET?

Alternatywy obejmują użycie async/await i Task.Run dla nowszych przepływów pracy oraz IProgress dla aktualizacji w czasie rzeczywistym podczas długich operacji.

Biblioteka PDF dla C#

Explore IronPDF Bezpłatna próba

HTML do PDF

Online Demo Zobacz wszystkie przykłady kodu %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >

Install-Package IronPdf

AKTUALNOŚCI DLA PROGRAMISTÓW

C# Obsługa zdarzeń (Jak to działa dla deweloperów)

Jacob Mellor

Updated: 21 kwietnia 2026

W nowoczesnych aplikacjach .NET, programowanie zorientowane na zdarzenia odgrywa kluczową rolę w poprawie reaktywności i zapewnieniu płynnych doświadczeń użytkownika. Gdy zadania, takie jak generowanie PDF, zajmują czas, nie chcesz blokować głównego wątku. Zamiast tego możesz użyć obsług zdarzeń, aby uruchamiać zadania asynchronicznie i reagować, gdy wystąpi zdarzenie — czyniąc swoją aplikację bardziej interaktywną i reaktywną.

W tym przewodniku pokażemy, jak zintegrować metody obsługi zdarzeń w C# z IronPDF dla płynnych przepływów pracy PDF w środowiskach desktopowych i webowych. Czy używasz WinForms, WPF, czy dowolnej innej platformy opartej na języku C#, ten przewodnik Cię pokryje.

Konfigurowanie projektu IronPDF

Zanim zagłębimy się w obsługę zdarzeń, szybko skonfigurujmy IronPDF w twoim projekcie .NET.

Zainstaluj IronPDF przez NuGet

W konsoli Menedżera pakietów Visual Studio, uruchom:

PM > Install-Package IronPdf

Install-Package IronPdf

To zainstaluje wszystko, co potrzebne do rozpoczęcia generowania PDF za pomocą IronPDF.

Podstawowe generowanie PDF w IronPDF

Oto szybki przykład, aby upewnić się, że IronPDF działa:

using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
pdf.SaveAs("example.pdf");

using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
pdf.SaveAs("example.pdf");

Imports IronPdf
Private renderer = New ChromePdfRenderer()
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
pdf.SaveAs("example.pdf")

Imports IronPdf
Private renderer = New ChromePdfRenderer()
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
pdf.SaveAs("example.pdf")

Gdy to działa, jesteś gotowy, aby dodać pola zdarzeń, podłączyć zarejestrowane delegaty i używać typów delegatów do tworzenia przepływów pracy zorientowanych na zdarzenia.

Podstawy obslugi zdarzen w C# dla deweloperow .NET

Podstawy programowania zorientowanego na zdarzenia

Dzięki programowaniu zorientowanemu na zdarzenia, twoja aplikacja reaguje, gdy wystąpi zdarzenie, np. zakończenie generowania PDF. C# używa delegatów jako typowych wskaźników funkcji, umożliwiając ci zdefiniowanie, jak powinna reagować twoja aplikacja.

Zazwyczaj deklarujesz zdarzenia używając słowa kluczowego event, łączysz je z metodami obsługi zdarzeń i przekazujesz dane za pomocą niestandardowych podklas EventArgs.

Declaruj zdarzenie przy użyciu słowa kluczowego event

C# używa słowa kluczowego event do deklarowania członków zdarzeń. Na przykład:

public event EventHandler PdfGenerated;

public event EventHandler PdfGenerated;

Public Event PdfGenerated As EventHandler

Public Event PdfGenerated As EventHandler

Ta linia deklaruje pole zdarzenia nazwane PdfGenerated. Używa EventHandler, wbudowanego delegata z następującymi parametrami: (object sender, EventArgs e) — często nazywanego wzorcem nazewniczym dla zdarzeń w .NET.

Definiowanie i subskrypcja zdarzen w C#

Dodawaj metody do zdarzeń przy użyciu delegatów

Zdarzenia w C# obsługują dodawanie metod dynamicznie w czasie wykonywania przy użyciu składni +=. Oto jak to zrobić:

pdfService.PdfGenerated += (s, e) =>
{
    Console.WriteLine("PDF was generated!");
};

pdfService.PdfGenerated += (s, e) =>
{
    Console.WriteLine("PDF was generated!");
};

AddHandler pdfService.PdfGenerated, Sub(s, e)
	Console.WriteLine("PDF was generated!")
End Sub

AddHandler pdfService.PdfGenerated, Sub(s, e)
	Console.WriteLine("PDF was generated!")
End Sub

Ta klasa subskrybenta nasłuchuje zdarzenia PdfGenerated i wykonuje wywołanie metody, gdy zdarzenie zostanie wyzwolone.

Dane zdarzenia niestandardowego

Aby przekazać dane zdarzeń, takie jak wygenerowana ścieżka pliku, zdefiniuj klasę pochodną od EventArgs:

public class PdfGeneratedEventArgs : EventArgs
{
    public string FilePath { get; set; } // returned value
}

public class PdfGeneratedEventArgs : EventArgs
{
    public string FilePath { get; set; } // returned value
}

Public Class PdfGeneratedEventArgs
	Inherits EventArgs

	Public Property FilePath() As String ' -  returned value
End Class

Public Class PdfGeneratedEventArgs
	Inherits EventArgs

	Public Property FilePath() As String ' -  returned value
End Class

Następnie zdefiniuj ponownie zdarzenie przy użyciu ogólnego typu delegata:

public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;

public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;

Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)

Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)

To daje ci zorganizowane, typowane dane, gdy zdarzenie zostanie wyzwolone, czyniąc twoją logikę reakcji bardziej potężną.

Obsługa wielu zdarzeń

Możesz zdefiniować wiele zdarzeń:

public event EventHandler PdfGenerationStarted;
public event EventHandler<PdfGeneratedEventArgs> PdfGenerationCompleted;

public event EventHandler PdfGenerationStarted;
public event EventHandler<PdfGeneratedEventArgs> PdfGenerationCompleted;

Public Event PdfGenerationStarted As EventHandler
Public Event PdfGenerationCompleted As EventHandler(Of PdfGeneratedEventArgs)

Public Event PdfGenerationStarted As EventHandler
Public Event PdfGenerationCompleted As EventHandler(Of PdfGeneratedEventArgs)

Każde pole zdarzenia jest obsługiwane przez klasę subskrybenta, umożliwiając różne metody obsługi zdarzeń na każdym etapie. To rozdzielenie obowiązków ma sens w złożonych przepływach pracy.

Używanie obsług zdarzeń z IronPDF

Podczas generowania dużych PDF, ma sens uruchomienie IronPDF na wątku w tle i powiadamianie interfejsu użytkownika po zakończeniu. Oto, jak projektowanie zorientowane na zdarzenia może pomóc:

Używaj BackgroundWorker do asynchronicznego generowania PDF
Wywołuj zdarzenia, gdy każdy etap się zakończy
Przekaż dane rezultatów przy użyciu obiektów danych zdarzeń

Przykład kodu – Asynchroniczne generowanie PDF

Poniższy przykład to pełny kod do używania obsługi zdarzeń z IronPDF:

using System;
using System.ComponentModel;
using IronPdf;
namespace IronPdfEventHandlerExample
{
    // 1. Define custom EventArgs to carry event data
    public class PdfGeneratedEventArgs : EventArgs
    {
        public string FilePath { get; set; }
    }
    // 2. Main class with event, BackgroundWorker, and logic
    public class PdfGenerator
    {
        // Declare the public event using EventHandler<t>
        public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;
        private readonly BackgroundWorker _worker;
        public PdfGenerator()
        {
            _worker = new BackgroundWorker();
            _worker.DoWork += OnDoWork;
            _worker.RunWorkerCompleted += OnRunWorkerCompleted;
        }
        // Start the async operation
        public void GenerateAsync(string html, string outputPath)
        {
            _worker.RunWorkerAsync(new Tuple<string, string>(html, outputPath));
        }
        // Perform PDF generation in background
        private void OnDoWork(object sender, DoWorkEventArgs e)
        {
            var (html, path) = (Tuple<string, string>)e.Argument;
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs(path);
            e.Result = path;
        }
        // Notify subscribers when the PDF is ready
        private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var path = e.Result as string;
            PdfGenerated?.Invoke(this, new PdfGeneratedEventArgs { FilePath = path });
        }
    }
    // 3. Program to wire it all together
    class Program
    {
        public static void Main(string[] args)
        {
            var generator = new PdfGenerator();
            // Subscribe to the PdfGenerated event
            generator.PdfGenerated += OnPdfGenerated;
            Console.WriteLine("Generating PDF asynchronously...");
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf");
            Console.WriteLine("Press any key to exit after generation.");
            Console.ReadKey();
        }
        // Event handler for when the PDF is ready
        static void OnPdfGenerated(object sender, PdfGeneratedEventArgs e)
        {
            Console.WriteLine($"PDF generated at: {e.FilePath}");
        }
    }
}

using System;
using System.ComponentModel;
using IronPdf;
namespace IronPdfEventHandlerExample
{
    // 1. Define custom EventArgs to carry event data
    public class PdfGeneratedEventArgs : EventArgs
    {
        public string FilePath { get; set; }
    }
    // 2. Main class with event, BackgroundWorker, and logic
    public class PdfGenerator
    {
        // Declare the public event using EventHandler<t>
        public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;
        private readonly BackgroundWorker _worker;
        public PdfGenerator()
        {
            _worker = new BackgroundWorker();
            _worker.DoWork += OnDoWork;
            _worker.RunWorkerCompleted += OnRunWorkerCompleted;
        }
        // Start the async operation
        public void GenerateAsync(string html, string outputPath)
        {
            _worker.RunWorkerAsync(new Tuple<string, string>(html, outputPath));
        }
        // Perform PDF generation in background
        private void OnDoWork(object sender, DoWorkEventArgs e)
        {
            var (html, path) = (Tuple<string, string>)e.Argument;
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs(path);
            e.Result = path;
        }
        // Notify subscribers when the PDF is ready
        private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var path = e.Result as string;
            PdfGenerated?.Invoke(this, new PdfGeneratedEventArgs { FilePath = path });
        }
    }
    // 3. Program to wire it all together
    class Program
    {
        public static void Main(string[] args)
        {
            var generator = new PdfGenerator();
            // Subscribe to the PdfGenerated event
            generator.PdfGenerated += OnPdfGenerated;
            Console.WriteLine("Generating PDF asynchronously...");
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf");
            Console.WriteLine("Press any key to exit after generation.");
            Console.ReadKey();
        }
        // Event handler for when the PDF is ready
        static void OnPdfGenerated(object sender, PdfGeneratedEventArgs e)
        {
            Console.WriteLine($"PDF generated at: {e.FilePath}");
        }
    }
}

Imports System
Imports System.ComponentModel
Imports IronPdf

Namespace IronPdfEventHandlerExample

    ' 1. Define custom EventArgs to carry event data
    Public Class PdfGeneratedEventArgs
        Inherits EventArgs

        Public Property FilePath As String
    End Class

    ' 2. Main class with event, BackgroundWorker, and logic
    Public Class PdfGenerator

        ' Declare the public event using EventHandler(Of T)
        Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)
        Private ReadOnly _worker As BackgroundWorker

        Public Sub New()
            _worker = New BackgroundWorker()
            AddHandler _worker.DoWork, AddressOf OnDoWork
            AddHandler _worker.RunWorkerCompleted, AddressOf OnRunWorkerCompleted
        End Sub

        ' Start the async operation
        Public Sub GenerateAsync(html As String, outputPath As String)
            _worker.RunWorkerAsync(Tuple.Create(html, outputPath))
        End Sub

        ' Perform PDF generation in background
        Private Sub OnDoWork(sender As Object, e As DoWorkEventArgs)
            Dim args = DirectCast(e.Argument, Tuple(Of String, String))
            Dim html = args.Item1
            Dim path = args.Item2
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(path)
            e.Result = path
        End Sub

        ' Notify subscribers when the PDF is ready
        Private Sub OnRunWorkerCompleted(sender As Object, e As RunWorkerCompletedEventArgs)
            Dim path = TryCast(e.Result, String)
            RaiseEvent PdfGenerated(Me, New PdfGeneratedEventArgs With {.FilePath = path})
        End Sub
    End Class

    ' 3. Program to wire it all together
    Module Program

        Sub Main(args As String())
            Dim generator = New PdfGenerator()
            ' Subscribe to the PdfGenerated event
            AddHandler generator.PdfGenerated, AddressOf OnPdfGenerated
            Console.WriteLine("Generating PDF asynchronously...")
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf")
            Console.WriteLine("Press any key to exit after generation.")
            Console.ReadKey()
        End Sub

        ' Event handler for when the PDF is ready
        Private Sub OnPdfGenerated(sender As Object, e As PdfGeneratedEventArgs)
            Console.WriteLine($"PDF generated at: {e.FilePath}")
        End Sub
    End Module

End Namespace

Imports System
Imports System.ComponentModel
Imports IronPdf

Namespace IronPdfEventHandlerExample

    ' 1. Define custom EventArgs to carry event data
    Public Class PdfGeneratedEventArgs
        Inherits EventArgs

        Public Property FilePath As String
    End Class

    ' 2. Main class with event, BackgroundWorker, and logic
    Public Class PdfGenerator

        ' Declare the public event using EventHandler(Of T)
        Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)
        Private ReadOnly _worker As BackgroundWorker

        Public Sub New()
            _worker = New BackgroundWorker()
            AddHandler _worker.DoWork, AddressOf OnDoWork
            AddHandler _worker.RunWorkerCompleted, AddressOf OnRunWorkerCompleted
        End Sub

        ' Start the async operation
        Public Sub GenerateAsync(html As String, outputPath As String)
            _worker.RunWorkerAsync(Tuple.Create(html, outputPath))
        End Sub

        ' Perform PDF generation in background
        Private Sub OnDoWork(sender As Object, e As DoWorkEventArgs)
            Dim args = DirectCast(e.Argument, Tuple(Of String, String))
            Dim html = args.Item1
            Dim path = args.Item2
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(path)
            e.Result = path
        End Sub

        ' Notify subscribers when the PDF is ready
        Private Sub OnRunWorkerCompleted(sender As Object, e As RunWorkerCompletedEventArgs)
            Dim path = TryCast(e.Result, String)
            RaiseEvent PdfGenerated(Me, New PdfGeneratedEventArgs With {.FilePath = path})
        End Sub
    End Class

    ' 3. Program to wire it all together
    Module Program

        Sub Main(args As String())
            Dim generator = New PdfGenerator()
            ' Subscribe to the PdfGenerated event
            AddHandler generator.PdfGenerated, AddressOf OnPdfGenerated
            Console.WriteLine("Generating PDF asynchronously...")
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf")
            Console.WriteLine("Press any key to exit after generation.")
            Console.ReadKey()
        End Sub

        ' Event handler for when the PDF is ready
        Private Sub OnPdfGenerated(sender As Object, e As PdfGeneratedEventArgs)
            Console.WriteLine($"PDF generated at: {e.FilePath}")
        End Sub
    End Module

End Namespace

Wynik konsoli

Obsluga zdarzen w C# (Jak to dziala dla deweloperow): Rysunek 1 - Konsolowy wynik

Wynik w formacie PDF

Obsluga zdarzen w C# (Jak to dziala dla deweloperow): Rysunek 2 - Wynik w formacie PDF

Kluczowe cechy w tym kodzie

public event EventHandler<PdfGeneratedEventArgs>: Deklaruje zdarzenie z silnym typowaniem
PdfGeneratedEventArgs: Niestandardowa klasa dla danych zdarzenia
BackgroundWorker: Pozwala na asynchroniczne wykonanie, aby uniknac blokowania interfejsu uzytkownika
?.Invoke(...): Bezpieczne wywolanie zdarzenia
Tuple<string, string>: Przekazuje HTML i sciezke wyjsciowa do watku w tle

Wskazówki dotyczące pracy ze zdarzeniami w .NET

1. Unikaj blokowania wątku UI

Używaj obsług zdarzeń takich jak RunWorkerCompleted, aby aktualizować interfejs użytkownika tylko po zakończeniu zadań w tle.

2. Obsłuż wyjątki z wdziękiem

Owiń swoją logikę pracy w bloki try-catch wewnątrz DoWork i przekaż wyjątki do RunWorkerCompleted za pośrednictwem e.Error.

if (e.Error != null)
{
    MessageBox.Show("Error: " + e.Error.Message);
}

if (e.Error != null)
{
    MessageBox.Show("Error: " + e.Error.Message);
}

If e.Error IsNot Nothing Then
	MessageBox.Show("Error: " & e.Error.Message)
End If

If e.Error IsNot Nothing Then
	MessageBox.Show("Error: " & e.Error.Message)
End If

3. Odsubskrybuj, gdy to konieczne

W długotrwałych aplikacjach, odsubskrybuj zdarzenia, gdy nie są już potrzebne, aby uniknąć wycieków pamięci:

pdfWorker.DoWork -= PdfWorker_DoWork;

pdfWorker.DoWork -= PdfWorker_DoWork;

pdfWorker.DoWork -= PdfWorker_DoWork

pdfWorker.DoWork -= PdfWorker_DoWork

Podsumowanie

Używanie obsług zdarzeń, typów delegatów i pól zdarzeń z IronPDF dodaje reaktywnego, nowoczesnego akcentu do aplikacji .NET. Czy generujesz dokumenty w klasie bazowej, tworzysz logikę do ponownego użycia w klasach pochodnych, czy po prostu eksplorujesz model zdarzeń .NET, ten wzorzec jest skalowalny i czysty.

Kiedy używać tego podejścia

Chcesz wywołać zdarzenie po zakończeniu zadania
Potrzebujesz czystego rozdzielenia między logiką a interfejsem użytkownika
Pracujesz z BackgroundWorker, zdarzeniami i delegatami
Wolisz mechanikę typowanych wskaźników funkcji C#

Alternatywy do eksploracji

async/await i Task.Run dla nowszych przeplywow pracy
IProgress<t> dla aktualizacji w czasie rzeczywistym podczas dlugotrwalych operacji, IronPDF w polaczeniu z wydarzeniami C# ulatwia tworzenie wydajnych, responsywnych aplikacji generujacych PDF-y, z mysla o realnej uzytecznosci. Gotowy, aby wdrożyć generowanie PDF zorientowane na zdarzenia w swojej aplikacji .NET? Wypróbuj to z bezpłatną wersją próbną IronPDF i zadowol swoich użytkowników płynnymi, nieblokującymi doświadczeniami!

Jacob Mellor

Czat z zespołem inżynierów teraz

Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.

...

Czytaj więcej